Android组件化开发架构超详细教程，包含单独运行和统一打包发布

为什么要组件化，组件化好的在哪里？

• 在项目的开发中，随着需求的增加以及需求频繁的变更，项目会越来越大，代码会变得越来越臃肿，耦合会越来越多，开发效率也会降低，这个时候我们就需要对项目进行重构以及模块的拆分，这个就叫做组件化开发.

• 实现代码解耦，代码复用，让代码架构更加清晰

• 实现多人协作开发

• 加快编译速度，提高开发效率，降低项目的维护成本

组件化的缺点有什么？

• 使用控件注入ButterKnife/IOC时，在library于Application之间的切换不是很友好

这是一个典型的组件化架构

---

• login模块，live模块，pay模块完全解耦，他们通过lib中的接口相互交互。

这样做有什么好处呢？

• 所有模块相互独立，便于合作分工。
• 通过接口交互，如果出了问题，接口不响应，也不会出现崩溃
• 模块可独立运行，提高开发效率

结构和理论基本如此，下面我们开始起锅烧油

• 首先创建项目和module
  
  **在此项目中，一共添加了3个module，类型如图标注。

• lib库是我们的基础工具库，里面包含，工具类，base类，网络访问框架，安全组件，等整个App使用的基础功能

• 后面两个则是我们的业务组件，live和pay。 所有组件必须全部依赖lib库，app则依赖所有组件，组件与组件之间相互解耦，没有关联，通过lib的接口交互

统一版本号

• 因为我们拥有大量的组件，我们必须统一维护，使用gradle统一管理项目开发环境

第一步我们需要配置我们的gradle

• 这样我们所有的配置都被gradle.properties管控，以后的维护，只需要在gradle.properties修改即可

application和library的区别在哪里，

• 插件类型

• 应用程序id
  
  

• AndroidManifest.xml
  

• 以上为三者之间的区别

为什么在这里讲解这个概念？

• 因为在我们的实际开发中，为了提高编译效率，我们不可能每次都跑整个项目，每一个module都是一个独立可运行的app，那么我们就需要module，在application和library之间进行切换，在开发模式下，application模式开发，在打包模式下以library模式统一打包
• 我们需要做的就是了解两者之间的差别，然后使用gradle配置，一键切换，实现我们单独运行和统一打包发布的目的

我们来配置gradle，来实现一键切换

• 第一步配置参数
  

• 第二步 在build.gradle中写判断代码，判断插件类型，应用程序id
  
  第三步 判断xml
  
  

• 到此为止，我们可以在gradle.properties修改frue和false，来决定是否独立运行

module之间的相互调用

• 首先，组件化的核心思想是解耦，那么moudle之间的相互调用，核心思想也是解耦，在任何一个moudle（包含app）中不允许出现其他类（lib除外，可以允许lib的引用）的引用，这样我们就可以实现彻底解耦

• 比如我们在app中调用live模块的类，那么以下代码是不被允许的

   startActivity(new Intent(this,LiveActivity.class));
  

• 这样的跳转，在我们正常使用时没有问题的，但是在组件化架构里面，是不允许出现的，为什么呢？因为这句代码会引入live组件下的LiveActivity到当前App组件下，如果live模块不被整合，项目就会出错，组合化是要求相互独立的。

• 那么我们应该怎么做呢？

• 说先我们先树立一个概念，所有的组件交互都是通过lib类实现的，上文的架构图中，有清晰的展示了这个特点

• 第一步在lib库中创建接口

public interface ILiveService {
    void launch(Context context, String tag);
    public int getUserId();
}`

• 第二步在live组件中实现接口

public class LiveService implements ILiveService {
    @Override
    public void launch(Context context, String tag) {
        Intent intent=new Intent(context,LiveActivity.class);
        context.startActivity(intent);
    }

• 第三步在lib库中创建单类工厂类

public class ServiceFactory {
    private static final ServiceFactory ourInstance = new ServiceFactory();
    private ILiveService mILiveService;
    
    public static ServiceFactory getInstance() {
        return ourInstance;
    }
    private ServiceFactory() {
    }
    public ILiveService getmILiveService() {
        return mILiveService;
    }
    public void setmILiveService(ILiveService mILiveService) {
        this.mILiveService = mILiveService;
    }
}

• 第四步 在调用主app中调用

 ServiceFactory.getInstance().getmILiveService().launch(this, "");

• 理论上这个模型已经结束，通过lib接口在app中调用，实现跳转。但是这里有个很严重的问题，getmILiveService()拿到的是空值，因为我们并没有set它，那么我们下面解决setmILiveService的问题

• 第五步 在live组件中创建application类

public class LiveApp extends Application implements IAppComponent {
    private static Application application;
    @Override
    public void onCreate() {
        super.onCreate();
        init(this);
    }
    }

• 第六步在lib中创建接口类，COMPONENTS 是所有我们需要注册的组件的application类路径，后面会通过反射机制，拿到相应的类，并且注册application

public interface IAppComponent {
    String[] COMPONENTS = {"com.molit.test.componentizationlive.LiveApp"};
    void init(Application app);
}

• 第七步在live组件中LiveApp 实现这个接口，在init方法中设置这个service

public class LiveApp extends Application implements IAppComponent {
    private static Application application;
    @Override
    public void onCreate() {
        super.onCreate();
        init(this);
    }
    @Override
    public void init(Application app) {
        application=this;
        ServiceFactory.getInstance().setmILiveService(new LiveService());
    }
}

• 第八步 通过反射机制，注册所有组件的application，从而实现了所有组件

ServiceFactory.getInstance().setmILiveService(new LiveService());
这样第四步的代码就不会为空，可以正常运行了

public class App extends Application implements IAppComponent {

    @Override
    public void onCreate() {
        super.onCreate();
        init(this);
    }
    @Override
    public void init(Application app) {
        for (String component : COMPONENTS) {
            try {
                Classclazz=Class.forName(component);
                Object object=clazz.newInstance();
                if(object instanceof IAppComponent){
                    ((IAppComponent) object).init(app);
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        }
    }
}

• 代码隔离，

 runtimeOnly project(':componentizationlive')

• runtimeOnly 这个关键词的意思是，在编译时候代码不可见，之后再运行时，代码才可见，可以实现代码隔离
• 资源隔离，组件的build gradle中加，

resourcePrefix “live”

• 组件中，资源文件必须拥有live前缀，对图片资源无效

组件化的架构到此结束

• 回顾一下，组件化的核心就是解耦，代码隔离，资源隔离，一切都组件分离，为了相互独立，对于未来移动端开发，组件化是势在必行的趋势。
• 本人水平有限，如果文章中有错误，或者不清晰，或者不明白的地方，请邮件联系[email protected] 谢谢
  https://download.csdn.net/download/mymolit/11007160 源码下载地址 这个需要积分，如果需要也可以邮件联系我 我邮件你