• 3）、Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

3）、一个 Stream 操作实例

取出所有大于18岁人的姓名，按字典排序，并输出到控制台，代码如下所示：

private static List persons = Arrays.asList(
new Person(“CJK”,19,“女”),
new Person(“BODUO”,20,“女”),
new Person(“JZ”,21,“女”),
new Person(“anglebabby”,18,“女”),
new Person(“huangxiaoming”,5,“男”),
new Person(“ROY”,18,“男”)
);
public static void main(String[] args) throws IOException {
persons.stream().filter(x- >x.getAge()>=18).map(Person::getName).sorted().forEach(System.out::println);
}

4）、Stream 的操作三个步骤

• 1、创建 Stream：一个数据源（如：集合、数组），获取一个流。
• 2、中间操作：一个中间操作链，对数据源的数据进行处理。
• 3、终止操作(终端操作)：一个终止操作，执行中间操作链，并产生结果。

1、创建 Steam

创建流主要有四种方式，其示例代码如下所示：

@Test
public void test1(){
//1. Collection 提供了两个方法 stream() 与 parallelStream()
List list = new ArrayList<>();
Stream stream = list.stream(); //获取一个顺序流
Stream parallelStream = list.parallelStream(); //获取一个并行流

//2. 通过 Arrays 中的 stream() 获取一个数组流
Integer[] nums = new Integer[10];
Stream stream1 = Arrays.stream(nums);

//3. 通过 Stream 类中静态方法 of()
Stream stream2 = Stream.of(1,2,3,4,5,6);

//4. 创建无限流
//迭代
Stream stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
stream3.forEach(System.out::println);

//生成
Stream stream4 = Stream.generate(Math::random).limit(2);
stream4.forEach(System.out::println);
}

2、中间操作

• 1）、筛选与切片
• filter：接收 Lambda ，从流中排除某些元素。
• limit：截断流，使其元素不超过给定数量。
• skip(n)：跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补。
• distinct：筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素。
• 2）、映射
• map：接收 Lambda ，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素，类似于 python、go 的 map 语法。
• flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
• 3）、排序
• sorted()：自然排序。
• sorted(Comparator com)：定制排序。

这里，我们给出一些常见的使用示例，如下所示：

1、有个数组 Integer[] ary = {1,2,3,4,5,6,7,8,9,10}，取出中间的第三到第五个元素。

List collect = Arrays.stream(ary).skip(2).limit(3).collect(Collectors.toList());

2、有个数组 Integer[] ary = {1,2,2,3,4,5,6,6,7,8,8,9,10}，取出里面的偶数，并去除重复。

List list = Arrays.stream(ary).filter(x -> x % 2 == 0).distinct().collect(Collectors.toList());
Set integerSet = Arrays.stream(ary).filter(x -> x % 2 == 0).collect(Collectors.toSet());

3、有个二维数组，要求把数组组合成一个一维数组，并排序（1，2，3，4，5……12）

Integer[][] ary = {{3,8,4,7,5}, {9,1,6,2}, {0,10,12,11} };

Arrays.stream(ary).flatMap(item->Arrays.stream(item)).sorted().forEach(System.out::println);

3）、终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

1、查找与匹配

接口	说明
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	迭代

2、归约

reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional。例如使用 reduce 来求所有人员学生的总分的示例代码如下所示：

Integer all = persons.stream().map(Person::getScore).reduce((integer, integer2) -> integer + integer2).get()

3、收集

• collect(Collector c) 将流转换为其他形式。它接收一个 Collector 接口的实现，用于给 Stream 中元素做汇总的方法。
• Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。
• Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

收集相关的 Stream API 与其实例代码如下所示：

• 1）、toList List 把流中元素收集到 List：

List emps= list.stream().collect(Collectors.toList());

• 2）、toSet Set 把流中元素收集 到Set：

Set emps= list.stream().collect(Collectors.toSet());

• 3）、toCollection Collection 把流中元素收集到创建的集合：

Collection emps=list.stream().collect(Collectors.toCollection(ArrayList::new));

• 4）、counting Long 计算流中元素的个数：

long count = list.stream().collect(Collectors.counting());

• 5）、summing Int Integer 对流中元素的整数属性求和：

