移动架构 (一) 架构第一步，学会画各种 UML 图

移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架

移动架构 (三) AMS 源码分析

移动架构 (四) EventBus 3.1.1 源码分析及实现自己的轻量级 EventBus 框架，根据 TAG 发送接收事件。

移动架构 (五) 仅仅对 Java Bean 的操作，就能完成对数据持久化

概述

现在多进程传递数据使用越来越广泛了，在 Android 中进程间通信提供了 文件 、AIDL 、Binder 、Messenger 、ContentProvider 、Socket 、MemoryFile 等，实际开发中使用最多的应该是 AIDL ,但是 AIDL 需要编写 aidl 文件，如果使用 AIDL 仅仅是为了传递数据, 那么 YKProBus 是你不错的选择。

YKProBus

怎么使用？

1. root/build.gradle 中添加框架 maven

	allprojects {

		repositories {

			...

			maven { url 'https://jitpack.io' }

		}

	}

复制代码

2. app/build.gradle 中添加框架 依赖

	dependencies {

	        implementation 'com.github.yangkun19921001:YKProBus:1.0.1'

	}

复制代码

3. 发送进程绑定接收进程服务

EventManager.getInstance().bindApplication(Context context,String proName);

复制代码

4. 发送消息

 EventManager.getInstance().sendMessage(int messageTag,Bundle bundle);

复制代码

5. 接收进程中需要在清单文件注册服务

<service       

 android:name="com.devyk.component_eventbus.proevent.service.MessengerService"

 android:enabled="true"

 android:exported="true">

    <intent-filter>

           <action android:name="com.devyk.component_eventbus.service"></action>

           <category android:name="android.intent.category.DEFAULT" />

    </intent-filter>

</service>

复制代码

6. 接收消息

6.1 在需要接收消息的类中实现 IMessageHandler 并实例化一个 Handler 用于接收发送进程发来的消息

public class MainActivity extends Activity implements IMessageHandler{

  ...

    

   

    /**

     * 接收其它进程发送过来的消息

     *

     * @return

     */

    @Override

    public Handler getHandler() {

        return new Handler() {

            @Override

            public void handleMessage(Message msg) {

                super.handleMessage(msg);

                switch (msg.what) {

                    case 0x001:

                       ...

                        break;

                }

            }

        };

    } 

  ...

}

复制代码

6.2 注册当前类需要接收消息

 EventManager.getInstance().registerMessager(int messageTag, Object obj);

复制代码

框架设计大概流程

Messenger 源码分析

Messenger 内部其实也是依赖 aidl 实现的进程间通信。

服务端

    @Override

    public IBinder onBind(Intent intent) {

        return mServiceMessenger.getServiceMessenger().getBinder();

    }

复制代码

getBinder() 跟进去

    public IBinder getBinder() {

        return mTarget.asBinder();

    }

复制代码

mTarget 从何而来，从源码找找

    public Messenger(Handler target) {

        mTarget = target.getIMessenger();

    }

复制代码

这里是我们实例化 服务端 Messenger 传入的 Handler target

    /**

     * 初始化服务端 Messenger

     */

    public MessengerManager() {

        if (null == mServiceMessenger)

            mServiceMessenger = new Messenger(mMessengerServiceHandler);

    }

复制代码

那么我们在点击 getIMessenger() 在看看内部实现

    final IMessenger getIMessenger() {

        synchronized (mQueue) {

            if (mMessenger != null) {

                return mMessenger;

            }

            mMessenger = new MessengerImpl();

            return mMessenger;

        }

    }

   

复制代码

继续点击 MessengerImple

    private final class MessengerImpl extends IMessenger.Stub {

        public void send(Message msg) {

            msg.sendingUid = Binder.getCallingUid();

            Handler.this.sendMessage(msg);

        }

    }

复制代码

这个是一个内部实现的类，可以看到继承的是 IMessenger.Stub 然后实现 send (Message msg) 函数，然后通过 mTarget.sendMessage(msg) 发送消息，最后在我们传入进去的 mMessengerServiceHandler 的 handleMessage (Message) 接收发来的消息。

既然这里内部帮我们写了 aidl 文件 ，并且也继承了 IMessenger.Stub 我们今天就要看到 aidl 才死心 ， 好吧我们来找找 IMessenger aidl 文件。

可以看到是在 framework/base/core/java/android/os 路径中，我们点击在来看下文件中怎么写的

内部就一个 send 函数，看到这，大家应该都明白了，Messenger 其实也没什么大不了，就是系统内部帮我们写了 aidl 并且也实现了 aidl ，最后又帮我们做了一个 Handler 线程间通信，所以服务端收到了客服端发来的消息。

客服端

客服端需要在 bindServicer onServiceConnected 回调中拿到 servicer, 平时我们自己写 应该是这么拿到 Ibinder 对象吧

IMessenger mServiceMessenger = IMessenger.Stub.asInterface(service);

复制代码

但是我们实际客服端是这样拿到服务端的 Messenger

    /**

     * 服务端消息是否连接成功

     */

    private class EventServiceConnection implements ServiceConnection {

        @Override

        public void onServiceConnected(ComponentName name, IBinder service) {

            isBindApplication = true;

            // 得到服务信使对象

            mServiceMessenger = new Messenger(service);



            //将本地信使告诉服务端

            registerMessenger();



            String proName = ProcessUtils.getProName(mApplicationContext);

            Log.d(TAG, " EventServiceConnection " + proName);



        }



        @Override

        public void onServiceDisconnected(ComponentName name) {

            isBindApplication = false;

        }

    }

复制代码

// 得到服务信使对象

mServiceMessenger = new Messenger(service);

复制代码

跟进去

public Messenger(IBinder target) {

  mTarget = IMessenger.Stub.asInterface(target);

}

复制代码

这不就是我们刚刚说的自己实现的那种写法吧，到这里我们都懂了吧，我们平时写的 aidl android 中已经帮我们写了，想当于在 aidl 中封装下就变成了现在的 Messenger , 而我们又在 Messenger 上封装了下，想当于 三次封装了，为了使用更简单。封装才是王道！

总结

我们自己的 YKProBus 为了进程间通信使用更简单方便，其实相当于在 AIDL 中的三次封装。想要了解的可以去看下我具体的封装或者 Messenger 源码。

感谢大家抽空阅览文章，谢谢！

移动架构 (一) 架构第一步，学会画各种 UML 图

移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架

移动架构 (三) AMS 源码分析

移动架构 (四) EventBus 3.1.1 源码分析及实现自己的轻量级 EventBus 框架，根据 TAG 发送接收事件。

前言

GitHub 上面开源了多个 Android 数据库，比如 GreenDao , LitePal , ORMLite 等，开源的数据库一般都是使用非常简单，不用开发者写 SQL，创建 table 等一些繁琐的操作，都是基于对对象的一些操作。那么我们自己可以设计一款不用自己来写 SQL 的轻量级数据库吗？当然可以，下面我们就来开干。

使用

1. 
   

   给一个 Object 对象定义协定好的注解 table ,id

   
   

   @YKTable("tb_police")
   
   public class Police {
   
   
   
       /**
   
        * 人员 id
   
        */
   
       @YKField("_id")
   
       private String id;
   
   
   
       /**
   
        * 人员姓名
   
        */
   
       private String name;
   
   
   
       public Police(String id, String name) {
   
           this.id = id;
   
           this.name = name;
   
       }
   
   
   
       public Police() {
   
       }
   
   
   
       public String getId() {
   
           return id;
   
       }
   
   
   
       public void setId(String id) {
   
           this.id = id;
   
       }
   
   
   
       public String getName() {
   
           return name;
   
       }
   
   
   
       public void setName(String name) {
   
           this.name = name;
   
       }
   
   
   
       @Override
   
       public String toString() {
   
           return "Police{" +
   
                   "id='" + id + '\'' +
   
                   ", name='" + name + '\'' +
   
                   '}';
   
       }
   
   }
   
   复制代码



2. 
   

   插入数据

   
   

   BaseDaoFactory.getOurInstance().getBaseDao(Police.class).insert(new Police("01", "DevYK"));
   
   复制代码



3. 
   

   删除数据

   
   

   BaseDaoFactory.getOurInstance().getBaseDao(Police.class).delete(new Police("01", "DevYK"));
   
   复制代码



4. 
   

   更新数据

   
   

   BaseDaoFactory.getOurInstance().getBaseDao(Police.class).updata(new Police("02", "BaseDevYK"), new Police("01", "DevYK"));
   
   复制代码



5. 
   

   查询数据

   
   

   BaseDaoImp<Police> mBaseDao BaseDaoFactory.getOurInstance().getBaseDao(Police.class);
   
   Police police = new Police();
   
   police.setId("02");
   
   List<Police> policeLists = mBaseDao.query(police);
   
   复制代码

到这里，增删改查咱们都已经操作完了，使用是不是非常的简单，不用使用者写一行 SQL 语句，基本上一行代码解决，下面我们来看看源码实现，它到底做了些什么？

自动创建 table

流程

创建表核心代码

    /**

     * 初始化

     *

     * @param sqLiteDatabase

     * @param entityClass

     */

    public void init(SQLiteDatabase sqLiteDatabase, Class<T> entityClass) {

        this.mSQLiteDatabase = sqLiteDatabase;

        this.mEntityClass = entityClass;



        if (!isInit) {

            //自动建表，取得表名

            if (entityClass != null && (entityClass.getAnnotation(YKTable.class) == null)) {

                //通过反射得到类名

                this.mTableName = entityClass.getSimpleName();

            } else {

                if (TextUtils.isEmpty(entityClass.getAnnotation(YKTable.class).value())) {

                    //如果有注解但是注解为空的话，就取当前 类名

                    this.mTableName = entityClass.getSimpleName();

                } else {

                    //取得注解上面的表名

                    this.mTableName = entityClass.getAnnotation(YKTable.class).value();

                }



            }



            //执行创建表的操作， 使用 getCreateTabeSql () 生成 sql 语句

            String autoCreateTabSql = getCreateTableSql();

            Log.i(TAG, "tagSQL-->" + autoCreateTabSql);

            //执行创建表的 SQL

            this.mSQLiteDatabase.execSQL(autoCreateTabSql);

            mCacheMap = new HashMap<>();

            initCacheMap();

            isInit = true;



        }

    }

复制代码

insert 插入数据

流程

插入核心代码

    /**

     * 插入数据

     * @param entity

     * @return

     */

    @Override

    public long insert(T entity) {

        //1. 准备好 ContentValues 中需要的数据

        Map<String, String> map = getValues(entity);

        if (map == null || map.size() == 0) return 0;

        //2. 把数据转移到 ContentValues 中

        ContentValues values = getContentValues(map);

        //将数据插入表中

        return mSQLiteDatabase.insert(mTableName, null, values);

    }

复制代码

1. 首先接收外部传入的数据对象。


2. 对数据对象进行解析，拿到数据库表中对应字段的值，拿到之后将字段 key,对应的值 values 存入 map。


3. 将 map 解析为 ContentValues。


4. 进行数据库插入 mSQLiteDatabase.insert。

delete 删除数据

流程图

核心代码流程

