Google官方MVP+Dagger2架构详解

1 前言

2 Dagger2基础

2.1 什么是Dagger2

2.2 Dagger2的优点

@inject

public class MainActivity extends Activity {
@Inject MyTwitterApiClient mTwitterApiClient;
@Inject SharedPreferences sharedPreferences;

public void onCreate(Bundle savedInstance) {
// assign singleton instances to fields
InjectorClass.inject(this);
}

2.3 Dagger2的引用

build.gradle

dependencies {
// other classpath definitions here
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}

app/build.gradle

// add after applying plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt'

dependencies {
// apt command comes from the android-apt plugin
apt 'com.google.dagger:dagger-compiler:2.2'
compile 'com.google.dagger:dagger:2.2'
provided 'javax.annotation:jsr250-api:1.0'
}

provided

apt

2.4 创建单例（singleton）

@Provides

OkHttpClient client = new OkHttpClient();

// Enable caching for OkHttp
int cacheSize = 10 * 1024 * 1024; // 10 MiB
Cache cache = new Cache(getApplication().getCacheDir(), cacheSize);
client.setCache(cache);

// Used for caching authentication tokens
SharedPreferences sharedPrefeences = PreferenceManager.getDefaultSharedPreferences(this);

// Instantiate Gson
Gson gson = new GsonBuilder().create();
GsonConverterFactory converterFactory = GsonConverterFactory.create(Gson);

// Build Retrofit
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com")
.addConverterFactory(converterFactory)
.client(client)  // custom client
.build();

AppModule.java

@Module

@Provides

@Singleton

@Module
public class AppModule {

Application mApplication;

public AppModule(Application application) {
mApplication = application;
}

@Provides
@Singleton
Application providesApplication() {
return mApplication;
}
}

@Module

@Provides

@Singleton

@Module
public class NetModule {

String mBaseUrl;

// Constructor needs one parameter to instantiate.
public NetModule(String baseUrl) {
this.mBaseUrl = baseUrl;
}

// Dagger will only look for methods annotated with @Provides
@Provides
@Singleton
// Application reference must come from AppModule.class
SharedPreferences providesSharedPreferences(Application application) {
return PreferenceManager.getDefaultSharedPreferences(application);
}

@Provides
@Singleton
Cache provideOkHttpCache(Application application) {
int cacheSize = 10 * 1024 * 1024; // 10 MiB
Cache cache = new Cache(application.getCacheDir(), cacheSize);
return cache;
}

@Provides
@Singleton
Gson provideGson() {
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES);
return gsonBuilder.create();
}

@Provides
@Singleton
OkHttpClient provideOkHttpClient(Cache cache) {
OkHttpClient client = new OkHttpClient();
client.setCache(cache);
return client;
}

@Provides
@Singleton
Retrofit provideRetrofit(Gson gson, OkHttpClient okHttpClient) {
Retrofit retrofit = new Retrofit.Builder()
.addConverterFactory(GsonConverterFactory.create(gson))
.baseUrl(mBaseUrl)
.client(okHttpClient)
.build();
return retrofit;
}
}

@Module

@Provide

@Singleton

@inject

@inject

MyTwitterApiClient

SharedPreferences