int total=list.stream().collect(Collectors.summingInt(Person::getAge));

• 6）、averaging Int Double 计算流中元素 Integer 属性的平均值：

double avg= list.stream().collect(Collectors.averagingInt(Person::getAge));

• 7）、summarizingInt IntSummaryStatistics 收集流中 Integer 属性的统计值。如平均值：

Int SummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Person::getAge));

• 8）、joining String 连接流中每个字符串：

String str= list.stream().map(Person::getName).collect(Collectors.joining());

• 9）、maxBy Optional 根据比较器选择最大值：

Optional max= list.stream().collect(Collectors.maxBy(comparingInt(Person::getSalary)));

• 10）、minBy Optional 根据比较器选择最小值：

Optional min = list.stream().collect(Collectors.minBy(comparingInt(Person::getSalary)));

• 11）、reducing 归约产生的类型，从一个作为累加器的初始值开始，利用 BinaryOperator 与流中元素逐个结合，从而归约成单个值：

int total=list.stream().collect(Collectors.reducing(0, Person::getSalary, Integer::sum));

• 12）、collectingAndThen 转换函数返回的类型，包裹另一个收集器，对其结果转换函数

int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));

• 13）、groupingBy Map<K, List> 根据某属性值对流分组，属性为 K，结果为 V：

Map<Person.Status, List> map= list.stream().collect(Collectors.groupingBy(Person::getStatus));

• 14）、partitioningBy Map<Boolean, List> 根 据true 或 false 进行分区：

Map<Boolean,List>vd= list.stream().collect(Collectors.partitioningBy(Person::getManage));

4、终止操作练习案例

• 1）、取出Person对象的所有名字，放到 List 集合中：

List collect2 = persons.stream().map(Person::getName).collect(Collectors.toList());

• 2、求 Person 对象集合的分数的平均分、总分、最高分，最低分，分数的个数：

IntSummaryStatistics collect = persons.stream().collect(Collectors.summarizingInt(Person::getScore));
System.out.println(collect);

• 3、根据成绩分组，及格的放一组，不及格的放另外一组：

Map<Boolean, List> collect1 = persons.stream().collect(Collectors.partitioningBy(person -> person.getScore() >= 60));
System.out.println(collect1);

• 4、统计 aa.txt 里面的单词数：

public static void main(String[] args) throws IOException {
InputStream resourceAsStream = Person.class.getClassLoader().getResourceAsStream(“aa.txt”);
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resourceAsStream));
bufferedReader.lines().flatMap(x->Stream.of(x.split(" “))).sorted().collect(Collectors.groupingBy(String::toString)).forEach((a,b)-> System.out.println(a+”:"+b.size()));
bufferedReader.close();
}

4、复杂泛型

1）、泛型是什么？

泛型，即 “参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

2）、泛型的好处

• 适用于多种数据类型执行相同的代码。
• 泛型中的类型在使用时指定，不需要强制类型转换。

3）、泛型类和泛型接口、泛型方法

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。而这种参数类型可以用在类、接口和方法中，分别被称为 泛型类、泛型接口、泛型方法。

泛型类

引入一个类型变量T（其他大写字母都可以，不过常用的就是T，E，K，V等等），并且用<>括起来，并放在类名的后面。泛型类是允许有多个类型变量的。常见的示例代码如下所示：

public class NormalGeneric {
private K data;

public NormalGeneric() {
}

public NormalGeneric(K data) {
this.data = data;
}

public K getData() {
return data;
}

public void setData(K data) {
this.data = data;
}
}

public class NormalGeneric2<T,K> {
private T data;
private K result;

public NormalGeneric2() {
}

public NormalGeneric2(T data) {
this();
this.data = data;
}

public NormalGeneric2(T data, K result) {
this.data = data;
this.result = result;
}

public T getData() {
return data;
}

public void setData(T data) {
this.data = data;
}

public K getResult() {
return result;
}

public void setResult(K result) {
this.result = result;
}
}

泛型接口

泛型接口与泛型类的定义基本相同。示例代码如下所示：

public interface Genertor {
public T next();
}

但是，实现泛型接口的类，有两种实现方法：

1、未传入泛型实参

在 new 出类的实例时，需要指定具体类型：