1. 
   

   拿到对应字段的值

   
   

     /**
   
        * key(字段) - values(成员变量) ---》getValues 后 ---》key (成员变量的名字) ---values 成员变量的值 id 1，name alan , password 123
   
        *
   
        * @param entity
   
        * @return
   
        */
   
       private Map<String, String> getValues(T entity) {
   
           HashMap<String, String> map = new HashMap<>();
   
           //返回所有的成员变量
   
           Iterator<Field> iterator = mCacheMap.values().iterator();
   
           while (iterator.hasNext()) {
   
               Field field = iterator.next();
   
               field.setAccessible(true);
   
   
   
               try {
   
                   Object object = field.get(entity);
   
                   if (object == null) {
   
                       continue;
   
                   }
   
                   String values = object.toString();
   
   
   
                   String key = "";
   
   
   
                   if (field.getAnnotation(YKField.class) != null) {
   
                       key = field.getAnnotation(YKField.class).value();
   
                   } else {
   
                       key = field.getName();
   
   
   
                   }
   
   
   
                   if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(values)) {
   
                       map.put(key, values);
   
                   }
   
               } catch (IllegalAccessException e) {
   
                   e.printStackTrace();
   
               }
   
   
   
           }
   
           return map;
   
       }
   
   
   
   复制代码



2. 
   

   将拿到要删除的 key,values 字段对应的值，自动生成 SQL

   
   

       public Condition(Map<String,String> whereCasue) {
   
           //whereArgs 里面的内容存入的 list
   
           ArrayList list = new ArrayList();
   
           StringBuffer stringBuffer = new StringBuffer();
   
           stringBuffer.append("1=1");
   
   
   
           //取得所有成员变量的名字
   
           Set<String> keys = whereCasue.keySet();
   
           Iterator<String> iterator = keys.iterator();
   
           while (iterator.hasNext()) {
   
               String key = iterator.next();
   
               String value = whereCasue.get(key);
   
               if (value != null){
   
                   stringBuffer.append(" and " + key + "=?");
   
                   list.add(value);
   
               }
   
           }
   
   
   
           this.whereClause = stringBuffer.toString();
   
           this.whereArgs = (String[]) list.toArray(new String[list.size()]);
   
       }
   
   
   
   复制代码



3. 
   

   根据生成的 SQL 条件删除数据

   
   

       int delete = mSQLiteDatabase.delete(mTableName, condition.getWhereClause(), condition.getWhereArgs());
   
           
   
   
   
   复制代码

query 查询数据

流程图

核心代码流程

1. 
   

   拿到查询的条件的对象，转为 key,values 的 map 对象

   
   

   Map<String, String> values = getValues(where);
   
   
   
      private Map<String, String> getValues(T entity) {
   
           HashMap<String, String> map = new HashMap<>();
   
           //返回所有的成员变量
   
           Iterator<Field> iterator = mCacheMap.values().iterator();
   
           while (iterator.hasNext()) {
   
             	//拿到成员变量
   
               Field field = iterator.next();
   
             	//设置可操作的权限
   
               field.setAccessible(true);
   
   
   
               try {
   
                 	//拿到成员变量对应的值 values
   
                   Object object = field.get(entity);
   
                   if (object == null) {
   
                       continue;
   
                   }
   
                   String values = object.toString();
   
   
   
                   String key = "";
   
   								//如果成员变量上声明了注解，直接拿到该值 key,反之反射拿
   
                   if (field.getAnnotation(YKField.class) != null) {
   
                       key = field.getAnnotation(YKField.class).value();
   
                   } else {
   
                       key = field.getName();
   
   
   
                   }
   
   								//将类中拿到的 key values 存入 map 中
   
                   if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(values)) {
   
                       map.put(key, values);
   
                   }
   
               } catch (IllegalAccessException e) {
   
                   e.printStackTrace();
   
               }
   
   
   
           }
   
           return map;
   
       }
   
   
   
   复制代码



2. 
   

   将 map 转为自动生成 SQL 对象

   
   

       public Condition(Map<String,String> whereCasue) {
   
           //whereArgs 里面的内容存入的 list
   
           ArrayList list = new ArrayList();
   
           StringBuffer stringBuffer = new StringBuffer();
   
           stringBuffer.append("1=1");
   
   
   
           //取得所有成员变量的名字
   
           Set<String> keys = whereCasue.keySet();
   
           Iterator<String> iterator = keys.iterator();
   
           while (iterator.hasNext()) {
   
               String key = iterator.next();
   
               String value = whereCasue.get(key);
   
               if (value != null){
   
                 	//查询的条件 sql
   
                   stringBuffer.append(" and " + key + "=?");
   
                 	//查询的条件对应的 值
   
                   list.add(value);
   
               }
   
           }
   
   
   
           this.whereClause = stringBuffer.toString();
   
           this.whereArgs = (String[]) list.toArray(new String[list.size()]);
   
       }
   
   
   
   复制代码



3. 
   

   查询数据，并遍历 Cursor 取出数据

   
   

   Cursor cursor = mSQLiteDatabase.query(mTableName,null,condition.getWhereClause(), condition.getWhereArgs(), null, limitString,  orderBy);
   
   
   
   List<T> result = getResult(cursor, where);
   
   
   
   
   
   复制代码

update 更新数据

流程图

核心代码流程

1. 
   

   拿到需要更新的值，转为 map

   
   

   Map<String, String> values = getValues(entity);
   
   复制代码



2. 
   

   将需要更新的 map 转为 ContentValues

   
   

   ContentValues contentValues = getContentValues(values);
   
   复制代码



3. 
   

   将条件转为 map

   
   

   //条件
   
   Map<String, String> whereMp = getValues(where);
   
   复制代码



4. 
   

   将条件 map 转为 sql

   
   

       public Condition(Map<String,String> whereCasue) {
   
           //whereArgs 里面的内容存入的 list
   
           ArrayList list = new ArrayList();
   
           StringBuffer stringBuffer = new StringBuffer();
   
           stringBuffer.append("1=1");
   
   
   
           //取得所有成员变量的名字
   
           Set<String> keys = whereCasue.keySet();
   
           Iterator<String> iterator = keys.iterator();
   
           while (iterator.hasNext()) {
   
               String key = iterator.next();
   
               String value = whereCasue.get(key);
   
               if (value != null){
   
                 	//查询的条件 sql
   
                   stringBuffer.append(" and " + key + "=?");
   
                 	//查询的条件对应的 值
   
                   list.add(value);
   
               }
   
           }
   
   
   
           this.whereClause = stringBuffer.toString();
   
           this.whereArgs = (String[]) list.toArray(new String[list.size()]);
   
       }
   
   复制代码

总结

通过上面的步骤，我们不编写 SQL ，完全是依赖数据对象来做操作，对 SQL 不太熟悉的很友好。对于那些开源框架为什么可以自动建表，不用填写 SQL ，仅仅通过数据 Bean 就能操作数据库的好奇，在没有了解它们内部实现的原理下，看看自己能不能实现，结果也没那么难嘛。但是实际项目还是建议在了解内部实现原理的情况下使用开源框架。在这里推荐下 郭霖大神的 LitePal 框架非常稳定，使用非常简单，易上手。

如果对上面源码感兴趣的可以去我的代码仓库YKDB详细了解。

移动架构 (一) 架构第一步，学会画各种 UML 图
移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架

移动架构 (三) AMS 源码分析

EventBus 我相信大家不会很默认，应该也都在项目中使用过，虽然 EventBus 在项目中不便于管理，发射出去的消息不便于跟踪或者阅读，但是不可否认它是一个优秀的开源项目，还是值得我们大家学习的，我个人感觉唯一不足的就是 EventBus 功能上不能根据 TAG 来进行发射和接收消息，只能通过注解 + 消息类型进行找消息。那么我们自己可以实现这个功能吗？不可否认，当然可以! 想要实现这个功能，我们先大概简要的了解下 EventBus 使用及源码是怎么实现的。

EventBus 简单使用

EventBus 可以代替 Android 传统的 Intent, Handler, Broadcast 或接口函数, 在 Fragment, Activity, Service 线程间进行数据传递。

添加 EventBus 到项目中

implementation 'org.greenrobot:eventbus:3.1.1'

复制代码

register

EventBus.getDefault().register(this);

复制代码

注解实现接收的 Event

    @Subscribe(threadMode = ThreadMode.MAIN)

    public void receive(String event){

        Log.d(TAG,"接收到 EventBus post message:" + event);

    }

复制代码

发射数据

EventBus.getDefault().post("发射一个测试消息");

复制代码

注销注册的事件

EventBus.getDefault().unregister(this);

复制代码

这里就简单介绍下 EventBus 使用，想详细了解的可以看 EventBus GitHub

EventBus 3.1.1 源码分析

上面小节咱们学习了 EventBus 的简单使用，那么我们就根据上面使用到的来进行源码分析。

register

流程图:

register 代码:

		/**

		*

		*EventBus register

		*/

    public void register(Object subscriber) {

      //1. 拿到当前注册 class

        Class<?> subscriberClass = subscriber.getClass();

      //2. 查找当前 class 类中所有订阅者的方法

        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

        synchronized (this) {

            for (SubscriberMethod subscriberMethod : subscriberMethods) {

              //3. 

                subscribe(subscriber, subscriberMethod);

            }

        }

    }

复制代码

subscribe（x,x）代码：

    //必须加锁调用

    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {

      //拿到订阅者参数类型

        Class<?> eventType = subscriberMethod.eventType;

        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);

      //根据参数类型，拿到当前所有订阅者

        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);

      //4. 如果没有拿到，则存进去缓存中

        if (subscriptions == null) {

            subscriptions = new CopyOnWriteArrayList<>();

            subscriptionsByEventType.put(eventType, subscriptions);

        } else {

          //如果已经存在相同类型的注册事件，就抛出异常

            if (subscriptions.contains(newSubscription)) {

                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "

                        + eventType);

            }

        }



       ......

    }

复制代码

1. 
   

   拿到当前传入进来的 this 对象。

   
   


2. 
   

   查找当前 this 类中所有订阅的函数。

   
   


3. 
   

   subscriptionsByEventType 完成数据初始化。

   
   

   subscriptionsByEventType = new HashMap();
   
   复制代码

   // 参考上图注释 4 ，根据参数类型存储订阅者和订阅方法

   
   

post

流程图:

代码

 /** 发送事件*/

    public void post(Object event) {

      //在当前线程中取出变量数据

        PostingThreadState postingState = currentPostingThreadState.get();

      //将需要发送的数据添加进当前线程的队列中

        List<Object> eventQueue = postingState.eventQueue;

        eventQueue.add(event);



        if (!postingState.isPosting) {

            postingState.isMainThread = isMainThread();

            postingState.isPosting = true;

            if (postingState.canceled) {

                throw new EventBusException("Internal error. Abort state was not reset");

            }

            try {

                while (!eventQueue.isEmpty()) {

                  //开启取出数据

                    postSingleEvent(eventQueue.remove(0), postingState);

                }

            } finally {

                postingState.isPosting = false;

                postingState.isMainThread = false;

            }

        }

    }

复制代码

    private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {

        Class<?> eventClass = event.getClass();

        boolean subscriptionFound = false;

        if (eventInheritance) {

          //查找所有的事件类型

            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);

            int countTypes = eventTypes.size();

            for (int h = 0; h < countTypes; h++) {

                Class<?> clazz = eventTypes.get(h);

                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);

            }

        } else {

          //发送事件

            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);

        }

        if (!subscriptionFound) {

            if (logNoSubscriberMessages) {

                logger.log(Level.FINE, "No subscribers registered for event " + eventClass);

            }

            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&

                    eventClass != SubscriberExceptionEvent.class) {

                post(new NoSubscriberEvent(this, event));

            }

        }

    }