public class MainActivity extends Activity {
@Inject MyTwitterApiClient mTwitterApiClient;
@Inject SharedPreferences sharedPreferences;

public void onCreate(Bundle savedInstance) {
// assign singleton instances to fields
InjectorClass.inject(this);
}

提供<->关联<->使用

@Component

AppModule.class,
NetModule.class

@Singleton
@Component(modules={AppModule.class, NetModule.class})
public interface NetComponent {
void inject(MainActivity activity);
// void inject(MyFragment fragment);
// void inject(MyService service);
}

@Component

DaggerNetComponent
.java

@Inject

2.5 初始化组件（Instantiating the component）

public class MyApp extends Application {

private NetComponent mNetComponent;

@Override
public void onCreate() {
super.onCreate();

// Dagger%COMPONENT_NAME%
mNetComponent = DaggerNetComponent.builder()
// list of modules that are part of this component need to be created here too
.appModule(new AppModule(this)) // This also corresponds to the name of your module: %component_name%Module
.netModule(new NetModule("https://api.github.com"))
.build();

// If a Dagger 2 component does not have any constructor arguments for any of its modules,
// then we can use .create() as a shortcut instead:
//  mAppComponent = com.codepath.dagger.components.DaggerNetComponent.create();
}

public NetComponent getNetComponent() {
return mNetComponent;
}
}

NetComponent

DaggerNetComponent

appModule

netModule

Application

AndroidManifest.xml

<application
android:allowBackup="true"
android:name=".MyApp">

Application

MyApp

InjectorClass.inject(this);

public class MyActivity extends Activity {
@Inject OkHttpClient mOkHttpClient;
@Inject SharedPreferences sharedPreferences;

public void onCreate(Bundle savedInstance) {
// assign singleton instances to fields
// We need to cast to `MyApp` in order to get the right method
((MyApp) getApplication()).getNetComponent().inject(this);
}

Dagger2的使用还有一些注意点。包括下面的限定类型，作用域，组建依赖，以及子组件。

2.6 限定类型（Qualified types）

@Named

@Provides

@Inject

@Named

@Named

@Provides @Named("cached")
@Singleton
OkHttpClient provideOkHttpClient(Cache cache) {
OkHttpClient client = new OkHttpClient();
client.setCache(cache);
return client;
}

@Provides @Named("non_cached")
@Singleton
OkHttpClient provideOkHttpClient() {
OkHttpClient client = new OkHttpClient();
return client;
}

@Inject @Named("cached") OkHttpClient client;
@Inject @Named("non_cached") OkHttpClient client2;

@Named

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface DefaultPreferences {
}

2.7 作用域（Scopes）

@Singleton

@Provides

@Scope
@Documented
@Retention(value=RUNTIME)
public @interface MyActivityScope

/** * In Dagger, an unscoped component cannot depend on a scoped component. As
* {@link edu.com.app.injection.component.ApplicationComponent} is a scoped component ({@code @Singleton}, we create a custom
* scope to be used by all fragment components. Additionally, a component with a specific scope
* cannot have a sub component with the same scope. */

ApplicationComponent

Singleton

2.8 组件依赖（Component Dependencies）

@Singleton

@Singleton
@Component(modules={AppModule.class, NetModule.class})
public interface NetComponent {
// downstream components need these exposed with the return type
// method name does not really matter
Retrofit retrofit();
}

2.9 子组件（Subcomponents）

@Module
public class MyActivityModule {
private final MyActivity activity;
public MyActivityModule(MyActivity activity) { this.activity = activity; }

@Provides @MyActivityScope @Named("my_list")
public ArrayAdapter providesMyListAdapter() {
return new ArrayAdapter<String>(activity, android.R.layout.my_list);
}
...
}

@MyActivityScope
@Subcomponent(modules={ MyActivityModule.class })
public interface MyActivitySubComponent {
@Named("my_list") ArrayAdapter myListAdapter();
}

@Singleton
@Component(modules={ ... })
public interface MyApplicationComponent {
MyActivitySubComponent newMyActivitySubcomponent(MyActivityModule activityModule);
}

newMyActivitySubcomponent()

public class MyActivity extends Activity {
@Inject ArrayAdapter arrayAdapter;

public void onCreate(Bundle savedInstance) {
// assign singleton instances to fields
// We need to cast to `MyApp` in order to get the right method
((MyApp) getApplication()).getApplicationComponent())
.newMyActivitySubcomponent(new MyActivityModule(this))
.inject(this);
}
}

3 google官方MVP架构回顾

4 Google官方架构MVP+Dagger2架构详解

4.1 对比

ApplicationModule

ToDoApplication

XXXComponent

XXXPresenterModule

4.2 分析

ToDoApplication

TasksRepositoryComponent

public class ToDoApplication extends Application {

private TasksRepositoryComponent mRepositoryComponent;

@Override
public void onCreate() {
super.onCreate();

mRepositoryComponent = DaggerTasksRepositoryComponent.builder()
.applicationModule(new ApplicationModule((getApplicationContext())))
.tasksRepositoryModule(new TasksRepositoryModule()).build();
}

public TasksRepositoryComponent getTasksRepositoryComponent() {
return mRepositoryComponent;
}
}

DaggerTasksRepositoryComponent

TasksRepositoryComponent

ApplicationModule

TasksRepositoryModule

TasksRepository

ApplicationModule

@Module
public final class ApplicationModule {

private final Context mContext;

ApplicationModule(Context context) {
mContext = context;
}
@Provides
Context provideContext() {
return mContext;
}
}

ToDoApplication

onCreate

getApplicationContext()

provideContext()

TasksRepositoryModule

@Module
public class TasksRepositoryModule {

@Singleton
@Provides
@Local
TasksDataSource provideTasksLocalDataSource(Context context) {
return new TasksLocalDataSource(context);
}

@Singleton
@Provides
@Remote
TasksDataSource provideTasksRemoteDataSource() {
return new FakeTasksRemoteDataSource();
}
}

TasksDataSource

TasksRepositoryComponent

ToDoApplication

@Singleton
@Component(modules = {TasksRepositoryModule.class, ApplicationModule.class})
public interface TasksRepositoryComponent {

TasksRepository getTasksRepository();
}

ToDoApplication

TasksRepositoryModule.class

ApplicationModule.class

ToDoApplication

@Inject

@Module

@Module

@Inject

TaskDetailComponent

@FragmentScoped
@Component(dependencies = TasksRepositoryComponent.class, modules = TaskDetailPresenterModule.class)
public interface TaskDetailComponent {

void inject(TaskDetailActivity taskDetailActivity);
}

@Documented
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface FragmentScoped {
}

TasksRepositoryComponent.class

TaskRespository

TasksRepositoryComponent

@Singleton

FragmentScoped

TaskDetailComponent

TaskDetailPresenterModule.class

@Module
public class TaskDetailPresenterModule {

private final TaskDetailContract.View mView;

private final String mTaskId;

public TaskDetailPresenterModule(TaskDetailContract.View view, String taskId) {
mView = view;
mTaskId = taskId;
}

@Provides
TaskDetailContract.View provideTaskDetailContractView() {
return mView;
}

@Provides
String provideTaskId() {
return mTaskId;
}
}

TaskDetailContract.View

TaskDetailActivity

public class TaskDetailActivity extends AppCompatActivity {
@Inject TaskDetailPresenter mTaskDetailPresenter;

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

if (taskDetailFragment == null) {
taskDetailFragment = TaskDetailFragment.newInstance(taskId);

ActivityUtils.addFragmentToActivity(getSupportFragmentManager(),
taskDetailFragment, R.id.contentFrame);
}

// Create the presenter
DaggerTaskDetailComponent.builder()
.taskDetailPresenterModule(new TaskDetailPresenterModule(taskDetailFragment, taskId))
.tasksRepositoryComponent(((ToDoApplication) getApplication())
.getTasksRepositoryComponent()).build()
.inject(this);
}
......
}

