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

/**
 * 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);
  }
}

@Override public void onAttach(Activity activity) {
  super.onAttach(activity);
  if (activity instanceof UserListListener) {
    this.userListListener = (UserListListener) activity;
  }
}

@Override public void onActivityCreated(Bundle savedInstanceState) {
  super.onActivityCreated(savedInstanceState);
  this.initialize();
  this.loadUserList();
}

private void initialize() {
  this.getComponent(UserComponent.class).inject(this);
  this.userListPresenter.setView(this);
}

/**
 * Loads all users.
 */
private void loadUserList() {
  this.userListPresenter.initialize();
}

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/