复制代码

    private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {

        CopyOnWriteArrayList<Subscription> subscriptions;

        synchronized (this) {

          //这里的容器就是 register 的时候添加进行去的，现在拿出来

            subscriptions = subscriptionsByEventType.get(eventClass);

        }

        if (subscriptions != null && !subscriptions.isEmpty()) {

            for (Subscription subscription : subscriptions) {

                postingState.event = event;

                postingState.subscription = subscription;

                boolean aborted = false;

                try {

                  //发送到订阅者哪里去

                    postToSubscription(subscription, event, postingState.isMainThread);

                    aborted = postingState.canceled;

                } finally {

                    postingState.event = null;

                    postingState.subscription = null;

                    postingState.canceled = false;

                }

                if (aborted) {

                    break;

                }

            }

            return true;

        }

        return false;

    }

复制代码

    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {

      //根据订阅者 threadMode 来进行发送

        switch (subscription.subscriberMethod.threadMode) {

            case POSTING:

            //通过反射发送

                invokeSubscriber(subscription, event);

                break;

            case MAIN:

            //如果是主线程直接在当前线程发送

                if (isMainThread) {

                    invokeSubscriber(subscription, event);

                } else {

                  //开启一个子线程发送

                    mainThreadPoster.enqueue(subscription, event);

                }

                break;

            case MAIN_ORDERED:

                if (mainThreadPoster != null) {

                    mainThreadPoster.enqueue(subscription, event);

                } else {

                    // temporary: technically not correct as poster not decoupled from subscriber

                    invokeSubscriber(subscription, event);

                }

                break;

            case BACKGROUND:

                if (isMainThread) {

                    backgroundPoster.enqueue(subscription, event);

                } else {

                    invokeSubscriber(subscription, event);

                }

                break;

            case ASYNC:

                asyncPoster.enqueue(subscription, event);

                break;

            default:

                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);

        }

    }

复制代码

步骤

1. post


2. 获取事件类型


3. 根据类型，获取订阅者和订阅方法


4. 根据订阅者的 threadMode 来判断线程


5. 通过反射直接调用订阅者的订阅方法来完成本次通信息

Subscribe

这里是订阅者的意思，通过自定义注解实现

@Documented

@Retention(RetentionPolicy.RUNTIME) //注解会在class字节码文件中存在，在运行时可以通过反射获取到

@Target({ElementType.METHOD}) //只能在方法上声明

public @interface Subscribe {

    ThreadMode threadMode() default ThreadMode.POSTING; //默认在 post 线程



    boolean sticky() default false; //默认不是粘性事件



    int priority() default 0; //线程优先级默认

}

复制代码

threadMode

package org.greenrobot.eventbus;



public enum ThreadMode {

    POSTING, // post 线程

    MAIN,//指定主线程

    MAIN_ORDERED,

    BACKGROUND,//后台进行

    ASYNC;//异步



    private ThreadMode() {

    }

}

复制代码

unregister

流程:

EventBus 源码总结

到这里我们就简单的分析了 注册 - > 订阅 - > 发送 - >接收事件 简单的流程就是这样了，如果想更深入的话，建议下载源码来看 EventBus GitHub 架构方面还是要注重基础知识，比如 注解 + 反射 + 设计模式 (设计模式的话建议去看 《Android 源码设计模式》一书 )，现在开源项目几乎离不开这几项技术。只有我们掌握了基础 + 实现原理。我们模仿着也能写出来同样的项目。

下面我们就简单模仿下 EventBus 原理，实现自己的 EventBus 框架。

YEventBus 根据 TAG 实现接收消息架构实现

说明一点，这里我们还是根据 EventBus 的核心原理实现，并不会有 EventBus 那么多功能，我们只是学习 EventBus 原理的同时，能根据它的原理，自己写一套轻量级的 EventBus 架构。

最后一共差不多 300 行代码实现根据 TAG 发送/接收事件，下面是效果图：

以下我就直接贴代码了 每一步代码都有详细的注释，相信应该不难理解。

使用方式

• 
  

  添加依赖

  
  

    allprojects {
  
    	repositories {
  
    		...
  
    		maven { url 'https://jitpack.io' }
  
    	}
  
    }
  
  
  
    dependencies {
  
            implementation 'com.github.yangkun19921001:YEventBus:Tag'
  
    }
  
  复制代码



• 
  

  注册事件

  
  

   //开始注册事件。模仿 EventBus
  
   YEventBus.getDefault().register(this);
  
  复制代码



• 
  

  订阅消息

  
  

      /**
  
       * 这里是自定义的注册，最后通过反射来获取当前类里面的订阅者
  
       *
  
       * @param meg
  
       */
  
  @YSubscribe(threadMode = YThreadMode.MAIN, tag = Constants.TAG_1)
  
      public void onEvent(String meg) {
  
          Toast.makeText(getApplicationContext(), "收到：" + meg, Toast.LENGTH_SHORT).show();
  
      }
  
  复制代码



• 
  

  发送消息

  
  

  YEventBus.getDefault().post(Constants.TAG_1, "发送 TAG 为 1 的消息");
  
  复制代码

register

 /**

     * 注册方法

     */

    public void register(Object subscriber) {

        //拿到当前注册的所有的订阅者

        List<YSubscribleMethod> ySubscribleMethods = mChacheSubscribleMethod.get(subscriber);

        //如果订阅者已经注册了 就不需要再注册了

        if (ySubscribleMethods == null) {

            //开始反射找到当前类的订阅者

            ySubscribleMethods = getSubscribleMethods(subscriber);

            //注册了就存在缓存中，避免多次注册

            mChacheSubscribleMethod.put(subscriber, ySubscribleMethods);

        }

    }



    /**

     * 拿到当前注册的所有订阅者

     *

     * @param subscriber

     * @return

     */

    private List<YSubscribleMethod> getSubscribleMethods(Object subscriber) {

        //拿到注册的 class

        Class<?> subClass = subscriber.getClass();

        //定义一个容器，用来装订阅者

        List<YSubscribleMethod> ySubscribleMethodList = new ArrayList<>();

        //开始循环找到

        while (subClass != null) {

            //1. 开始进行筛选，如果是系统的就不需要进行下去

            String subClassName = subClass.getName();

            if (subClassName.startsWith(Constants.JAVA) ||

                    subClassName.startsWith(Constants.JAVA_X) ||

                    subClassName.startsWith(Constants.ANDROID) ||

                    subClassName.startsWith(Constants.ANDROID_X)

            ) {

                break;

            }

            //2. 遍历拿到当前 class

            Method[] declaredMethods = subClass.getDeclaredMethods();

            for (Method declaredMethod : declaredMethods) {

                //3. 检测当前方法中是否有 我们的 订阅者 注解也就是 YSubscribe

                YSubscribe annotation = declaredMethod.getAnnotation(YSubscribe.class);

                //如果没有直接跳出查找

                if (annotation == null)

                    continue;



                // check 这个方法的参数是否有多个

                Class<?>[] parameterTypes = declaredMethod.getParameterTypes();

                if (parameterTypes.length > 1) {

                    throw new RuntimeException("YEventBus 只能接收一个参数");

                }



                //4. 符合要求，最后添加到容器中

                //4.1 拿到需要在哪个线程中接收事件

                YThreadMode yThreadMode = annotation.threadMode();

                //只能在当前 tag 相同下才能接收事件

                String tag = annotation.tag();

                YSubscribleMethod subscribleMethod = new YSubscribleMethod(tag, declaredMethod, yThreadMode, parameterTypes[0]);

                ySubscribleMethodList.add(subscribleMethod);



            }

            //去父类找订阅者

            subClass =   subClass.getSuperclass();

        }

        return ySubscribleMethodList;

    }

复制代码

post (这里不是粘性事件)

    /**

     * post 方法

     */

    public void post(String tag, Object object) {

        //拿到当前所有订阅者持有的类

        Set<Object> subscriberClass = mChacheSubscribleMethod.keySet();

        //拿到迭代器，

        Iterator<Object> iterator = subscriberClass.iterator();

        //进行循环遍历

        while (iterator.hasNext()) {

            //拿到注册 class

            Object subscribleClas = iterator.next();

            //获取类中所有添加订阅者的注解

            List<YSubscribleMethod> ySubscribleMethodList = mChacheSubscribleMethod.get(subscribleClas);

            for (YSubscribleMethod subscribleMethod : ySubscribleMethodList) {

                //判断这个方法是否接收事件

                if (!TextUtils.isEmpty(tag) && subscribleMethod.getTag().equals(tag) //注解上面的 tag 是否跟发送者的 tag 相同，相同就接收

                        && subscribleMethod.getEventType().isAssignableFrom(object.getClass() //判断类型

                )

                ) {

                    //根据注解上面的线程类型来进行切换接收消息

                    postMessage(subscribleClas, subscribleMethod, object);

                }



            }



        }



    }



    private void postMessage(final Object subscribleClas, final YSubscribleMethod subscribleMethod, final Object message) {



        //根据需要的线程来进行切换

        switch (subscribleMethod.getThreadMode()) {

            case MAIN:

                //如果接收的是主线程，那么直接进行反射，执行订阅者的方法

                if (isMainThread()) {

                    postInvoke(subscribleClas, subscribleMethod, message);

                } else {//如果接收消息在主线程，发送线程在子线程那么进行线程切换

                    mHandler.post(new Runnable() {

                        @Override

                        public void run() {

                            postInvoke(subscribleClas, subscribleMethod, message);

                        }

                    });

                }

                break;

            case ASYNC://需要在子线程中接收

                if (isMainThread())

                    //如果当前 post  是在主线程中，那么切换为子线程

                    ThreadUtils.executeByCached(new ThreadUtils.Task<Boolean>() {

                        @Nullable

                        @Override

                        public Boolean doInBackground() throws Throwable {

                            postInvoke(subscribleClas, subscribleMethod, message);

                            return true;

                        }



                        @Override

                        public void onSuccess(@Nullable Boolean result) {

                            Log.i(TAG, "执行成功");

                        }



                        @Override

                        public void onCancel() {



                        }



                        @Override

                        public void onFail(Throwable t) {



                        }

                    });

                else

                    postInvoke(subscribleClas, subscribleMethod, message);

                break;

            case POSTING:

            case BACKGROUND:

            case MAIN_ORDERED:

                postInvoke(subscribleClas, subscribleMethod, message);

                break;

            default:

                break;

        }

    }



    /**

     * 反射调用订阅者

     *

     * @param subscribleClas

     * @param subscribleMethod

     * @param message

     */

    private void postInvoke(Object subscribleClas, YSubscribleMethod subscribleMethod, Object message) {

        Log.i(TAG, "post message: " + "TAG:" + subscribleMethod.getTag() + " 消息体：" + message);

        Method method = subscribleMethod.getMethod();

        //执行

        try {

            method.invoke(subscribleClas, message);

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            e.printStackTrace();

        }

    }

复制代码

Subscribe 订阅者

/**

 * <pre>

 *     author  : devyk on 2019-07-27 18:05

 *     blog    : https://juejin.im/user/3368559355637566/posts

 *     github  : https://github.com/yangkun19921001

 *     mailbox : yang1001yk@gmail.com

 *     desc    : This is YSubscribe

 * </pre>

 */



@Target(ElementType.METHOD) //target 描述此注解在哪里使用

