概述
- 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 的添加由 增量 进行界定，具体的处理标准如下：
最后
以上就是坚定外套为你收集整理的深入探索 Gradle 自动化构建技术（六、Gradle 插件平台化框架 ByteX 探秘之旅二、初识 ByteX三、ByteX 插件平台构建流程探秘的全部内容，希望文章能够帮你解决深入探索 Gradle 自动化构建技术（六、Gradle 插件平台化框架 ByteX 探秘之旅二、初识 ByteX三、ByteX 插件平台构建流程探秘所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复