Presention层:
整个应用启动的时候，就执行依赖的初始化。编译项目之后，Dagger依赖框架使用ApplicationComponent生成一个DaggerApplicationCOmponent。
1. 首先进行依赖的生成
在Application中，调用initializeInjector()就会促使Dagger框架进行依赖生成。
ApplicationComponent
对其它Component提供Context,ThreadExecutor,PostExecutionThread,UserRepository依赖
/**
* A component whose lifetime is the life of the application.
*/
@Singleton // Constraints this component to one-per-application or unscoped bindings.
@Component(modules = ApplicationModule.class)
public interface ApplicationComponent {
void inject(BaseActivity baseActivity);
//Exposed to sub-graphs.
Context context();
ThreadExecutor threadExecutor();
PostExecutionThread postExecutionThread();
UserRepository userRepository();
}
ApplicationModule
/**
* Dagger module that provides objects which will live during the application lifecycle.
*/
@Module
public class ApplicationModule {
private final AndroidApplication application;
public ApplicationModule(AndroidApplication application) {
this.application = application;
}
@Provides @Singleton Context provideApplicationContext() {
return this.application;
}
@Provides @Singleton Navigator provideNavigator() {
return new Navigator();
}
@Provides @Singleton ThreadExecutor provideThreadExecutor(JobExecutor jobExecutor) {
return jobExecutor;
}
@Provides @Singleton PostExecutionThread providePostExecutionThread(UIThread uiThread) {
return uiThread;
}
@Provides @Singleton UserCache provideUserCache(UserCacheImpl userCache) {
return userCache;
}
@Provides @Singleton UserRepository provideUserRepository(UserDataRepository userDataRepository) {
return userDataRepository;
}
}
在这个类中，提供了生成依赖的方法。
需要参数的provide方法，参数也是通过Dagger依赖框架生成的。
参数JobExecutor(data模块)，UIThread(presentation模块),UserCacheImpl(data模块),UserDataRepository(data模块)生成的方式，是Dagger依赖框架调用相应类的构造方法实现的，而不是通过provide实现的。
比如
JobExecutor(data模块):
public class JobExecutor implements ThreadExecutor {
@Inject
public JobExecutor() {
this.workQueue = new LinkedBlockingQueue<>();
this.threadFactory = new JobThreadFactory();
this.threadPoolExecutor = new ThreadPoolExecutor(INITIAL_POOL_SIZE, MAX_POOL_SIZE,
KEEP_ALIVE_TIME, KEEP_ALIVE_TIME_UNIT, this.workQueue, this.threadFactory);
}
...
}
属于data模块的:参数JobExecutor(data模块),UserCacheImpl(data模块),UserDataRepository(data模块)
Application:
/**
* Android Main Application
*/
public class AndroidApplication extends Application {
private ApplicationComponent applicationComponent;
@Override public void onCreate() {
super.onCreate();
this.initializeInjector();
}
private void initializeInjector() {
this.applicationComponent = DaggerApplicationComponent.builder()
.applicationModule(new ApplicationModule(this))
.build();
}
public ApplicationComponent getApplicationComponent() {
return this.applicationComponent;
}
}
2.MainActivity实现
使用ButterKnife对View对象进行注入，从而无需写findViewById。
2.1继承BaseActivity，BaseActivity的实现
A.
声明了一个带有Inject注解的成员Navigator
在onCreate方法中，将Navigator依赖注入到当前实例。
B.
提供三个protected方法，一个是用来添加fragment到当前界面的某个位置；两个是用来进行依赖注入的。
2.2 MainActivity执行流程
用户点击R.id.btn_LoadData Button，就会跳转到界面UserListActivity.
3.UserListActivity实现
A.
界面加载，使用UserListFragment。
B.
在onCreate方法中，执行UserComponent包含的依赖初始化。
private void initializeInjector() {
this.userComponent = DaggerUserComponent.builder()
.applicationComponent(getApplicationComponent())
.activityModule(getActivityModule())
.build();
}
UserComponent生成的依赖，被注入到UserListFragment,UserDetailsFragment。UserListFragment,UserDetailsFragment调用UserComponent实例的inject方法。
UserComponent如下：
可以注入到UserListFragment,UserDetailsFragment的依赖是GetUserListUseCase,GetUserDetailsUseCase。
,
,
/**
* A scope {@link com.fernandocejas.android10.sample.presentation.internal.di.PerActivity} component.
* Injects user specific Fragments.
*/
@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = {ActivityModule.class, UserModule.class})
public interface UserComponent extends ActivityComponent {
void inject(UserListFragment userListFragment);
void inject(UserDetailsFragment userDetailsFragment);
}
/**
* A base component upon which fragment's components may depend.
* Activity-level components should extend this component.
*
* Subtypes of ActivityComponent should be decorated with annotation:
* {@link com.fernandocejas.android10.sample.presentation.internal.di.PerActivity}
*/
@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class)
public interface ActivityComponent {
//Exposed to sub-graphs.
Activity activity();
}
/**
* A module to wrap the Activity state and expose it to the graph.
*/
@Module
public class ActivityModule {
private final Activity activity;
public ActivityModule(Activity activity) {
this.activity = activity;
}
/**
* Expose the activity to dependents in the graph.
*/
@Provides @PerActivity Activity activity() {
return this.activity;
}
}
/**
* Dagger module that provides user related collaborators.
*/
@Module
public class UserModule {
private int userId = -1;
public UserModule() {}
public UserModule(int userId) {
this.userId = userId;
}
@Provides @PerActivity @Named("userList") UseCase provideGetUserListUseCase(
GetUserListUseCase getUserListUseCase) {
return getUserListUseCase;
}
@Provides @PerActivity @Named("userDetails") UseCase provideGetUserDetailsUseCase(
UserRepository userRepository, ThreadExecutor threadExecutor,
PostExecutionThread postExecutionThread) {
return new GetUserDetailsUseCase(userId, userRepository, threadExecutor, postExecutionThread);
}
}
4.UserListFragment的实现
A.
UserListFragment实现UserListView接口，用来表示View层。
B.
UserListFragment跟宿主Activity的通信，通过UserListFragment声明的接口UserListListener来实现。
@Override public void onAttach(Activity activity) {
super.onAttach(activity);
if (activity instanceof UserListListener) {
this.userListListener = (UserListListener) activity;
}
}
C.
当宿主Activity创建成功之后，回调方法:
@Override public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
this.initialize();
this.loadUserList();
}
在UserListFragment类中，使用Inject注解，声明了一个成员@Inject UserListPresenter userListPresenter;
然后，调用UserComponent实例的方法inject，就可以将依赖userListPresenter注入到UserListFragment实例中。
调用userListPresenter的方法setView，建立Presenter和View之间的关系。
private void initialize() {
this.getComponent(UserComponent.class).inject(this);
this.userListPresenter.setView(this);
}
调用loadUserList方法，会加载所有用户数据。
/**
* Loads all users.
*/
private void loadUserList() {
this.userListPresenter.initialize();
}
界面的数据加载操作，都被封装在userListPresenter的initalize方法中。展示界面加载效果；执行获取数据操作；数据加载成功之后，显示对应的界面。这些都由userListPresenter来实现和控制。
5.UserListPresenter
A.
调用构造方法，构造方法的参数，由Dagger注入。
@Inject
public UserListPresenter(@Named("userList") UseCase getUserListUserCase, UserModelDataMapper userModelDataMapper) {
this.getUserListUseCase = getUserListUserCase;
this.userModelDataMapper = userModelDataMapper;
}
B.
提供initialize方法，供其它类调用。调用该方法，展示界面加载效果；获取所有用户数据。
/**
* Initializes the presenter by start retrieving the user list.
*/
public void initialize() {
this.loadUserList();
}
/**
* Loads all users.
*/
private void loadUserList() {
this.hideViewRetry();
this.showViewLoading();
this.getUserList();
}
private void getUserList() {
this.getUserListUseCase.execute(this); //这里使用到了domain层上的类，domain层提供用例类。一个用例类表示一个表示一个业务，在这里表示获取用户列表。
}
6.UserListPresenter和UseCase的协作
UserListPresenter和UseCase的协作，使用
The RxJava Android Module 框架
1.UserListPresenter属于Presention层，它依赖domain层和data层。
2.UseCase是domain层，它的实例是GetUserListUseCase，这个是由Presention层中的依赖定义包指定的，如下：
com.fernandocejas.android10.sample.presentation.internal.di.modules.UserModule:
@Provides @PerActivity @Named("userList") UseCase provideGetUserListUseCase(
GetUserListUseCase getUserListUseCase) {
return getUserListUseCase;
}
-----
所以，GetUserListUseCase是必须是可注入的，要在其构造函数中添加@Inject注解。
3.UserListPresenter和GetUserListUseCase，UserListPresenter是一个订阅者；这个订阅者订阅的流是CloudUserDataStore实例的方法getUseEntityList()产出来之后，经过映射的流，
该流是长这个样子的：
@Override public Observable<List<User>> getUsers() {
//we always get all users from the cloud
final UserDataStore userDataStore = this.userDataStoreFactory.createCloudDataStore();
return userDataStore.getUserEntityList().map(userListEntityMapper);
}
总结牵涉到的类及所在的层：
presentation层：UserListPresenter。
domain层: GetUseerListUseCase,UseCase
data层:UserDataRepository,CloudUserDataStore,UserDataStoreFactory
presentation层依赖domain层和data层。
7.整个项目使用到的框架技术
1.Dagger依赖生成，定义依赖的生成规则。
2.RxAndroid 响应式编程范式的应用，用事件流的方式来处理异步事件。
3.okHttp，网络请求应用到该框架。
8.整个项目阅读下来，可以学习到的东西
1.使用依赖注入，一个实例包含其它实例，在获取其它实例的使用，使用依赖注入，不将其它实例的生成方式暴露出去。这样，使用者只关注使用，无需关注怎样实例化，其它实例实例化的过程对使用者隐藏掉。
2.分层，分模块，这个要针对功能的含义来划分，根据关注点来划分。
presentation层，我们只关注界面展示，我们在这一层里面，我们只需要关注界面展示方面的代码，我们只放界面展示代码在这一层上，还有依赖生成的代码。在这层，我们重点只关注界面代码，还有依赖生成的规则。
domain层，领域层，用例层，从这个模块中包的命名就可以知道，它表示抽象程度高的业务，与系统平台无关的业务。在这个应用中，有两个业务，一个是获取用户列表，一个是获取用户的详细信息。
在这一层，存放业务的实现代码。
data层，数据获取，数据存储的实现代码放在这一层。
层之间的依赖规则:
presention层------>domain层-------获取数据---->data层
参考资料：http://fernandocejas.com/2014/09/03/architecting-android-the-clean-way/