@Retention(RetentionPolicy.RUNTIME) //retention 描述此注解保留的时长 这里是在运行时

public @interface YSubscribe {

    YThreadMode threadMode() default YThreadMode.POSTING; //默认是在 post 线程接收数据



    String tag() default "";//根据消息来接收事件

}



复制代码

TreadMode 线程模式

/**

 * <pre>

 *     author  : devyk on 2019-07-27 18:14

 *     blog    : https://juejin.im/user/3368559355637566/posts

 *     github  : https://github.com/yangkun19921001

 *     mailbox : yang1001yk@gmail.com

 *     desc    : This is YThreadMode

 * </pre>

 */

public enum  YThreadMode {

    /**

     * Subscriber will be called directly in the same thread, which is posting the event. This is the default. Event delivery

     * implies the least overhead because it avoids thread switching completely. Thus this is the recommended mode for

     * simple tasks that are known to complete in a very short time without requiring the main thread. Event handlers

     * using this mode must return quickly to avoid blocking the posting thread, which may be the main thread.

     */

    POSTING,



    /**

     * On Android, subscriber will be called in Android's main thread (UI thread). If the posting thread is

     * the main thread, subscriber methods will be called directly, blocking the posting thread. Otherwise the event

     * is queued for delivery (non-blocking). Subscribers using this mode must return quickly to avoid blocking the main thread.

     * If not on Android, behaves the same as {@link #POSTING}.

     */

    MAIN,



    /**

     * On Android, subscriber will be called in Android's main thread (UI thread). Different from {@link #MAIN},

     * the event will always be queued for delivery. This ensures that the post call is non-blocking.

     */

    MAIN_ORDERED,



    /**

     * On Android, subscriber will be called in a background thread. If posting thread is not the main thread, subscriber methods

     * will be called directly in the posting thread. If the posting thread is the main thread, EventBus uses a single

     * background thread, that will deliver all its events sequentially. Subscribers using this mode should try to

     * return quickly to avoid blocking the background thread. If not on Android, always uses a background thread.

     */

    BACKGROUND,



    /**

     * Subscriber will be called in a separate thread. This is always independent from the posting thread and the

     * main thread. Posting events never wait for subscriber methods using this mode. Subscriber methods should

     * use this mode if their execution might take some time, e.g. for network access. Avoid triggering a large number

     * of long running asynchronous subscriber methods at the same time to limit the number of concurrent threads. EventBus

     * uses a thread pool to efficiently reuse threads from completed asynchronous subscriber notifications.

     */

    ASYNC



}

复制代码

unRegister取消注册

    /**

     * 取消注册订阅者

     */

    public void unRegister(Object subscriber) {

        Log.i(TAG, "unRegister start：当前注册个数" + mChacheSubscribleMethod.size());

        Class<?> subClas = subscriber.getClass();

        List<YSubscribleMethod> ySubscribleMethodList = mChacheSubscribleMethod.get(subClas);

        if (ySubscribleMethodList != null)

            mChacheSubscribleMethod.remove(subscriber);



        Log.i(TAG, "unRegister success：当前注册个数" + mChacheSubscribleMethod.size());

    }



复制代码

框架怎么实现根据 TAG 接收消息

这个其实很简单，拿到 post 发送的 tag,跟订阅者的 tag 比较下就行了。其实只要了解原理也没有那么难得。