public class ImplGenertor implements Genertor {
@Override
public T next() {
return null;
}
}

2、传入泛型实参

在 new 出类的实例时，和普通的类没区别。

public class ImplGenertor2 implements Genertor {
@Override
public String next() {
return null;
}
}

泛型方法

泛型方法的 定义在 修饰符与返回值 的中间。示例代码如下所示：

public T genericMethod(T…a){
return a[a.length/2];
}

泛型方法，是在调用方法的时候指明泛型的具体类型，泛型方法可以在任何地方和任何场景中使用，包括普通类和泛型类。

泛型类中定义的普通方法和泛型方法的区别

在普通方法中：

// 虽然在方法中使用了泛型，但是这并不是一个泛型方法。
// 这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
// 所以在这个方法中才可以继续使用 T 这个泛型。
public T getKey(){
return key;
}

在泛型方法中：

/**

• 这才是一个真正的泛型方法。
• 首先在 public 与返回值之间的 必不可少，这表明这是一个泛型方法，并且声明了一个泛型 T
• 这个 T 可以出现在这个泛型方法的任意位置，泛型的数量也可以为任意多个。
  */
  public <T,K> K showKeyName(Generic container){
  // …
  }

4）、限定类型变量

public class ClassBorder {
…
}

public class GenericRaw<T extends ArrayList&Comparable> {
…
}

- <T extends Comparable>：T 表示应该绑定类型的子类型，Comparable 表示绑定类型，子类型和绑定类型可以是类也可以是接口。

• extends 左右都允许有多个，如 T,V extends Comparable&Serializable。
• 注意限定类型中，只允许有一个类，而且如果有类，这个类必须是限定列表的第一个。
• 限定类型变量既可以用在泛型方法上也可以用在泛型类上。

5）、泛型中的约束和局限性

• 1、不能用基本类型实例化类型参数。
• 2、运行时类型查询只适用于原始类型。
• 3、泛型类的静态上下文中类型变量失效：不能在静态域或方法中引用类型变量。因为泛型是要在对象创建的时候才知道是什么类型的，而对象创建的代码执行先后顺序是 static 的部分，然后才是构造函数等等。所以在对象初始化之前 static 的部分已经执行了，如果你在静态部分引用泛型，那么毫无疑问虚拟机根本不知道是什么东西，因为这个时候类还没有初始化。
• 4、不能创建参数化类型的数组，但是可以定义参数化类型的数组。
• 5、不能实例化类型变量。
• 6、不能使用 try-catch 捕获泛型类的实例。

6）、泛型类型的继承规则

泛型类可以继承或者扩展其他泛型类，比如 List 和 ArrayList：

private static class ExtendPair extends Pair{
…
}

7）、通配符类型

• ？extends X：表示类型的上界，类型参数是 X 的子类。
• ？super X：表示类型的下界，类型参数是 X 的超类。

？extends X

如果其中提供了 get 和 set 类型参数变量的方法的话，set 方法是不允许被调用的，会出现编译错误，而 get 方法则没问题。

？extends X 表示类型的上界，类型参数是 X 的子类，那么可以肯定的说，get 方法返回的一定是个 X（不管是 X 或者 X 的子类）编译器是可以确定知道的。但是 set 方法只知道传入的是个 X，至于具体是 X 的哪个子类，是不知道的。

因此，？extends X 主要用于安全地访问数据，可以访问 X 及其子类型，并且不能写入非 null 的数据。

？super X

如果其中提供了 get 和 set 类型参数变量的方法的话，set 方法可以被调用，且能传入的参数只能是 X 或者 X 的子类。而 get 方法只会返回一个 Object 类型的值。

？ super X 表示类型的下界，类型参数是 X 的超类（包括 X 本身），那么可以肯定的说，get 方法返回的一定是个 X 的超类，那么到底是哪个超类？不知道，但是可以肯定的说，Object 一定是它的超类，所以 get 方法返回 Object。编译器是可以确定知道的。对于 set 方法来说，编译器不知道它需要的确切类型，但是 X 和 X 的子类可以安全的转型为 X。

因此，？super X 主要用于安全地写入数据，可以写入 X 及其子类型。

无限定的通配符 ?

