一篇项目总结

项目从去年6月份到9月中旬,历时3个半月,我一个人开发,学习了一些东西,现在作一篇总结,加深印象.

整体架构

以前没有架构项目的经验,所以项目开始时,上网学习了一些别人的架构经验,我的整体架构思想主要参考了MarkZhai的系列文章.主要考虑到实际项目需求,领导要求将这个APP做成一个公用模板,以便日后将它换个名字什么,换个界面什么的作为公司另外的购物网站APP(''马甲APP'').
先来看下项目整体结构:

项目结构.png

module 功能说明:

1. app对应与界面相关功能,主要包括View,以及为View服务的一些功能.
2. data对应数据仓库,项目中一切数据来源都应该来自它,其他module不管数据来源,只是向data要.data提供.
3. domain 对应用户Usecase,主要封装一些rxjava代码,属于Java层,负责连接app和data.

项目引入了Dagger2进行解耦,引入原因是因为我想学习怎么用,目前看来大材小用,因为项目不大,感觉没有完全发挥出它的强大作用,并且在项目开始时由于对它的不熟悉,常常出现一些自己不知道错在哪里的问题,花费了不少精力,重写了不少界面,特别是在和kotlin结合使用的时候,错在那个位置都不会报,在使用dagger2时,只要一个界面使用了它的功能,那你必须马上build工程一遍,不然等你连续写好几个界面后,都不知道到底是哪个出了问题,不过现在看来也算是学习了它,有所收获.

View 层(app module)在MVP模式中引入了DataBinding构成了MVPVM (Model-View-Presenter-ViewModel)模式

image

• Model:data和domain模块组成.
• View:Activity和fragment
• Presenter:连接View和Model
• ViewModel:继承BaseObservable,对Model进行wrap,处理成View需要的数据,通过DataBinding绑定到View中.

关于MVPVM模式可以看看Markzhai的这篇文章.下面我通过项目中用户进入产品详情界面来具体说明MVPVM是怎么工作的.

产品界面数据请求流程如下:

ivrose-product-page.jpg

在说明整个请求流程前,先介绍下Dagger2在我的项目中是怎样组织各个组件的:
ApplicationComponent:负责将项目中一直存在的组件(和应用同生命周期)inject到每一个需要这些组件的View中,并且保证这些组件只有一个实例.

@Singleton
@Component(modules = {ApplicationModule.class, ApiModule.class})
public interface ApplicationComponent {
   void inject(BaseActivity baseActivity);
   void inject(BaseFragment baseFragment);
   void inject(MessageUtils messageUtils);

   Context context();
   ThreadExecutor threadExecutor();
   PostExecutionThread postExecutionThread();
   AppApi api();

   void inject(@NotNull EditVariantBottomSheet editVariantBottomSheet);
}

ApplicationModule 提供组件:

/**
 * Dagger module that provides objects which will live during the application lifecycle.
 */
@Module
public class ApplicationModule {
    private final BaseApplication baseApplication;

    public ApplicationModule(BaseApplication baseApplication) {
        this.baseApplication = baseApplication;
    }


    @Provides
    @Singleton
    Context provideApplicationContext() {
        return this.baseApplication;
    }

    @Provides
    @Singleton
    ThreadExecutor provideThreadExecutor(JobExecutor jobExecutor) {
        return jobExecutor;
    }

    @Provides
    @Singleton
    PostExecutionThread providePostExecution(UIThread uiThread) {
        return uiThread;
    }

    @Provides
    @Singleton
    JsonSerializerUtil provideJsonSerializerUtil(){
        return new JsonSerializerUtil();
    }
}

在具体的界面Component中, 如ProductDetailComponent,负责将当前界面需要的实例注入到界面中.

@Component(dependencies = ApplicationComponent.class, modules = {ProductDataModule.class, ActivityModule.class})
public interface ProductDetailComponent {

    void inject(ProductDetailFragment productDetailFragment);

    void inject(ProductListFragment productListFragment);

    void inject(HomeFragment homeFragment);

    void inject(ProductDetailActivity productDetailActivity);

    void inject(ProductActivity productActivity);
}

ProductDataModule:

@Module
public class ProductDataModule {


    private final Context context;

    public ProductDataModule(Context context) {
        this.context = context;
    }

    @Provides
    ProductRepository provideProductRepository(ProductDataRepository productDataRepository) {
        return productDataRepository;

    }

}

在ProductActivity onCreate()方法中进行ProductDetailComponent的注入:

private fun initializeInjector() {
        DaggerProductDetailComponent.builder()
                .applicationComponent(applicationComponent)
                .productDataModule(ProductDataModule(BaseApplication.getContext()))
                .build().inject(this)
    }

到这一步时,我们的Activity中已经存在JobExecutor ,UIThread(ApplicationModule提供);ProductDataRepository(ProductDataModule提供)这些在后面生产ProductDetailPresenter实例需要的实例.
ProductDetailPresenter通过@Inject直接注入到ProductActivity中:

class ProductActivity : MvpActivity(), ProductDetailView {
    @Inject
    lateinit var productDetailPresenter: ProductDetailPresenter

来看下ProductDetailPresenter:

public class ProductDetailPresenter extends MvpBasePresenter {

    private final ProductDetailsUseCase productDetailsUseCase;
    private final ProductListUseCase productListUseCase;
    private final ProductBuyUseCase productBuyUseCase;

    private String productId;
    private int skip;

    public ProductDetailEntity getProductDetailEntity() {
        return productDetailEntity;
    }

    private ProductDetailEntity productDetailEntity;

    @Inject
    LikeProductUseCase likeProductUseCase;

    @Inject
    ProductShareToUseCase productShareToUseCase;

    @Inject
    public ProductDetailPresenter(ProductDetailsUseCase productDetailsUseCase, ProductListUseCase productListUseCase, ProductBuyUseCase productBuyUseCase) {
        this.productDetailsUseCase = productDetailsUseCase;
        this.productListUseCase = productListUseCase;
        this.productBuyUseCase = productBuyUseCase;
    }

    @Override
    public void initialize() {
        productId = getView().getProductId();
        getProductData();
        getRelativeProduct(false);
    }

    public void getRelativeProduct(boolean b) {
        productListUseCase.execute(new RelativeProductSubscriber(b), ProductListUseCase.Params.relativeProduct(productId, skip));
    }

    public void getProductData() {
        productDetailsUseCase.execute(new ProductDetailSubscriber(), ProductDetailsUseCase.Params.forProduct(productId, 2));
    }

    @Override
    public void detachView(boolean retainInstance) {
        super.detachView(retainInstance);
        productDetailsUseCase.dispose();
        productBuyUseCase.dispose();
        productListUseCase.dispose();
        likeProductUseCase.dispose();
    }

    public void saveProduct(int position, String id, boolean like) {
        likeProductUseCase.executeCanEmitNull(new LikeSubscriber(position, id, like), LikeProductUseCase.Params.forProduct(id, like));
    }

    public void shareSuccess(String shareTo) {
        productShareToUseCase.executeCanEmitNull(new ShareToSubscriber(),ProductShareToUseCase.Params.shareProduct(productId,shareTo));
    }

  

    public void productBuy(String id, int num, String unifiedId, String warehouseId, String countryCode, boolean isBuy, boolean limitTimeOver) {
        ProductBuyUseCase.Params params = ProductBuyUseCase.Params.buyProduct(id, num, unifiedId, warehouseId, countryCode,limitTimeOver);
        productBuyUseCase.execute(new ProductBuySubscriber(isBuy), params);
    }

    //.....省略一些代码...

    private class ProductDetailSubscriber extends DefaultObserver