//判断这个方法是否接收事件

                if (!TextUtils.isEmpty(tag) && subscribleMethod.getTag().equals(tag) //注解上面的 tag 是否跟发送者的 tag 相同，相同就接收

                        && subscribleMethod.getEventType().isAssignableFrom(object.getClass() //判断类型

                )

复制代码

总结

最后我们根据开源项目 EventBus 实现了自己 代码传送阵 YEventBus 框架，可以根据 TAG 发送/接收消息。只要了解开源框架原理，根据自己需求改动原有框架或者实现自己的框架都不是太难，加油！

移动架构 (一) 架构第一步，学会画各种 UML 图

移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架

AMS 介绍

ActivityManagerService 简称 AMS , 是 Android 内核中核心功能之一，由 com.android.server.SystemService.java 启动。

AMS 启动流程

以下流程因为涉及的源代码太多了 , 我这里以 UML 流程图跟代码截图以示

Android 系统启动

应用进程启动

ServiceManager 启动

AMS 注册

AMS 启动详解

代码流程:

1. 
   

   AMS 具体是在 SystemService 进中启动的，主要是在 com/android/server/SystemServer.java main() 函数中进行。

   
   

       /**
   
        * 这里的 main 函数 主要是 zygote 通过反射调用
   
        */
   
       public static void main(String[] args) {
   
           new SystemServer().run();
   
       }
   
   复制代码



2. 
   

   从上图可以得知 main 方法主要是执行的 com/android/server/SystemServer.java run() 函数，我们具体来看下 run() 到底干了什么？

   
   

       private void run() {
   
           try {
   
   				....
   
               //加载了动态库libandroid_servers.so
   
               System.loadLibrary("android_servers");
   
               //创建SystemServiceManager，它会对系统的服务进行创建、启动和生命周期管理
   
               mSystemServiceManager = new SystemServiceManager(mSystemContext);
   
               mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
   
               LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
   
           } finally {
   
      
   
           }
   
   
   
           // 启动各种服务
   
           try {
   
               traceBeginAndSlog("StartServices");
   
             //启动了ActivityManagerService、PowerManagerService、PackageManagerService 等服务
   
               startBootstrapServices();
   
             // 启动了BatteryService、UsageStatsService和WebViewUpdateService 等服务
   
               startCoreServices();
   
             // 启动了CameraService、AlarmManagerService、VrManagerService等服务
   
               startOtherServices();
   
               SystemServerInitThreadPool.shutdown();
   
             
   
             ....
   
               
   
           } catch (Throwable ex) {
   
               throw ex;
   
           } finally {
   
               traceEnd();
   
           }
   
           // Loop forever.
   
           Looper.loop();
   
           throw new RuntimeException("Main thread loop unexpectedly exited");
   
       }
   
   复制代码

   run () 函数核心任务就是初始化一些事务和核心服务启动，这里核心服务初略有 80 多个，系统把核心服务大概分为了 3 类，分别是引导服务、核心服务和其他服务，因为这小节主要研究 AMS 启动，所以我们只关注 startBootstrapServices(); 内容就行了。

   
   


3. 
   

   startBoostrapService() 这个函数的主要作用，根据官方的意思就是启动需要获得的小型的关键服务。 这些服务具有复杂的相互依赖性，这就是我们在这里将它们全部初始化的原因。 除非您的服务也与这些依赖关系缠绕在一起，否则应该在其他一个函数中初始化它。

   
   

   public void startBootstrapServices(){
   
     ...
   
       
   
       		//启动 AMS 服务
   
           mActivityManagerService = mSystemServiceManager.startService(
   
           ActivityManagerService.Lifecycle.class).getService();
   
     			//设置管理器
   
           mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
   
     			//设置安装器
   
           mActivityManagerService.setInstaller(installer);
   
     
   
     ...
   
       
   
   }
   
   复制代码

   这里主要调用 SystemServiceManager 的 startService 方法，方法的参数是 ActivityManagerService.Lifecycle.class com/android/server/SystemServiceManager.java 我们再来看看 SSM 的 startService 方法主要干嘛了?

   
   


4. 
   

   SSM startService(Class serviceClass)

   
   

       public  T startService(Class serviceClass) {
   
           try {
   
             ...
   
               final T service;
   
               try {
   
                   Constructor constructor = serviceClass.getConstructor(Context.class);
   
                   //实例化对象
   
                   service = constructor.newInstance(mContext);
   
               }  catch (InvocationTargetException ex) {
   
                   throw new RuntimeException("Failed to create service " + name
   
                           + ": service constructor threw an exception", ex);
   
               }
   
   
   
               startService(service);
   
               return service;
   
           } finally {
   
               Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
   
           }
   
       }
   
   复制代码

   跟踪代码可以得知 startService 方法传入的参数是 Lifecycle.class，Lifecycle 继承自 SystemService 。首先，通过反射来创建 Lifecycle 实例，得到传进来的 Lifecycle 的构造器 constructor ，接着又调用 constructor 的newInstance 方法来创建 Lifecycle 类型的 service 对象。接着将刚创建的 service 添加到 ArrayList 类型的mServices 对象中来完成注册。最后在调用 service 的 onStart 方法来启动 service ，并返回该 service 。Lifecycle 是 AMS 的内部类。

   
   


5. 
   

   Lifecycle 走向

   
   

       public static final class Lifecycle extends SystemService {
   
           private final ActivityManagerService mService;
   
   
   
           public Lifecycle(Context context) {
   
               super(context);
   
               mService = new ActivityManagerService(context);
   
           }
   
   
   
           @Override
   
           public void onStart() {
   
               mService.start();
   
           }
   
   
   
           public ActivityManagerService getService() {
   
               return mService;
   
           }
   
       }
   
   复制代码

   主要执行 Lifecyle onStart()

   
   

       public void startService(@NonNull final SystemService service) {
   
           // 把 AMS 服务添加到系统服务中
   
           mServices.add(service);
   
           // Start it.
   
           long time = System.currentTimeMillis();
   
           try {
   
             //执行 Lifecyle 重 onStart 函数方法
   
               service.onStart();
   
           } catch (RuntimeException ex) {
   
               throw new RuntimeException("Failed to start service " + service.getClass().getName()
   
                       + ": onStart threw an exception", ex);
   
           }
   
           warnIfTooLong(System.currentTimeMillis() - time, service, "onStart");
   
       }
   
   复制代码

   上面第四步调用 constructor 的 newInstance 方法已经实例化了 Lifecycle 并创建 new

   
   

   ActivityManagerService(context); 对象，接着又在第四步 startService(service) 调用了 service.start();实际上是调用了 Lifecyle onStart 函数方法。

   
   


6. 
   

   ActivityManagerService getService()

   
   

           mActivityManagerService = mSystemServiceManager.startService(
   
                   ActivityManagerService.Lifecycle.class).getService();
   
   复制代码

   从上面代码得知实际上是调用了 AMS 中内部类 Lifecycle 中的 getService 函数返回了 AMS 实例，那么 AMS 实例就相当于创建了。

   
   


7. 
   

   最后启动 AMS 进程是在 Zygote 中执行的，可以参考应用进程中的流程图。

移动架构 (一) 架构第一步，学会画各种 UML 图

Android 中消息机制

Android 的消息机制主要指 Handler 的运行机制，先来看下 Handler 的一张运行架构图来对 Handler 有个大概的了解。

Handler 消息机制图:

Handler 类图:

以上图的解释:

1. 以 Handler 的 sendMessage () 函数为例，当发送一个 message 后，会将此消息加入消息队列 MessageQueue 中。
2. Looper 负责去遍历消息队列并且将队列中的消息分发非对应的 Handler 进行处理。
3. 在 Handler 的 handlerMessage 方法中处理该消息，这就完成了一个消息的发送和处理过程。

这里从图中可以看到 Android 中 Handler 消息机制最重要的四个对象分别为 Handler 、Message 、MessageQueue 、Looper。

ThreadLocal 的工作原理

ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据, 数据存储以后，只有再指定线程中可以获取到存储的数据，对于其它线程来说则是无法获取到存储的对象。下面就是我们验证 ThreadLocal 存取是否是按照刚刚那样所说。

• 子线程中存，子线程中取

   	// 代码测试       
  
   	new Thread("thread-1"){
  
              @Override
  
              public void run() {
  
                  ThreadLocal<String> mThread_A = new ThreadLocal();
  
                  mThread_A.set("thread-1");
  
                  System.out.println("mThread_A :"+mThread_A.get());
  
  
  
              }
  
          }.start();
  
  
  
  	//打印结果
  
  	mThread_A :thread-1
  
  复制代码

• 主线程中存，子线程取

  	//主线程中存，子线程取    
  
  	final ThreadLocal<String> mThread_B = new ThreadLocal();   
  
  	mThread_B.set("thread_B");      
  
  	new Thread(){
  
              @Override
  
              public void run() {
  
                  System.out.println("mThread_B :"+mThread_B.get());
  
              }
  
          }.start();
  
  
  
  	//打印结果
  
  	mThread_B :null
  
  复制代码

• 主线程存，主线程取

  	//主线程存，主线程取
  
          ThreadLocal<String> mThread_C = new ThreadLocal();
  
          mThread_C.set("thread_C");
  
          System.out.println("mThread_C :"+mThread_C.get());
  
  
  
  	//打印结果
  
  	mThread_C :thread_C
  
  复制代码

结果是不是跟上面我们所说的答案一样，那么为什么会是这样勒？现在我们带着问题去看下 ThreadLocal 源码到底做了什么？

从上图可以 ThreadLocal 主要函数组成部分，这里我们用到了 set , get 那么就从 set , get 入手吧。

ThreadLocal set(T):

（图 1）

（图 2）

（图 3）

(图 四)

从 (图一) 得知 set 函数里面获取了当前线程，这里我们主要看下 getMap(currentThread) 主要干什么了？

从 (图二) 中我们得知 getMap 主要是从当前线程拿到 ThreadLocalMap 这个实例对象，如果当前线程的 ThreadLocalMap 为 NULL ，那么就 createMap ，这里的 ThreadLocalMap 可以暂时理解为一个集合对象就行了，它 (图四) 底层是一个数组实现的添加数据。

ThreadLocal T get():

这里的 get() 函数其实已经能够说明为什么在不同线程存储的数据拿不到了。因为存储是在当前线程存储的，取数据也是在当前所在的线程取得，所以不可能拿到的。带着问题我们找到了答案。是不是有点小激动呀？(^▽^)

Android 消息机制源码分析

这里我们就直接看源码，一下是我看源码的流程。

1. 创建全局唯一的 Looper 对象和全局唯一 MessageQueue 消息对象。

   

2. Activity 中创建 Handler。

   

3. Handler sendMessage 发送一个消息的走向。

   

4. Handler 消息处理。

   

消息阻塞和延时

阻塞和延时

Looper 的阻塞主要是靠 MessageQueue 来实现的，在 MessageQueue -> next() nativePollOnce(ptr, nextPollTimeoutMillis) 进行阻塞 , 在 MessageQueue -> enqueueMessage() -> nativeWake(mPtr) 进行唤醒。主要依赖 native 层的 looper epoll 进制进行的。

阻塞和延时，主要是 next() 的 nativePollOnce(ptr , nextPollTimeoutMillis) 调用 native 方法来操作管道，由 nextPollTimeoutMillis 决定是否需要阻塞 , nextPollTimeoutMilis 为 0 的时候表示不阻塞 , 为 -1 的时候表示一直阻塞直到被唤醒，其它时间表示延时。

唤醒

主要是指 enqueueMessage () @MessageQueue 进行唤醒。

阻塞 -> 唤醒 消息切换

总结

简单的理解阻塞和唤醒就是在主线程的 MessageQueue 没有消息时，便阻塞在 Loop 的 queue.next() 中的 nativePollOnce() 方法里面，此时主线程会释放 CPU 资源进入休眠状态，直到下一个消息到达或者有消息的时候才触发，通过往 pipe 管道写端写入数据来唤醒主线程工作。

这里采用的 epoll 机制，是一种 IO 多路复用机制，可以同时监控多个描述符，当某个描述符就绪 (读或写就绪) , 则立刻通知相应程序进行读或者写操作，本质同步 I/O , 即读写是阻塞的。所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量的 CPU 资源。

延时入队

主要指 enqueueMessage() 消息入队列（Message 单链表），上图代码对 message 对象池重新排序，遵循规则 ( when 从小到大) 。

此处 for 死循环退出情况分为两种

1. p == null 表示对象池中已经运行到了最后一个，无需要再循环。
2. 碰到下一个消息 when 小于前一个，立马退出循环 (不管对象池中所有 message 是否遍历完) 进行重新排序。

好了，到了这里 Handler 源码分析算是告一段落了，下面我们来看下面试中容易被问起的问题。

常见问题分析

为什么不能在子线程中更新 UI ，根本原因是什么？

mThread 是主线程，这里会检查当前线程是否是主线程，那么为什么没有在 onCreate 里面没有进行这个检查呢？这个问题原因出现在 Activity 的生命周期中 , 在 onCreate 方法中， UI 处于创建过程，对用户来说界面还不可见，直到 onStart 方法后界面可见了，再到 onResume 方法后页面可以交互，从某种程度来讲, 在 onCreate 方法中不能算是更新 UI，只能说是配置 UI，或者是设置 UI 属性。 这个时候不会调用到 ViewRootImpl.checkThread () , 因为 ViewRootImpl 没有创建。 而在 onResume 方法后， ViewRootImpl 才被创建。 这个时候去交户界面才算是更新 UI。

setContentView 知识建立了 View 树，并没有进行渲染工作 (其实真正的渲染工作实在 onResume 之后)。也正是建立了 View 树，因此我们可以通过 findViewById() 来获取到 View 对象，但是由于并没有进行渲染视图的工作，也就是没有执行 ViewRootImpl.performTransversal。同样 View 中也不会执行 onMeasure (), 如果在 onResume() 方法里直接获取 View.getHeight() / View.getWidth () 得到的结果总是 0。

为什么主线程用 Looper 死循环不会引发 ANR 异常？

简单来说就是在主线程的 MessageQueue 没有消息时，便阻塞在 loop 的 queue.next() 中的 nativePollOnce() 方法，此时主线程会释放 CPU 资源进入休眠状态，直到下个消息到达或者有事务发生，通过往 pipe 管道写入数据来唤醒主线程工作。这里采用的是 epoll 机制，是一种 IO 多路复用机制。

为什么 Handler 构造方法里面的 Looper 不是直接 new ?

如果在 Handler 构造方法里面直接 new Looper(), 可能是无法保证 Looper 唯一，只有用 Looper.prepare() 才能保证唯一性，具体可以看 prepare 方法。

MessageQueue 为什么要放在 Looper 私有构造方法初始化？

因为一个线程只绑定一个 Looper ,所以在 Looper 构造方法里面初始化就可以保证 mQueue 也是唯一的 Thread 对应一个 Looper 对应一个 mQueue。

Handler . post 的逻辑在哪个线程执行的？是由 Looper 所在线程还是 Handler 所在线程决定的？

由 Looper 所在线程决定的。逻辑是在 Looper.loop() 方法中，从 MessageQueue 中拿出 message ,并且执行其逻辑，这里在 Looper 中执行的，因此有 Looper 所在线程决定。

MessageQueue.next() 会因为发现了延迟消息，而进行阻塞。那么为什么后面加入的非延迟消息没有被阻塞呢？

可以参考 消息阻塞和延时 -> 唤醒

Handler 的 dispatchMessage () 分发消息的处理流程？

1. 属于 Runnable 接口。

2. 通过下面代码形式调用。

       private static Handler mHandler = new Handler(new Handler.Callback() {
   
           @Override
   
           public boolean handleMessage(Message msg) {
   
               return true;
   
           }
   
       });
   
   复制代码

3. 如果第一步，第二部都不满足直接走下面 handlerMessage 参考下面代码实现方式

       private static Handler mHandler = new Handler(){
   
           @Override
   
           public void handleMessage(Message msg) {
   
               super.handleMessage(msg);
   
           }
   
       };
   
   复制代码

也可以通过 debug 方式来具体看 dispatchMessage 执行状态。

实现自己的 Handler 简单架构

主要实现测试代码

代码传送阵

前言

上一篇移动应用遗留系统重构（5）- 重构方法篇我们分享了进行依赖解除的重构流程。主要为4个操作步骤，识别内聚包、解除依赖、移动、验收。同时最后也提出了一个问题，重构时如何保证功能的正确性，不会修改出新问题？

其实这个问题容易但又不简单。容易的是把修改得功能仔细测一篇保证所有功能正常就可以了。不简单的是如何全面、高效、可重复的执行这个过程。我们很容易联想到的方案就是自动化测试。但最大的问题是，对大部分遗留系统来说都是没有任何自动化测试。而且大量的坏味道代码，可测试性低，我们也很难补充充分的自动化测试。那么我们有什么折中的策略吗？

测试策略

我们先来看看Google Android开发者官网上对于测试的介绍，将不同的类型的测试分为三类测试（即小型、中型和大型测试）。

图片来源developer.android.com

• 小型测试是指单元测试，用于验证应用的行为，一次验证一个类。


• 中型测试是指集成测试，用于验证模块内堆栈级别之间的互动或相关模块之间的互动。


• 大型测试是指端到端测试，用于验证跨越了应用的多个模块的用户操作流程。

前面提到对于遗留单体系统来说通常没有任何自动化测试，并且通常内部结构耦合严重，所以实施中小型的成本非常高。显然对于遗留系统，测试金字塔模型适用度较低。 所以对于遗留系统，可能比较适合的策略模型如下：

对于遗留单体系统，一个可行的思路是先补充中大型的测试，作为基本的冒烟测试，重构优化内部结构后再及时补充中小型测试。

CloudDisk示例

对于我们这个浓缩版的CloudDisk，界面上也比较简单。主要是有一个主界面，主界面上主要为文件、动态、用户。（后续的MV*重构篇会持续补充页面交互及逻辑）

我们可以设计一组UI的测试验证基本的功能。主要的几个测试点如下：

1. 主界面能正常运行并显示3个Fragment


2. 3个Fragment能正常显示


3. 点击登录按钮，能够跳转到登录页面

测试设计的用例如下：

@RunWith(AndroidJUnit4.class)

@LargeTest

public class SmokeTesting {



    @Test

    public void should_show_fragment_list_when_activity_launch() {

        //given

        ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);

        scenario.onActivity(activity -> {

            //when

            onView(withText(R.string.tab_user)).perform(click());

            //then

            List fragments = activity.getSupportFragmentManager().getFragments();

            assertThat(fragments.size() == 3);

            assertThat(fragments.get(0) instanceof FileFragment);

            assertThat(fragments.get(1) instanceof DynamicFragment);

            assertThat(fragments.get(2) instanceof UserCenterFragment);

        });

    }



    @Test

    public void show_show_file_ui_when_click_tab_file() {

        //given

        ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);

        scenario.onActivity(activity -> {

            //when

            onView(withText(R.string.tab_file)).perform(click());

            //then

            onView(withText("Hello file fragment")).check(matches(isDisplayed()));

        });

    }



    @Test

    public void show_show_dynamic_ui_when_click_tab_dynamic() {

        //given

        ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);

        scenario.onActivity(activity -> {

            //when

            onView(withText(R.string.tab_dynamic)).perform(click());

            //then

            onView(withText("Hello dynamic fragment")).check(matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE)));

        });

    }



    @Test

    public void show_show_user_center_ui_when_click_tab_dynamic() {

        //given

        ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);

        scenario.onActivity(activity -> {

            //when

            onView(withText(R.string.tab_user)).perform(click());

            //then

            onView(withText("Hello user center fragment")).check(matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE)));

        });

    }



    @Test

    public void show_show_login_ui_when_click_login_button() {

        //given

        ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);

        scenario.onActivity(activity -> {

            Intents.init();

            //when

            onView(withId(R.id.fab)).perform(click());

            //then

            intended(IntentMatchers.hasComponent("com.cloud.disk.platform.login.LoginActivity"));

            Intents.release();

        });

    }

}