TaskDetailPresenter

final class TaskDetailPresenter implements TaskDetailContract.Presenter {

private TasksRepository mTasksRepository;//Model

private TaskDetailContract.View mTaskDetailView;//View

/**
* Dagger strictly enforces that arguments not marked with {@code @Nullable} are not injected
* with {@code @Nullable} values.
*/
@Nullable String mTaskId;
/**
* Dagger strictly enforces that arguments not marked with {@code @Nullable} are not injected
* with {@code @Nullable} values.
*/
@Inject
TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository,
TaskDetailContract.View taskDetailView) {
mTasksRepository = tasksRepository;
mTaskDetailView = taskDetailView;
mTaskId = taskId;
}

/**
* Method injection is used here to safely reference {@code this} after the object is created.
* For more information, see Java Concurrency in Practice.
*/
@Inject
void setupListeners() {
mTaskDetailView.setPresenter(this);
}
...Presenter中的操作...
}

5 Dagger2添加步骤：

ApplicationModule

DaggerTaskDetailComponent

TaskDetailPresenterModule

mRepositoryComponent = DaggerTasksRepositoryComponent.builder()
.applicationModule(new ApplicationModule((getApplicationContext())))
.tasksRepositoryModule(new TasksRepositoryModule()).build();

TaskDetailPresenter

@Provides

ApplicationModule.java

@Inject

Component.inject()

TaskDetailActivity

getApplicationComponent()