例子Architecting Android…The clean way?----代码分析

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/

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。