表示对类型没有什么限制，可以把 ？看成所有类型的父类，如 ArrayList<?>。

8）、虚拟机是如何实现泛型的？

泛型思想早在 C++ 语言的模板（Template）中就开始生根发芽，在 Java 语言处于还没有出现泛型的版本时，只能通过 Object 是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。

由于 Java 语言里面所有的类型都继承于 java.lang.Object，所以 Object 转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个 Object 到底是个什么类型的对象。在编译期间，编译器无法检查这个 Object 的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多 ClassCastException 的风险就会转嫁到程序运行期之中。

此外，泛型技术在 C#/C++ 和 Java 之中的使用方式看似相同，但实现上却有着根本性的分歧，C# 里面的泛型无论在程序源码中、编译后的 IL 中（Intermediate Language，中间语言，这时候泛型是一个占位符），或是运行期的 CLR 中，都是切实存在的，List＜int＞ 与 List＜String＞ 就是两个不同的类型，它们在系统运行期生成，有自己的虚方法表和类型数据，这种实现称为类型膨胀，基于这种方法实现的泛型称为真实泛型。

而 Java 语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的 Java 语言来说，ArrayList＜int＞ 与 ArrayList＜String＞ 就是同一个类，所以 泛型技术实际上是 Java 语言的一颗语法糖，Java 语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。 将一段 Java 代码编译成 Class 文件，然后再用字节码反编译工具进行反编译后，将会发现泛型都不见了，程序又变回了 Java 泛型出现之前的写法，泛型类型都变回了原生类型。

由于 Java 泛型的引入，各种场景（虚拟机解析、反射等）下的方法调用都可能对原有的基础产生影响和新的需求，如在泛型类中如何获取传入的参数化类型等。因此，JCP 组织对虚拟机规范做出了相应的修改，引入了诸如 Signature、LocalVariableTypeTable 等新的属性用于解决伴随泛型而来的参数类型的识别问题，Signature 是其中最重要的一项属性，它的作用就是存储一个方法在字节码层面的特征签名，这个属性中保存的参数类型并不是原生类型，而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别 49.0 以上版本的 Class 文件的虚拟机都要能正确地识别 Signature 参数。

最后，从 Signature 属性的出现我们还可以得出结论，擦除法所谓的擦除，仅仅是对方法的 Code 属性中的字节码进行擦除，实际上元数据中还是保留了泛型信息，这也是我们能通过反射手段取得参数化类型的根本依据。

二、初识 ByteX

ByteX 使用了纯 Java 来编写源码，它是一个基于 Gradle transform api 和 ASM 的字节码插桩平台。

调试:gradle clean :example:assembleRelease -Dorg.gradle.debug=true --no-daemon

1、优势

• 1）、自动集成到其它宿主和插件一起整合为一个单独的 MainTransformFlow，结合 class 文件多线程并发处理，避免了打包的额外时间呈线性增长。
• 2）、插件、宿主之间完全解耦，便于协同开发。
• 3）、common module 提供通用的代码复用，每个插件只需专注自身的字节码插桩逻辑。

2、MainTransformFlow 基本流程

在 MainTransformFlow implements MainProcessHandler 常规处理过程，会遍历两次工程构建中的所有 class。

• 1）、第一次，遍历 traverse 与 traverseAndroidJar 过程，以形成完整的类图。
• 2）、第二次，执行 transform：再遍历一次工程中所有的构建产物，并对 class 文件做处理后输出。

3、如何自定义独立的 TransformFlow？

重写 IPlugin 的 provideTransformFlow 即可。

4、类图对象

context.getClassGraph() 获取类图对象，两个 TransformFlow 的类图是隔离的。

5、MainProcessHandler

• 通过复写 process 方法，注册自己的 FlieProcessor 来处理。
• FileProcessor 采用了责任链模式，每个 class 文件都会流经一系列的 FileProcessor 来处理。

6、IPlugin.hookTransformName()

使用 反射 Hook 方式 将 Transform 注册到 proguard 之后。

三、ByteX 插件平台构建流程探秘

添加 apply plugin: ‘bytex’ 之后，bytex 可以在 Gradle 的构建流程中起作用了。这里的插件 id 为 bytex，我们找到 bytex.properties 文件，查看里面映射的实现类，如下所示：