复制代码

详细代码见Github提交

我们可以将用例运行在Robolectric上，提高反馈的速度，执行命令如下：

./gradlew testDebug --tests SmokeTesting

复制代码

测试执行结果如下：

当然实际的项目里情况更复杂，数据可能来自网络服务、数据库等等。我们还需要进行Mock。后续的MV*重构篇会持续补充常见坏味道示例代码及更多的自动化测试用例。

更多测试框架及设计可以参考Google官方
在 Android 平台上测试应用

总结

这一篇我们介绍了常用的测试分类及遗留系统的测试策略，对于遗留单体系统，一个可行的思路是先补充中大型的测试，作为基本的冒烟测试，重构优化内部结构后再及时补充中小型测试。同时也给CloudDisk补充了一组基础的大型测试作为冒烟测试，作为后续重构的基本守护测试。

下一篇移动应用遗留系统重构（7）- 解耦重构演示篇（一） 我们将基于方法篇的流程开始对CloudDisk进行重构的改造，具体的解耦操作会以视频的方式展示。

参考资料

developer.android.com

CloudDisk示例代码

CloudDisk

系列链接

移动应用遗留系统重构（1）- 开篇

移动应用遗留系统重构（2）-架构篇

移动应用遗留系统重构（3）-示例篇

移动应用遗留系统重构（4）-分析篇

移动应用遗留系统重构（5）- 重构方法篇

大纲

前言

上一篇

移动应用遗留系统重构（4）-分析篇  我们根据CloudDisk未来的架构，借助ArchUnit进行架构测试守护以及Intellij的Dependendencies分析出了按照未来的架构设计需要解决的异常依赖。

这一篇开始我们将分享进行依赖解除的重构流程、方法以及常用的工具使用。

重构流程

1.识别内聚的包

对于移动应用通常我们可以通过产品的业务划分进行领域的识别划分。例如CloudDisk这个产品的相对还是比较清晰，业务上主要分为文件、动态及个人中心。

对于部分遗留系统来说，旧代码可能散落在不同的包下，或者原先的代码组织方式是以功能划分，而非业务划分。就像CloudDisk的代码一样，第一步我们得先把相关的业务代码组织到同一包下，这个阶段我们可以先不管是否存在异常依赖，因为只有先组织到一个内聚的包下才方便我们进行依赖分析及代码重构。

2.解除异常依赖

这里我们将介绍几种通用的依赖解除手法。包含下沉、接口提取、路由跳转。

后续的演示篇会通过视频进行具体的操作演示

重构手法：

1. 类下沉

• 
  

  将具体类移动到适当的 Lib 模块中

  
  


• 
  

  在调用模块增加对该 Lib 的依赖

  
  

2. 接口提取

• 在适当的公用模块中创建空的接口


• 将调用具体页面类的跳转代码块所在的包中建立新的实现类实现该接口


• (自动)将调用代码块通过 Extract method 提取成新方法

如已经是独立方法跳过此步

• (自动)在原调用逻辑所属的类中增加实现类的成员变量作为delegate

需要预留 Inject 接口，建议采用 Constructor Inject，静态成员提供setter

• (自动)将新方法调用转移到delegate中

如果是静态方法先通过 Change Method Signature 将 delegate 作为参数传给该方法

• (自动)将新方法 Pull up 到接口中


• (自动)将实现类移动到壳程序中


• 在壳程序中实现实现类的Inject

3. 路由跳转

• 在跳转类定义对应的映射Path


• 在调用处使用对应的path进行跳转

3.移动代码及资源

当包的异常依赖全部解耦完后，就可以直接进行移动了。这里我们分享2中常用的代码移动方式。

1. Move

这种方式大家应该比较常用，选择一个File或者Directory,按下F6选择希望移动后的目录则可。

但是这种方式会存在一个问题，就是被移动的类如果依赖了其他的类或者资源，移动后会出现依赖异常。

适用场景：移动的File或Directory没有其他的依赖

2. Modularize

Modularize能够分析出移动的File存在的相关依赖，并一起关联移动，很好解决Move的痛点，非常适用于跨Module的移动。

选择移动的Module后点击Preview。

这里注意，有一些划线的文件，那是因为这个文件同时被多处引用，如果跟随一起移动，那么其他的地方会报错。所以我们需要将划线的文件先移动至公用的合适位置。待Preview没有任何的文件划线时，就可以进行移动。

4.包解耦验收

• 所有模块编译通过


• 所有新增模块符合模块依赖规则


• 通过架构守护测试

总结

这一篇我们分享了进行依赖解除的重构流程，主要为4个操作步骤，识别内聚包、解除依赖、移动、验收。同时也介绍了Intellij中非常好用的Modularize功能。接下来我们就可以开始动手进行代码重构，但此时我们又面临着另外一个问题，也是很多同学在做重构时经常担心的一个问题。重构时如何保证功能的正确性，不会修改出新问题。

下一篇移动应用遗留系统重构（6）- 测试篇，我们将分享对于单体移动应用遗留系统，如何制定测试策略及有效补充自动化测试，更好为重构保驾护航。

系列链接

移动应用遗留系统重构（1）- 开篇

移动应用遗留系统重构（2）-架构篇

移动应用遗留系统重构（3）-示例篇

移动应用遗留系统重构（4）-分析篇

大纲

前言

上一篇移动应用遗留系统重构（3）-示例篇我们介绍了CloudDisk的业务及代码现状。分享了“理想”（未来的架构设计）与“现实”（目前的代码现状），接下来在我们开始动手进行重构时，我们首先得知道往理想的设计架构演化，中间存在多少问题。一方面作为开始重构的输入，另外一方面我们有数据指标，也能更好评估工作量及衡量进度。

接下来我们将根据架构篇团队采用的架构设计，结合目前的代码，总结分析工具及方法。

架构设计

我们先回忆一下架构篇里团队采用的架构设计。

1. 代码复用

• 公共能力复用，有一层专门统一管理应用公用的基础能力，如图片、网络、存储能力、安全等


• 公用业务能力复用，有一层专门统一管理应用的业务通用组件，如分享、推送、登录等

2. 低耦合

• 业务模块间通过API方式依赖，不依赖具体的模块实现


• 依赖方向清晰，上层模块依赖下层模块

3. 并行研发

• 业务模块支持独立编译调试


• 业务模块独立发布

结合该4层架构、已有的代码，以及业务的后续演化，团队设计的新架构如下

分析工具

ArchUnit

有了架构设计后，我们就能识别代码的边界，这里我们可以通过Archunit进行边界约束描述。我们可以得到2条通用的守护规则。

1. 垂直方向，下层模块不能反向依赖上层


2. 横向方向，组件之间不能存在相互的依赖

转化为ArchUnit的测试用例如下:

  @ArchTest

    public static final ArchRule architecture_layer_should_has_right_dependency =layeredArchitecture()

            .layer("Library").definedBy("..cloud.disk.library..")

            .layer("PlatForm").definedBy("..cloud.disk.platform..")

            .layer("FileBundle").definedBy("..cloud.disk.bundle.file..")

            .layer("DynamicBundle").definedBy("..cloud.disk.bundle.dynamic..")

            .layer("UserBundle").definedBy("..cloud.disk.bundle.user..")

            .layer("AllBundle").definedBy("..cloud.disk.bundle..")

            .layer("App").definedBy("..cloud.disk.app..")

            .whereLayer("App").mayOnlyBeAccessedByLayers()

            .whereLayer("FileBundle").mayOnlyBeAccessedByLayers("App")

            .whereLayer("DynamicBundle").mayOnlyBeAccessedByLayers("App")

            .whereLayer("UserBundle").mayOnlyBeAccessedByLayers("App")

            .whereLayer("PlatForm").mayOnlyBeAccessedByLayers("App","AllBundle")

            .whereLayer("Library").mayOnlyBeAccessedByLayers("App","AllBundle","PlatForm");

复制代码

当然这个用例的执行是失败的，因为我们基本的包结构还没有调整。但有了架构守护测试用例，我们就可以逐步把代码移动到对应的Package中，直到守护用例运行通过为止。

接下来我们先运用IDE工具进行基础的包结构调整，调整后的结构如下

调整后运行ArchUnit测试运行结果如下

这些异常的提示就是我们需要处理的异常依赖。但是ArchUnit的这个提示比较不不友好，接下来我们介绍另外一种分析异常依赖的方式，使用Intellij Dependencies 。

Intellij Dependencies

我们选择对应的Package，选择Analyze菜单，点击Dependencies，可以找出该Package所依赖的相关类。

我们选择dynamic Package进行分析后，发现根据现有的架构约束，存在横向的Bundle依赖需要进行解除依赖。

我是在实际重构过程中，我们可以频繁借助该功能验证耦合解除情况，并且同时通过ArchUnit测试做好守护。

详细代码见Cloud Disk

总结

这一篇我们分享了如何借助工具进行异常依赖的分析。当我们有了未来的架构设计后，可以借助ArchUnit进行架构测试守护，通过Intellij的Dependendencies 我们可以方便以Package或者Class为单位进行依赖分析。

当我们已经分析出需要处理的异常依赖，接下来我们就可以逐步进行重构。下一篇，我们将给大家分享实践总结的一些重构套路，移动应用遗留系统重构（5）- 重构方法篇。

系列链接

大纲

前言

上一篇移动应用遗留系统重构（2）-架构篇我们介绍了业内的优秀架构实践以及CloudDisk团队根据业务情况设计的分层架构。

这一篇我们将介绍一个浓缩版的示例，示例中我们设计了一些常见的异常依赖，后续的重构篇我们也将基于这个示例进行操作演示。为了简化代码及对业务上下文的理解，示例中的部分实现都是空实现，重点体现异常的耦合依赖。

仓库地址：CloudDisk

CloudDisk示例

项目概述

CloudDisk是一个类似于Google Drive的云存储应用。该应用主要拥有3大核心业务模块。

1. 文件模块:用于管理用户云端文件系统。用户能够上传、下载、浏览文件。


2. 动态模块:类似微信朋友圈，用于可以在动态上分享信息及文件


3. 个人中心模块:用于管理用户个人信息

问题说明

该项目已经维护超过10年以上，目前有用开发人员100+。代码在一个大单体模块中，约30w行左右，编译时间5分钟以上。团队目前主要面临几个问题。

1. 开发效率低，编译时间长，经常出现代码合并冲突


2. 代码质量差，经常修改出新问题


3. 市场响应慢，需要对齐各个模块进行整包发布

代码分析

代码在一个Module中，且在一个Git仓中管理。采用"MVC"结构，按功能进行划分Package。

包结构如下：

主要包说明：

主要类说明：

详细源码见CloudDisk

为了简化业务上下文理解，代码都是空实现，只体现模块的异常依赖，后续的MV*重构篇会持续补充常见坏味道示例代码。

总结

