APM框架Matrix源码分析（一）整体架构

Matrix监控ANR、启动耗时，卡顿，慢方法，SQLite 操作优化，文件读写，内存泄漏等等，它是如何管理这些检测项的。

从Application的onCreate中初始化：

// build matrix
Matrix.Builder builder = new Matrix.Builder(application);
//...
//init matrix
Matrix.init(builder.build());

public class Matrix {
   //volatile保证可见性
   private static volatile Matrix sInstance;
   //插件的集合plugins，使用HashSet来保证不出现重复
   private final HashSet<Plugin> plugins;
   //Application
   private final Application  application;
   //插件监听
   private final PluginListener  pluginListener; 

   private Matrix(Application app, PluginListener listener, HashSet<Plugin> plugins, MatrixLifecycleConfig config) {
       this.application = app;
       this.plugins = plugins;
       MatrixLifecycleOwnerInitializer.init(app, config);
       ProcessSupervisor.INSTANCE.init(app, config.getSupervisorConfig());
       //逐个调用插件的初始化方法
       for (Plugin plugin : plugins) {
           plugin.init(application, listener);
       }
   }
 
   //plugin会维护子任务，start()会开启子任务
   public void startAllPlugins() {
       for (Plugin plugin : plugins) {
           plugin.start();
      }
   }
   //plugin会维护子任务，start()会停止子任务
   public void stopAllPlugins() {
       for (Plugin plugin : plugins) {
           plugin.stop();
       }
   }

   public void destroyAllPlugins() {
       for (Plugin plugin : plugins) {
           plugin.destroy();
       }
   }

   public static class Builder {
     /**
        * 省略构建方法：
        * Builder(构造函数)
        * plugin(添加插件)
        * pluginListener(插件状态监听)
        * matrixLifecycleConfig(默认配置)
        */
       //通过build创建Matrix实例
       public Matrix build() {
           if (pluginListener == null) {
               pluginListener = new DefaultPluginListener(application);
           }
           return new Matrix(application, pluginListener, plugins, mLifecycleConfig);
      }
  }

接着看插件的初始化方法plugin.init(application, listener)

public abstract class Plugin implements IPlugin, IssuePublisher.OnIssueDetectListener, IAppForeground {
   //维护了插件的5种状态
   public static final int PLUGIN_CREATE = 0x00;
   public static final int PLUGIN_INITED = 0x01;
   public static final int PLUGIN_STARTED = 0x02;
   public static final int PLUGIN_STOPPED = 0x04;
   public static final int PLUGIN_DESTROYED = 0x08; 
   //插件监听
   private PluginListener pluginListener;
   //当前状态
   private int status = PLUGIN_CREATE;
 
   @Override
   public void init(Application app, PluginListener listener) {
       //init时状态置为PLUGIN_INITED
       status = PLUGIN_INITED;
       this.application = app;
       this.pluginListener = listener;
       listener.onInit(this);
   }
 
   @Override
   public void onDetectIssue(Issue issue) {
      //提供了简单的统一的数据上报方法
      pluginListener.onReportIssue(issue);
   }
 
   @Override
   public void start() {
     status = PLUGIN_STARTED;
     pluginListener.onStart(this);
   }   
 
   @Override
   public void stop() {
       status = PLUGIN_STOPPED;
       pluginListener.onStop(this);
   }

   @Override
   public void destroy() {
       status = PLUGIN_DESTROYED;
       pluginListener.onDestroy(this);
   }
   //是否在前台
   public boolean isForeground() {
       return ProcessUILifecycleOwner.INSTANCE.isProcessForeground();
   }
}

Plugin是个抽象类，继承自IPlugin ， 是所有插件的父类（具体实现如TracePlugin），抽取插件公共的接口来约束插件的写法，实现不了不同功能插件的高度接耦。

感知插件的生命周期（5种状态：CREATE INITED STARTED STOPPED DESTROYED）和 APP前后台状态

接着看plugin.init具体实现，以TracePlugin为例：

public class TracePlugin extends Plugin {
 
   @Override
   public void init(Application app, PluginListener listener) {
       super.init(app, listener);
       //anr
       looperAnrTracer = new LooperAnrTracer(traceConfig);
       //fps
       frameTracer = new FrameTracer(traceConfig);
       //慢函数 插桩
       evilMethodTracer = new EvilMethodTracer(traceConfig);
       // 应用启动
       startupTracer = new StartupTracer(traceConfig);
   }
   //plugin.start()
   @Override
   public void start() {
       super.start();
       Runnable runnable = new Runnable() {
           @Override
           public void run() {
              //start根据配置开关开启追踪
              if (traceConfig.isStartupEnable()) {
                  //onStartTrace最终调到了自身的onAlive
                  startupTracer.onStartTrace();
              }
          }
        };
       //主线程执行。。
  }
   //plugin.stop()
   @Override
   public void stop() {
       super.stop();
       Runnable runnable = new Runnable() {
           @Override
           public void run() {
              //stop关闭追踪，最终调到了自身的onDead
              startupTracer.onCloseTrace();
           }
        };
       //主线程执行。。
   }
}

有anr、fps、慢函数、应用启动等一个个Tracer ，同样通过Tracer的抽取，实现了不同功能的解耦。

小结：

Matrix通过建造者模式构建，会遍历plugins并执行plugin.init，Plugin的子类(如TracePlugin/IOCanaryPlugin)会覆写init并初始化自己的子任务，每个Plugin都有start和stop，其中TracePlugin多抽了一层Trace来维护一组子任务，每个Trace抽取了生命周期onAlive和onDead。