implementation-class=com.ss.android.ugc.bytex.base.ByteXPlugin

可以看到，bytex 的实现类为 ByteXPlugin，其源码如下所示：

public class ByteXPlugin implements Plugin {
@Override
public void apply(@NotNull Project project) {
// 1
AppExtension android = project.getExtensions().getByType(AppExtension.class);
// 2
ByteXExtension extension = project.getExtensions().create(“ByteX”, ByteXExtension.class);
// 3
android.registerTransform(new ByteXTransform(new Context(project, android, extension)));
}
}

首先，注释1处，获取 Android 为 App 提供的扩展属性 AppExtension 实例。然后，在注释2处，获取 ByteX 自身创建的扩展属性 ByteXExtension 实例。最后，在注释3处，注册 ByteXTransform 实例。ByteXTransform 继承了抽象类 CommonTransform，其实现了关键的 transform 方法，其实现源码如下所示：

@Override
public final void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
super.transform(transformInvocation);
// 1、如果不是增量模式，则清楚输出目录的文件。
if (!transformInvocation.isIncremental()) {
transformInvocation.getOutputProvider().deleteAll();
}
// 2、获取 transformContext 实例。
TransformContext transformContext = getTransformContext(transformInvocation);
// 3、初始化 HtmlReporter（生成 ByteX 构建产生日志的 HTML 文件）
init(transformContext);
// 4、过滤掉没有打开插件开关的 plugin。
List plugins = getPlugins().stream().filter(p -> p.enable(transformContext)).collect(Collectors.toList());
Timer timer = new Timer();
// 5、创建一个 transformEngine 实例。
TransformEngine transformEngine = new TransformEngine(transformContext);
try {
if (!plugins.isEmpty()) {
// 6、使用 PriorityQueue 对每一个 TransformFlow 进行优先级排序（在这里添加的是与之对应的实现类 MainTransformFlow）。
Queue flowSet = new PriorityQueue<>((o1, o2) -> o2.getPriority() - o1.getPriority());
MainTransformFlow commonFlow = new MainTransformFlow(transformEngine);
flowSet.add(commonFlow);
for (int i = 0; i < plugins.size(); i++) {
// 7、给每一个 Plugin 注册 MainTransformFlow，其实质是将每一个 Plugin 的 MainProcessHandler 添加到 MainTransformFlow 中的 handlers 列表中。
IPlugin plugin = plugins.get(i);
TransformFlow flow = plugin.registerTransformFlow(commonFlow, transformContext);
if (!flowSet.contains(flow)) {
flowSet.add(flow);
}
}
while (!flowSet.isEmpty()) {
TransformFlow flow = flowSet.poll();
if (flow != null) {
if (flowSet.size() == 0) {
flow.asTail();
}
// 8、按指定优先级执行每一个 TransformFlow 的 run 方法，默认只有一个 MainTransformFlow 实例。
flow.run();
// 9、获取流中的 graph 类图对象并清除。
Graph graph = flow.getClassGraph();
if (graph != null) {
//clear the class diagram.we won’t use it anymore
graph.clear();
}
}
}
} else {
transformEngine.skip();
}
// 10
afterTransform(transformInvocation);
} catch (Throwable throwable) {
LevelLog.sDefaultLogger.e(throwable.getClass().getName(), throwable);
throw throwable;
} finally {
for (IPlugin plugin : plugins) {
try {
plugin.afterExecute();
} catch (Throwable throwable) {
LevelLog.sDefaultLogger.e(“do afterExecute”, throwable);
}
}
transformContext.release();
release();
timer.record(“Total cost time = [%s ms]”);
if (BooleanProperty.ENABLE_HTML_LOG.value()) {
HtmlReporter.getInstance().createHtmlReporter(getName());
HtmlReporter.getInstance().reset();
}
}
}

在注释7处，调用了 plugin.registerTransformFlow 方法，其源码如下所示：

@Nonnull
@Override
public final TransformFlow registerTransformFlow(@Nonnull MainTransformFlow mainFlow, @Nonnull TransformContext transformContext) {
if (transformFlow == null) {
transformFlow = provideTransformFlow(mainFlow, transformContext);
if (transformFlow == null) {
throw new RuntimeException(“TransformFlow can not be null.”);
}
}
return transformFlow;
}