CloudDisk在业务最初发展的时候，采用了单一Module及简单“MVC”架构很好的支持了业务的发展，但随着业务的演化及人员膨胀，这样的模式已经很难高效的支持业务及团队的发展。

前面我们已经分享了“理想”（未来的架构设计）与“现实”（目前的代码现状），接下来在我们开始动手进行重构时，我们首先得知道往理想的设计架构演化，中间存在多少问题。一方面作为开始重构的输入，另外一方面我们有数据指标，也能评估工作量及衡量进度。

下一篇，我们将给大家分享移动应用遗留系统重构（4）-分析篇。介绍常用的分析工具及框架，并对CloudDisk团队目前的代码进行分析。

系列链接

大纲

前言

上一篇移动应用遗留系统重构（1）- 开篇我们分享了移动应用遗留系统常见的问题。那么好的实践或者架构设计是怎样的呢？

这一篇我们将整理业内优秀的移动应用架构设计，包含微信、淘宝、支付宝以及美团外卖。其中的部分产品也经历过遗留系统的重构改造，具有非常好的参考意义。

优秀实践

微信

从微信对外分享的架构演进文章中可知，微信应用其实也是经历了从大单体到模块化的演进。

图片来源 微信Android模块化架构重构实践

我们看下介绍中后续改造后的架构设计。

图片来源 微信Android模块化架构重构实践

设计中提到重构主要3个目标

• 改变通信方式 （API化）


• 重新设计模块 （中心化业务代码回归各自业务）


• 约束代码边界 （pins工程结构，更细粒度管控边界）

我们可以发现重构后架构比原来的单体应用的一些变化。

1. 业务模块独立编译调试，耦合度低


2. 代码复用高，有统一公共的组件库及kernel


3. 模块职责、代码边界清晰，强约束

更多信息可阅读原文，微信Android模块化架构重构实践

手淘

从手机淘宝客户端架构探索实践的分享中介绍到手机淘宝从1.0用单工程编写开始，东西非常简陋；到2.0为索引许多三方库的庞大的单工程；再到3.0打破了单工程开发模式实现业务复用。

图片来源 手机淘宝客户端架构探索实践

淘宝架构主要分为四层，最上层是组件Bundle(业务组件)，往下是容器(核心层)，中间件Bundle(功能封装)，基础库Bundle(底层库)。

文章提到架构演化的一些优点及变化很值得深思。

1. 业务复用，减少人力


2. 基础复用，做深做精


3. 敏捷开发，快速试错

支付宝

在支付宝mPass实践讨论分析一文中，提到支付宝客户端的总体架构图如下。

图片来源 开篇 | 模块化与解耦式开发在蚂蚁金服 mPaaS 深度实践探讨

分享文章中介绍到5层架构设计如下：

• 
  

  最底层是支付宝框架的容器层，包括类加载资源加载和安全模块；

  
  


• 
  

  第二层是我们抽离出来的组件层，包括网络库，日志库，缓存库，多媒体库，日志等等，简单说这些是一些通用的能力层；

  
  


• 
  

  第三层是我们定制的框架层，这是关键部分，是我们得以实现上千人，上千多个工程共同开发一个 App 的基础。

  
  


• 
  

  第四层是基于框架封装出来的业务服务层；

  
  


• 
  

  第五层便是具体的业务模块，其中每一个模块都是一个或多个具体的工程;

  
  

文章中介绍到关于工程之间的依赖关系的处理比较特别。

在支付宝的架构里，编译参与的部分是和运行期参与的部分是分离的：编译期使用 bundle 的接口包，运行期使用 bundle 包本身。bundle 的接口包是 bundle 包的一部分，即刚才说的 bundle 的代码部分。bundle 的资源包同时打进接口包，在编译期提供给另一个 bundle 引用。

更多信息可阅读原文，开篇 | 模块化与解耦式开发在蚂蚁金服 mPaaS 深度实践探讨

美团

最后看另外一个跨平台技术架构相关的分享，在外卖客户端容器化架构的演进分享中提到了美团外包的整体架构如下。

图片来源 外卖客户端容器化架构的演进

特别的一点是是采用了容器化架构，根据业务场景及PV，支持多种容器技术。在文末的总结提到，容器化架构相对于传统的移动端架构而言，充分地利用了现在的跨端技术，将动态化的能力最大化的赋予业务。通过动态化，带来业务迭代周期缩短、编译的加速、开发效率的提升等好处。同时，也解决了面临着的多端复用、平台能力、平台支撑、单页面多业务团队、业务动态诉求强等业务问题。但对线上的可用性、容器的可用性、支撑业务的线上发布上提出了更加严格的要求。

更多信息可阅读原文，外卖客户端容器化架构的演进

总结

架构是为了解决业务的问题，没有银弹。 但通过这些业内的优秀实践分享，我们可以发现一些优秀的设计范式。

1. 代码复用

• 公共能力复用，有专门统一管理应用公用的基础能力，如图片、网络、存储能力、安全等


• 公用业务能力复用，有专门统一管理应用的业务通用组件，如分享、推送、登录等

2. 低耦合，高内聚

• 业务模块间通过API方式依赖，不依赖具体的模块实现


• 依赖方向清晰，上层模块依赖下层模块

3. 并行研发

• 业务模块支持独立编译调试


• 业务模块独立发布

结合这些特点及CloudDisk团队的业务，团队采用的架构设计如下。

下一篇，移动应用遗留系统重构（3）- 示例篇，我们将继续介绍CloudDisk的业务及团队问题，分析现有的代码。

参考

微信Android模块化架构重构实践

手机淘宝客户端架构探索实践

参考来自阿里云开发者社区，但链接已失效

开篇 | 模块化与解耦式开发在蚂蚁金服 mPaaS 深度实践探讨

外卖客户端容器化架构的演进

系列链接

大纲

哈喽，大家好，我是西哥！

又到了大家最喜欢了的环节--开源库推荐，前面为大家推荐了我收藏的一些非常酷的开源库，受到大家一致好评，还没看过的，请移步至：

【Android珍藏】推荐10个炫酷的开源库

【开源推荐】进阶实战，从一款音乐播放器开始

【2020年GitHub 上那些优秀Android开源库，这里是Top10！】

本期又为大家带来了哪些有趣的库呢？本期为大家精选了15个有趣又有用的开源，排名不分先后，一起来看看吧！

1. Coil

Coil是Android上的一个全新的图片加载框架，它的全名叫做 coroutine image loader,即协程图片加载库。与传统的图片加载库Glide，Picasso或Fresco等相比。该具有轻量（只有大约1500个方法）、快、易于使用、更现代的API等优势。

它支持GIF和SVG，并且可以执行四个默认转换：模糊，圆形裁剪，灰度和圆角。

示例如下：

imageView.load(“https://www.example.com/image.jpg") {

 crossfade(true)

 placeholder(R.drawable.image)

 transformations(CircleCropTransformation())

}

复制代码

并且是全用Kotlin编写，如果你是纯Kotlin项目的话，那么这个库应该是你的首选。

Github地址：github.com/coil-kt/coi…

2. MultiSearchView

该库具有一个非常酷的Search View 动画！

使用非常简单，并且可以自定义，你可以在在styles.xml下添加自定义样式。

示例代码：

<com.iammert.library.ui.multisearchviewlib.MultiSearchView

        android:layout_width="match_parent"

        android:layout_height="wrap_content"/>     

复制代码

multiSearchView.setSearchViewListener(object : MultiSearchView.MultiSearchViewListener{

    override fun onItemSelected(index: Int, s: CharSequence) {

    }



    override fun onTextChanged(index: Int, s: CharSequence) {

    }



    override fun onSearchComplete(index: Int, s: CharSequence) {

    }



    override fun onSearchItemRemoved(index: Int) {

    }



})

复制代码

自定义样式：

  <!-- Search Text Style. -->

    <style name="SearchTextStyle">

        <!-- Custom values write to here for SearchEditText. -->

        <item name="android:focusable">true</item>

        <item name="android:focusableInTouchMode">true</item>

        <item name="android:enabled">true</item>

        <item name="android:hint">Search</item>

        <item name="android:imeOptions">actionSearch</item>

        <item name="android:textSize">18sp</item>

        <item name="android:maxLength">15</item>

        <item name="android:inputType">textCapSentences</item>

        <item name="android:textColorHint">#80999999</item>

        <item name="android:textColor">#000</item>

    </style>

复制代码

然后，您应该将样式设置为MultiSearchView下的app：searchTextStyle。

Github地址：github.com/iammert/Mul…

3. CalendarView

CalendarView是一个高度可定制化的日历组件库，用recycleView实现。

它有如下特性：

• 单一或范围选择


• 周历或者月历模式


• 边界日期


• 自定义日历视图


• 水平或者垂直滚动模式


• 完全可定制的视图

该库的文档也非常全面，并包含许多示例。此外，还有一个示例应用程序展示了库的所有功能。

它是用纯Kotlin编写的，并在MIT许可下发布。如果您需要在应用程序中使用日历视图，这是一个不错的选择。

注意：该库通过Java 8+ API使用了java.time类，以便向后兼容，因为这些类是在Java 8中添加的。

因此，需要在app的build.gradle 中添加如下配置：

android {

  defaultConfig {

    // Required ONLY when setting minSdkVersion to 20 or lower

    multiDexEnabled true

  }



  compileOptions {

    // Flag to enable support for the new language APIs

    coreLibraryDesugaringEnabled true

    // Sets Java compatibility to Java 8

    sourceCompatibility JavaVersion.VERSION_1_8

    targetCompatibility JavaVersion.VERSION_1_8

  }

}



dependencies {

  coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:<latest-version>'

}

复制代码

Github: github.com/kizitonwose…

4. Bubble Navigation

FloatingTopBarActivity	TopBarActivity

BottomBarActivity	EqualBottomBarActivity

Bubble Navigation是一个轻巧的库，可通过大量自定义选项轻松制作精美的导航栏。

它有很多非常的特性：

• 
  

  针对不同用例的两种类型的NavigationViews：

  
  
  
  
  • 
    

    BubbleNavigationConstraintView（支持spreadspread，inside, 和 packed莫斯）

    
    
  
  
  • 
    

    BubbleNavigationLinearView（允许平均分配，使用权重或packed模式）

    
    
  
  
  
  


• 
  

  高度可定制化

  
  


• 
  

  您可以添加小红点，它具有BubbleToggleView来创建新的UI组件，而不仅仅是导航

  
  

示例：

<com.gauravk.bubblenavigation.BubbleNavigationConstraintView

        android:id="@+id/top_navigation_constraint"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:layout_marginBottom="380dp"

        android:background="@color/white"

        android:elevation="4dp"

        android:padding="12dp"

        app:bnc_mode="spread">



        <com.gauravk.bubblenavigation.BubbleToggleView

            android:id="@+id/c_item_rest"

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            app:bt_active="true"

            app:bt_colorActive="@color/search_active"

            app:bt_colorInactive="@color/search_inactive"

            app:bt_icon="@drawable/ic_restaurant"

            app:bt_shape="@drawable/transition_background_drawable_restaurant"

            app:bt_title="@string/restaurant"

            app:bt_padding="@dimen/internal_padding"

            app:bt_titlePadding="@dimen/title_padding" />



         <!-- Add more child items here - max upto 5 -->

    

    </com.gauravk.bubblenavigation.BubbleNavigationConstraintView>

复制代码

Github文档很完善，有很多示例，更多用法和属性可去Github了解。