这里继续调用了 provideTransformFlow 方法，其源码如下所示：

/**

• create a new transformFlow or just return mainFlow and append a handler.
• It will be called by {@link IPlugin#registerTransformFlow(MainTransformFlow, TransformContext)} when
• handle start.
• @param mainFlow main TransformFlow
• @param transformContext handle context
• @return return a new TransformFlow object if you want make a new flow for current plugin
  */
  protected TransformFlow provideTransformFlow(@Nonnull MainTransformFlow mainFlow, @Nonnull TransformContext transformContext) {
  return mainFlow.appendHandler(this);
  }

可以看到，通过调用 mainFlow.appendHandler(this) 方法将每一个 Plugin 的 MainProcessHandler 添加到 MainTransformFlow 中的 handlers 列表之中。

在注释8处，按指定优先级执行了每一个 TransformFlow 的 run 方法，默认只有一个 MainTransformFlow 实例。我们看到了 MianTransformFlow 的 run 方法：

@Override
public void run() throws IOException, InterruptedException {
try {
// 1
beginRun();
// 2
runTransform();
} finally {
// 3
endRun();
}
}

首先，在注释1出，调用了 beginRun 方法，其实现如下：

// AbsTransformFlow
protected void beginRun() {
transformEngine.beginRun();
}

// TransformEngine
public void beginRun(){
context.markRunningState(false);
}

// TransformContext
private final AtomicBoolean running = new AtomicBoolean(false);

void markRunningState(boolean running) {
this.running.set(running);
}

最后，在 TransformContext 实例中使用了一个 AtomicBoolean 实例标记 MainTransformFlow 是否正在运行中。

然后，在注释2处执行了 runTransform 方法，这里就是真正执行 transform 的地方，其源码如下所示：

private void runTransform() throws IOException, InterruptedException {
if (handlers.
isEmpty()) return;
Timer timer = new Timer();
timer.startRecord(“PRE_PROCESS”);
timer.startRecord(“INIT”);
// 1、初始化 handlers 列表中的每一个 handler。
for (MainProcessHandler handler : handlers) {
handler.init(transformEngine);
}
timer.stopRecord(“INIT”, “Process init cost time = [%s ms]”);
// 如果不是 跳过 traverse 仅仅只执行 Transform 方法时，才执行 traverse 过程。
if (!isOnePassEnough()) {
if (!handlers.isEmpty() && context.isIncremental()) {
timer.startRecord(“TRAVERSE_INCREMENTAL”);
// 2、如果是 增量模式，则执行 traverseArtifactOnly（仅仅增量遍历产物）调用每一个 plugin 的对应的 MainProcessHandler 的 traverseIncremental 方法。这里最终会调用 ClassFileAnalyzer.handle 方法进行遍历分发操作。
traverseArtifactOnly(getProcessors(Process.TRAVERSE_INCREMENTAL, new ClassFileAnalyzer(context, Process.TRAVERSE_INCREMENTAL, null, handlers)));
timer.stopRecord(“TRAVERSE_INCREMENTAL”, “Process project all .class files cost time = [%s ms]”);
}
handlers.forEach(plugin -> plugin.beforeTraverse(transformEngine));
timer.startRecord(“LOADCACHE”);
// 3、创建一个 CachedGraphBuilder 对象：能够缓存 类图 的 类图构建者对象。
GraphBuilder graphBuilder = new CachedGraphBuilder(context.getGraphCache(), context.isIncremental(), context.shouldSaveCache());
if (context.isIncremental() && !graphBuilder.isCacheValid()) {
// 4、如果是增量更新 && graphBuilder 的缓存失效则直接请求非增量运行。
context.requestNotIncremental();
}
timer.stopRecord(“LOADCACHE”, “Process loading cache cost time = [%s ms]”);
// 5、内部会调用 running.set(true) 来标记正在运行的状态。
running();
if (!handlers.isEmpty()) {
timer.startRecord(“PROJECT_CLASS”);
// 6、执行 traverseArtifactOnly（遍历产物）调用每一个 plugin 的对应的 MainProcessHandler 的 traverse 方法，这里最终会调用 ClassFileAnalyzer.handle 方法进行遍历分发操作。
traverseArtifactOnly(getProcessors(Process.TRAVERSE, new ClassFileAnalyzer(context, Process.TRAVERSE, graphBuilder, handlers)));
timer.stopRecord(“PROJECT_CLASS”, “Process project all .class files cost time = [%s ms]”);
}
if (!handlers.isEmpty()) {
timer.startRecord(“ANDROID”);
// 7、仅仅遍历 Android.jar
traverseAndroidJarOnly(getProcessors(Process.TRAVERSE_ANDROID, new ClassFileAnalyzer(context, Process.TRAVERSE_ANDROID, graphBuilder, handlers)));
timer.stopRecord(“ANDROID”, “Process android jar cost time = [%s ms]”);
}
timer.startRecord(“SAVECACHE”);
// 8、构建 mClassGraph 类图实例。
mClassGraph = graphBuilder.build();
timer.stopRecord(“SAVECACHE”, “Process saving cache cost time = [%s ms]”);
}
timer.stopRecord(“PRE_PROCESS”, “Collect info cost time = [%s ms]”);
if (!handlers.isEmpty()) {
timer.startRecord(“PROCESS”);
// 9、遍历执行每一个 plugin 的 transform 方法。
transform(getProcessors(Process.TRANSFORM, new ClassFileTransformer(handlers, needPreVerify(), needVerify())));
timer.stopRecord(“PROCESS”, “Transform cost time = [%s ms]”);
}
}

首先，在注释1处，遍历调用了每一个 MainProcessHandler 的 init 方法，它是用于 transform 开始前的初始化实现方法。

MainProcessHandler 接口的 init 方法是一个 default 方法，里面直接调用了每一个 pluign 实现的 init 方法（如果 plugin 没有实现，则仅仅调用 CommonPlugin 实现的 init 方法：这里通常是用于把不需要处理的文件添加到 mWhiteList 列表），这里可以做一些 plugin 的准备工作。

1、仅仅遍历产物

traverseArtifactOnly(getProcessors(Process.TRAVERSE, new ClassFileAnalyzer(context, Process.TRAVERSE, graphBuilder, handlers)));

getProcessors 方法的源码如下所示：

private FileProcessor[] getProcessors(Process process, FileHandler fileHandler) {
List processors = handlers.stream()
.flatMap((Function<MainProcessHandler, Stream>) handler -> handler.process(process).stream())
.collect(Collectors.toList());
switch (process) {
case TRAVERSE_INCREMENTAL:
processors.add(0, new FilterFileProcessor(fileData -> fileData.getStatus() != Status.NOTCHANGED));
processors.add(new IncrementalFileProcessor(handlers, ClassFileProcessor.newInstance(fileHandler)));
break;
case TRAVERSE:
case TRAVERSE_ANDROID:
case TRANSFORM:
processors.add(ClassFileProcessor.newInstance(fileHandler));
processors.add(0, new FilterFileProcessor(fileData -> fileData.getStatus() != Status.NOTCHANGED && fileData.getStatus() != Status.REMOVED))
break;
default:
throw new RuntimeException(“Unknow Process:” + process);
}
return processors.toArray(new FileProcessor[0]);
}

这里的 processor 的添加由 增量 进行界定，具体的处理标准如下：

eProcessor>>) handler -> handler.process(process).stream())
.collect(Collectors.toList());
switch (process) {
case TRAVERSE_INCREMENTAL:
processors.add(0, new FilterFileProcessor(fileData -> fileData.getStatus() != Status.NOTCHANGED));
processors.add(new IncrementalFileProcessor(handlers, ClassFileProcessor.newInstance(fileHandler)));
break;
case TRAVERSE:
case TRAVERSE_ANDROID:
case TRANSFORM:
processors.add(ClassFileProcessor.newInstance(fileHandler));
processors.add(0, new FilterFileProcessor(fileData -> fileData.getStatus() != Status.NOTCHANGED && fileData.getStatus() != Status.REMOVED))
break;
default:
throw new RuntimeException(“Unknow Process:” + process);
}
return processors.toArray(new FileProcessor[0]);
}

这里的 processor 的添加由 增量 进行界定，具体的处理标准如下：