Github:github.com/gauravk95/b…

5. FabFilter

这是一个有趣的项目，它不是一个直接可用的库，而是一个示例应用程序，展示了使用和不使用 MotionLayout两种方式来实现的高级UI动画。

详细的实现细节可以看看Medium上的系列文章：

“Complex UI/Animations on Android”

“Complex UI/Animations on Android — featuring MotionLayout”

Github:github.com/nikhilpanju…

6.android-showcase

android-showcase是一个非常优秀的开源项目，它是一个展示应用程序，展示了如何使用Kotlin和最新的Jetpack 技术栈来开发一个APP。

该项目为您带来了一系列最佳实践，工具和解决方案：

• 100% Kotlin


• 现代架构 (feature modules, clean architecture, Model-View-ViewModel, Model-View-Intent)


• Android Jetpack组件


• 单Activity模式，使用Navigation导航

看完这个项目，在模块化，Clean体系结构，测试、设置CI / CD工具，等方面，你将会受到启发。感谢作者的开源。

Github：github.com/igorwojda/a…

7. Croppy

Croppy是一个Android图片裁剪库。

它有很多强大的特性：

• 双指缩放


• 裁剪任意大小


• 按照长宽比例裁剪


• 显示裁剪后的Bitmap


• 自动居中裁剪


• 全面的动画使用体验

更多使用细节请看Github。

Github: github.com/lyrebirdstu…

8. RubberPicker

一个炫酷的、有趣的SeekBar动画库。

RubberPicker库包含RubberSeekBar和RubberRangePicker，其灵感来自Cuberto的iOS橡胶范围选择器。

使用示例：

布局文件中配置

<com.jem.rubberpicker.RubberSeekBar

  ...

  app:minValue="20"

  app:maxValue="80"

  app:elasticBehavior="cubic"

  app:dampingRatio="0.3"

  app:stiffness="300"

  app:stretchRange="24dp"

  app:defaultThumbRadius="16dp"

  app:normalTrackWidth="4dp"

  app:highlightTrackWidth="8dp"

  app:normalTrackColor="#AAAAAA"

  app:highlightTrackColor="#BA1F33"

  app:defaultThumbInsideColor="#FFF"

  app:highlightDefaultThumbOnTouchColor="#CD5D67"/>



<!-- Similar attributes can be applied for RubberRangePicker as well-->

<com.jem.rubberpicker.RubberRangePicker

  ...

  app:minValue="0"

  app:maxValue="100"

  app:elasticBehavior="linear"

  app:dampingRatio="0.4"

  app:stiffness="400"

  app:stretchRange="36dp"

  app:defaultThumbRadius="16dp"

  app:normalTrackWidth="4dp"

  app:highlightTrackWidth="8dp"

  app:normalTrackColor="#AAAAAA"

  app:highlightTrackColor="#BA1F33"

  app:defaultThumbInsideColor="#CFCD5D67"

  app:highlightDefaultThumbOnTouchColor="#CD5D67"/>

复制代码

或者，在代码中动态配置：

val rubberSeekBar = RubberSeekBar(this)

rubberSeekBar.setMin(20)

rubberSeekBar.setMax(80)

rubberSeekBar.setElasticBehavior(ElasticBehavior.CUBIC)

rubberSeekBar.setDampingRatio(0.4F)

rubberSeekBar.setStiffness(1000F)

rubberSeekBar.setStretchRange(50f)

rubberSeekBar.setThumbRadius(32f)

rubberSeekBar.setNormalTrackWidth(2f)

rubberSeekBar.setHighlightTrackWidth(4f)

rubberSeekBar.setNormalTrackColor(Color.GRAY)

rubberSeekBar.setHighlightTrackColor(Color.BLUE)

rubberSeekBar.setHighlightThumbOnTouchColor(Color.CYAN)

rubberSeekBar.setDefaultThumbInsideColor(Color.WHITE)



val currentValue = rubberSeekBar.getCurrentValue()

rubberSeekBar.setCurrentValue(currentValue + 10)

rubberSeekBar.setOnRubberSeekBarChangeListener(object : RubberSeekBar.OnRubberSeekBarChangeListener {

    override fun onProgressChanged(seekBar: RubberSeekBar, value: Int, fromUser: Boolean) {}

    override fun onStartTrackingTouch(seekBar: RubberSeekBar) {}

    override fun onStopTrackingTouch(seekBar: RubberSeekBar) {}

})





//Similarly for RubberRangePicker

val rubberRangePicker = RubberRangePicker(this)

rubberRangePicker.setMin(20)

...

rubberRangePicker.setHighlightThumbOnTouchColor(Color.CYAN)



val startThumbValue = rubberRangePicker.getCurrentStartValue()

rubberRangePicker.setCurrentStartValue(startThumbValue + 10)

val endThumbValue = rubberRangePicker.getCurrentEndValue()

rubberRangePicker.setCurrentEndValue(endThumbValue + 10)

rubberRangePicker.setOnRubberRangePickerChangeListener(object: RubberRangePicker.OnRubberRangePickerChangeListener{

    override fun onProgressChanged(rangePicker: RubberRangePicker, startValue: Int, endValue: Int, fromUser: Boolean) {}

    override fun onStartTrackingTouch(rangePicker: RubberRangePicker, isStartThumb: Boolean) {}

    override fun onStopTrackingTouch(rangePicker: RubberRangePicker, isStartThumb: Boolean) {}

})

复制代码

更多、更详细的使用请看Github。

Github：github.com/Chrisvin/Ru…

9. Switcher

一个炫酷的Switcher 切换动画库，真是的太可爱了，我前面也写过文章专门介绍过：

炫酷！从未见过如此Q弹的Switcher

它的灵感来自于 Dribble上Oleg Frolov 的设计。

Github: github.com/bitvale/Swi…

10. StfalconImageViewer

StfalconImageViewer是一个图片查看库，
该库简单且可定制。它包含一个全屏图像查看器，具有共享的图像过渡支持，捏合缩放功能以及滑动手势来关闭手势。

Github文档说明了如何使用每个功能。同样值得注意的是：该库与所有最受欢迎的图像处理库（例如Picasso，Glide等）兼容。

所有可配置项如下：

StfalconImageViewer.Builder<String>(this, images, ::loadImage)

            .withStartPosition(startPosition)

            .withBackgroundColor(color)

            //.withBackgroundColorResource(R.color.color)

            .withOverlayView(view)

            .withImagesMargin(R.dimen.margin)

            //.withImageMarginPixels(margin)

            .withContainerPadding(R.dimen.padding)

            //.withContainerPadding(R.dimen.paddingStart, R.dimen.paddingTop, R.dimen.paddingEnd, R.dimen.paddingBottom)

            //.withContainerPaddingPixels(padding)

            //.withContainerPaddingPixels(paddingStart, paddingTop, paddingEnd, paddingBottom)

            .withHiddenStatusBar(shouldHideStatusBar)

            .allowZooming(isZoomingAllowed)

            .allowSwipeToDismiss(isSwipeToDismissAllowed)

            .withTransitionFrom(targeImageView)

            .withImageChangeListener(::onImageChanged)

            .withDismissListener(::onViewerDismissed)

            .withDismissListener(::onViewerDismissed)

复制代码

更详细的使用请看Github。

Github: github.com/stfalcon-st…

11. Broccoli

Broccoli是一个show View Loading 库，也就是我常说的骨架屏，在内容加载的时候，显示一个占位符。

该库带有很平滑的动画效果，你可以配合RecyclerView一起使用，等待加载内容时，再也不枯燥了。

示例：

Broccoli broccoli = new Broccoli();



//add the default style placeholder

broccoli.addPlaceholders('activity', 'view_id', 'view_id'); 



or 

//add the default style placeholder

broccoli.addPlaceholders('view1', 'view2', 'view3'); 



or 



//add the custom style placeholder

broccoli.addPlaceholder(new PlaceholderParameter.Builder()

                        .setView('view')

                        .setAnimation('scaleAnimation');

                        .setDrawable(DrawableUtils.createRectangleDrawable(placeHolderColor, 0))

                        .build()); 



or

//add the custom style placeholder with gradient animation

broccoli.addPlaceholder(new PlaceholderParameter.Builder()

                        .setView('view')

                        .setDrawable(new BroccoliGradientDrawable(Color.parseColor("#DDDDDD"),

                            Color.parseColor("#CCCCCC"), 0, 1000, new LinearInterpolator())

                        .build()); 

broccoli.show();

复制代码

更多使用请看Github。

Github: github.com/samlss/Broc…

12. Orbit MVI

这是一个用于Kotlin和Android的Model-View-Intent （MVI）框架。它的灵感来自Jake Wharton，RxFeedback和Mosby的“Managing State with RxJava”。

根据ReadMe所说：

Orbit在您的redux实现周围提供了尽可能小的结构，以使其易于使用，但您仍可以使用RxJava的强大功能。

redux系统可能如下所示：

data class State(val total: Int = 0)



data class AddAction(val number: Int)



sealed class SideEffect {

    data class Toast(val text: String) : SideEffect()

}



class CalculatorViewModel : OrbitViewModel<State, SideEffect> (State(), {



    perform("addition")

        .on<AddAction>()

        .sideEffect { post(SideEffect.Toast("Adding ${event.number}")) }

        .reduce {

            currentState.copy(currentState.total + event.number)

        }



    ...

})

复制代码

activity / fragment 中：

// Example of injection using koin, your DI system might differ

private val viewModel by viewModel<CalculatorViewModel>()



override fun onCreate() {

    ...

    addButton.setOnClickListener { viewModel.sendAction(AddAction) }

}



override fun onStart() {

    viewModel.connect(this, ::handleState, ::handleSideEffect)

}



private fun handleState(state: State) {

    ...

}



private fun handleSideEffect(sideEffect: SideEffect) {

    when (sideEffect) {

        is SideEffect.Toast -> toast(sideEffect.text)

    }

}

复制代码

详细使用请看Github。

Github: github.com/babylonheal…

13. IndicatorScrollView

IndicatorScrollView	IndicatorScrollView

该库为NestedScrollView添加了逻辑，使它可以在滚动时，更改对指示器进行动态响应。

README文件包含开始项目所需的所有信息，例如如何使用IndicatorScrollView，IndicatorView和IndicatorItem。目前,它的版本为1.0.2，是根据Apache 2.0许可发布的。它支持API 16及更高版本。

文档示例很详细，更多使用相关请看Github。

Github： github.com/skydoves/In…

14. Cyanea

Cyanea 是一个Android 主题引擎库。

它允许那你动态更换应用主题，它内置了很多主题如：

• Theme.Cyanea.Dark


• Theme.Cyanea.Dark.LightActionBar


• Theme.Cyanea.Dark.NoActionBar


• Theme.Cyanea.Light


• Theme.Cyanea.Light.DarkActionBar


• Theme.Cyanea.Light.NoActionBar

更多详细信息请看Github。

Github: github.com/jaredrummle…

15. Android MotionLayout Carousel

这是一个示例项目，它展示了如何使用MotionLayout来实现一个炫酷的轮播图。

文档几乎没有任何说明，但是如果你最近也在探索MotionLayout，这将是一个很好示例。

Github: github.com/faob-dev/Mo…

总结

以上就是本期的开源项目推荐，如果你也有好玩的、有趣的、强大的开源项目，也可以推荐给西哥，欢迎评论区留言讨论。

作者：依然范特稀西