DroidAssist执行流程分析。
1：首先整个插件的入口是DroidAssistPlugin.groovy下面的apply函数。在自定义插件的apply方法中，获取module对应的project的AppExtension，然后通过其registerTransform方法注册一个自定义的Transform。注册之后，在编译流程中会通过TaskManager-createPostCompilationTasks为这个自定义的Transform生成一个对应的Task，在.class文件转换成.dex文件的流程中会执行这个Task，对所有的.class文件（可包括第三方库的.class）进行转换，转换的逻辑定义在Transform的transform方法中。
class DroidAssistPlugin implements Plugin<Project> {
@Override
void apply(Project project) {
/*
扩展属性的配置，droidAssistOptions属性
* */
project.extensions.create("droidAssistOptions", DroidAssistExtension)
if (project.plugins.hasPlugin(AppPlugin.class)) { ////这句话判断是不是主程序,如果是主程序，获得所有的class文件
AppExtension extension = project.extensions.getByType(AppExtension)
/*
如果当前引用插件的项目为apply plugin: 'com.android.application'则配置的DroidAssistTransform的属性标记为true
* */
extension.registerTransform(
new DroidAssistTransform(project, true))
}
/*
同上，这个只是对类的处理
* */
if (project.plugins.hasPlugin(LibraryPlugin.class)) {
LibraryExtension extension = project.extensions.getByType(LibraryExtension)
extension.registerTransform(
new DroidAssistTransform(project, false))
}
}
}
2：下面我们来看一下transform函数，这个函数在DroidAssistTransform.groovy里面；在这个transform函数里面，最主要调用的是核心函数 onTransform，下面我们来看一下这个函数。
如果在配置里面你不开启这个插件的话，也就是droidAssistOptions里面的enabled=false，那么程序会原封不动的将输入文件拷贝到输出文件夹中，交给下一个Transform处理，其实Transform就是用Task装饰了一下，最终执行的还是任务。isIncremental这个变量判断的是否实现增量更新，不是的话直接删除所有输出文件，然后创建DroidAssistContext，这个类作用是将所有要操作的类放入类池中，当然是先加载规则文件剔除掉不需要操作的class，主要是通过configure()函数来实现，最后是创建DroidAssistExecutor类实现字节码的操作，主要是通过execute()函数实现，其他的代码都是和日志相关的；所以后面我们主要关注的函数就是configure() 和 execute()；
void onTransform(
Context gradleContext,
Collection<TransformInput> inputs,/////这里的输入包括jar输入和directoryinputs
Collection<TransformInput> referencedInputs,
TransformOutputProvider outputProvider,
boolean isIncremental)
throws IOException, TransformException, InterruptedException {
Logger.info("Transform start, " +
"enable:${gradleExtension.enable}, " +
"incremental:${isIncremental}")
// 这个属性为false的时候直接copy输入文件到输出位置，交给下一个Transform处理----这个属性的配置是用户在gradle.build直接配置droidassistoptions就可以了
if (!gradleExtension.enable) {
outputProvider.deleteAll()
def dirStream = inputs
.parallelStream()
.flatMap { it.directoryInputs.parallelStream() }
.filter { it.file.exists() }
def jarStream = inputs
.parallelStream()
.flatMap { it.jarInputs.parallelStream() }
.filter { it.file.exists() }
Stream.concat(dirStream, jarStream).forEach {
def copy = it.file.isFile() ? "copyFile" : "copyDirectory"
FileUtils."$copy"(
it.file,
GradleUtils.getTransformOutputLocation(outputProvider, it))
}
return
}
def start = System.currentTimeMillis()
Logger.info("DroidAssist options: ${gradleExtension}")
def timingLogger = new TimingLogger("Timing", "execute")
//不是增量更新每次删除旧的输出文件
if (!isIncremental) {
outputProvider.deleteAll()
timingLogger.addSplit("delete output")
}
//将需要操作的类都加入到流中
def context =
new DroidAssistContext(
gradleContext,
project,
gradleExtension,
referencedInputs)
context.configure()
timingLogger.addSplit("configure context")
///////创建字节码操作执行者
def executor =
new DroidAssistExecutor(
context,
outputProvider,
isIncremental)
timingLogger.addSplit("create executor")
//Execute all input classed with byte code operation transformers
executor.execute(inputs)
timingLogger.addSplit("execute inputs")
timingLogger.dumpToLog()
Logger.info("Transform end, " +
"input classes count:${executor.classCount}, " +
"affected classes:${executor.affectedCount}, " +
"time use:${System.currentTimeMillis() - start} ms")
}
}
2.1：我们先看一下configure的实现 ；首先是创建类池，在这个类池中会整合dirStream 和 jarstream. 然后我们通过loadConfiguration()这个函数加载.xml配置文件，然后在这个函数里面还通过DroidAssistConfiguration.groovy类对xml文件的解析，得到过滤机制，然后对类池的class进行过滤。下面我们具体介绍一下createClassPool() 和 loadConfiguration()函数。
def configure() {
try {
//创建类的操作池
createClassPool()
} catch (Throwable e) {
throw new DroidAssistException("Failed to create class pool", e)
}
//加载配置文件并过滤掉不需要修改的class
transformers = loadConfiguration()
2.1.1： 类池的创建createClassPool()
def createClassPool() {
classPool = new DroidAssistClassPool()
//将android代码放入
org.gradle.api.logging.Logger logger=project.logger;
classPool.appendBootClasspath(project.android.bootClasspath)
logger.quiet("path:"+project.android.bootClasspath);
//拿出class文件流
def dirStream = referencedInputs
.parallelStream()
.flatMap { it.directoryInputs.parallelStream() }
.filter { it.file.exists() }
//拿出jar文件下的流
def jarStream = referencedInputs
.parallelStream()
.flatMap { it.jarInputs.parallelStream() }
.filter { it.file.exists() }
//合并两个流，将他们全部放入操作池中
Stream.concat(dirStream, jarStream).forEach {
Logger.info("Append classpath: ${IOUtils.getPath(it.file)}")
classPool.appendClassPath(it.file)
2.1.2：loadConfiguration()函数，我们通过DroidAssistConfiguration的parse来解析xml文件，后面我们会看一下如何解析的。
def loadConfiguration() {
def transformers = extension.configFiles
.parallelStream()
.flatMap {
try {
//解析xml文件
def list = new DroidAssistConfiguration(project).parse(it)
return list.stream().peek {
transformer ->
//添加包括哪些类
transformer.classFilterSpec.addIncludes(extension.includes)
//添加不包裹哪些类
transformer.classFilterSpec.addExcludes(extension.excludes)
transformer.setClassPool(classPool)
transformer.setAbortOnUndefinedClass(extension.abortOnUndefinedClass)
//开始检测
transformer.check()
}
} catch (Throwable e) {
throw new DroidAssistException("Unable to load configuration," +
" unexpected exception occurs when parsing config file:$it, " +
"What went wrong:\n${e.message}", e)
}
}//parse each file
.collect(Collectors.toList())
Logger.info("Dump transformers:")
transformers.each {
Logger.info("transformer: $it")
}
return transformers
}
2.1.3：先用XmlParser将文件解析为Node，然后遍历节点，根据节点的值进行不同Transformer的创建，这些具体的结点的值都有哪些，文档里面说的很清楚了。照着来就行；进过这个函数之后就创建了很多种类型的的TransformerNodeHandler，这些不同的transform类都是在tarnsform文件夹下定义，根据的是策略模式的组织方式。之后就可以执行execute()方法了。
List<Transformer> parse(File file) {
Node configs = new XmlParser(true, true, true).parse(file)
configs.Global.Filter.Include.each { globalIncludes.add(it.text()) }
configs.Global.Filter.Exclude.each { globalExcludes.add(it.text()) }
//添加不同的处理策略
configs.Replace.MethodCall.each {
node ->
sourceTargetTransformerNodeHandler(METHOD, node) {
//代表第三个参数,最后一个参数的闭包可以这么写
return new MethodCallReplaceTransformer()
}
}
//添加不同的处理策略
configs.Replace.MethodExecution.each {
node ->
sourceTargetTransformerNodeHandler(METHOD, node) {
return new MethodExecutionReplaceTransformer()
}
}
configs.Replace.ConstructorCall.each {
node ->
sourceTargetTransformerNodeHandler(CONSTRUCTOR, node) {
return new ConstructorCallReplaceTransformer()
}
}
configs.Replace.ConstructorExecution.each {
node ->
sourceTargetTransformerNodeHandler(CONSTRUCTOR, node) {
return new ConstructorExecutionReplaceTransformer()
}
}
。。。。。。。。。
}
2.2 执行execute()方法，这个方法定义在DroidAssistExecutor.groovy里面。代码如下：
void execute(Collection<TransformInput> inputs) {
//合并两个类型class流
def dirStream = inputs.stream()
.flatMap { it.directoryInputs.stream() }
def jarStream = inputs.stream()
.flatMap { it.jarInputs.stream() }
Stream.concat(dirStream, jarStream)
.parallel()
//将流转化为task执行
.map { createTask(it) }/////其中createTask合并两种输入的class流
.filter { it != null }
.forEach { it.run() }////这个run方法会调用每一个子类的execute()方法
createTask创建了两种task，一种是JarInputTask，一种是DirInputTask，两个任务都有一个方法是execute()方法，因为JarInputTask和DirInputTask都是实现的是InputTask中的抽象方法。我们主要看一下execute方法的执行。
我们先看一下DirInputTask中的：
InputTask createTask(QualifiedContent content) {
//创建两个输入任务
def taskInput =
new InputTask.TaskInput(
input: content,
dest: GradleUtils.getTransformOutputLocation(outputProvider, content),
incremental: incremental)
if (content instanceof JarInput) {
return new JarInputTask(context, buildContext, taskInput)
}
if (content instanceof DirectoryInput) {
return new DirInputTask(context, buildContext, taskInput)
}
return null
判断如果是增量更新的话，判断哪些文件改变了，删除的删除，改变的将它全部copy到目的地然后放到files集合，过滤出class文件，执行executeClass方法改变字节码，最后将改变的字节码copy到输出目录覆盖原来的。所以executeClass方法是核心方法，主要完成字节码的转换。
void execute() {
DirectoryInput input = taskInput.input
def inputDir = input.file
def executor = new WorkerExecutor(1)
List<File> files = Lists.newArrayList()
/**
* 如果增量更新的话只改变增量更新
*/
if (taskInput.incremental) {
//process changedFiles in incremental mode.
//if file is removed, delete corresponding dest file.
//if file is changed or added, add file to pending collections.
input.changedFiles.each {
file, status ->
def destFile = getDestFileMapping(file, inputDir, taskInput.dest)
context.project.logger.quiet("taskInput.dest:" + taskInput.dest.getAbsolutePath());
context.project.logger.quiet("file:" + file.getAbsolutePath());
context.project.logger.quiet("inputDir:" + inputDir.getAbsolutePath());
context.project.logger.quiet("destFile:" + destFile.getAbsolutePath());
if (status == Status.REMOVED) {
if (destFile != null) {
FileUtils.deleteQuietly(destFile)
}
}
if (status == Status.CHANGED || status == Status.ADDED) {
//添加进files
files << file
if (destFile != null) {
executor.execute {
FileUtils.copyFile(file, destFile)
}
}
}
}
} else {
//process every class file in Non-incremental mode
executor.execute {
FileUtils.copyDirectory(inputDir, taskInput.dest)
}
def fileList = Files.walk(inputDir.toPath())
.parallel()
.map { it.toFile() }//Path to file
.filter { it.isFile() }
.filter { it.name.endsWith(DOT_CLASS) } //Filter class file
.collect(Collectors.toList())
files.addAll(fileList)
}
//过滤出class
files.stream()
.filter { it.isFile() }//Path to file
.filter { it.name.endsWith(DOT_CLASS) }//Filter class file
.forEach { executeClass(it, inputDir, temporaryDir) }
/**
* 操作完输入给输出覆盖掉原来的
*/
executor.execute {
FileUtils.copyDirectory(temporaryDir, taskInput.dest)
}
executor.finish()
}
2.3 派生类DirinputTask中也有一个executeClass方法，但是这只是对基类InoutTasks中的一个封装如下：
DirinputTask：
void executeClass(File classFile, File inputDir, File tempDir) {
def className =
FilenameUtils.
removeExtension(
inputDir.toPath()
.relativize(classFile.toPath())
.toString())
.replace(File.separator, '.') /////// 将/替换为.
executeClass(className, tempDir)////调用基类中的方法：
}
其中里面比较重要的一个函数是performTransform，这个函数是定义在所有transform类型的公共基类Transformer.groovy中。因为各种transformer的构建是按照策略模式安排的。我们首先看一下performTransform
boolean executeClass(String className, File directory) {
buildContext.totalCounter.incrementAndGet()
def inputClass = null
def transformers = context.transformers.findAll { /////得到之前建立的所有的transformer
it.classAllowed(className)
}
if (transformers.isEmpty()) {
return false
}
inputClass = context.classPool.getOrNull(className)////得到所有的待转换的类
if (inputClass == null) {
return false
}
transformers.each {
try {
it.performTransform(inputClass, className)///转换开始
} catch (NotFoundException e) {
throw new DroidAssistNotFoundException(
"Transform failed for class: ${className}" +
" with not found exception: ${e.cause?.message}", e)
} catch (CannotCompileException e) {
throw new DroidAssistBadStatementException(
"Transform failed for class: ${className} " +
"with compile error: ${e.cause?.message}", e)
} catch (Throwable e) {
throw new DroidAssistException(
"Transform failed for class: ${className} " +
"with error: ${e.cause?.message}", e)
}
}
if (inputClass.modified) {//类被修改的话则完成修改,将文件写入directory文件夹下
buildContext.affectedCounter.incrementAndGet()
inputClass.writeFile(directory.absolutePath)
return true
}
return false
}
}
2.4 这个方法让ctclass这个类可以重新操作然后执行beforeTransform和onTransform，最终字节码修改是在onTransform中实现。onTransform是在ExprExecTransformer.groovy中实现的。可以看出有两种类型，onTransformExpr 和 onTransformExec，
protected final boolean onTransform(
CtClass inputClass,
String inputClassName)
throws NotFoundException, CannotCompileException {
//expr
if (TRANSFORM_EXPR.equals(getTransformType())) {
return onTransformExpr(inputClass, inputClassName);
}
//exec
if (TRANSFORM_EXEC.equals(getTransformType())) {
return onTransformExec(inputClass, inputClassName);
}
return false;
}
我们看一下 onTransformExpr（），，我们可以看到editor中有三个函数重载，对应方法，属性，new操作三种处理方式。而在editor类中，edit方法总会调用各种transformer类型的execute（）方法，下面我们以MethodCallInsertTransformer.groovy中的execute()实现来看一下：
//检查class是否在include或者不在einclude
if (!filterClass(inputClass, inputClassName)) {
return false;
}
final AtomicBoolean modified = new AtomicBoolean(false);
Editor editor = new Editor() { /////有三种函数重载，对应三种不同的调用
///遇到方法调用会调用下面这个
@Override
public void edit(MethodCall call) throws CannotCompileException {
if (METHOD_CALL.equals(getExecuteType())) {
boolean disposed;
try {
disposed = execute(inputClass, inputClassName, call);
} catch (NotFoundException e) {
String msg = e.getMessage() + " for input class " + inputClassName;
throw new CannotCompileException(msg, e);
}
modified.set(modified.get() | disposed);
}
}
/////遇到属性声明会调用这个
@Override
public void edit(FieldAccess fieldAccess) throws CannotCompileException {
if (FIELD_ACCESS.equals(getExecuteType())) {
boolean disposed;
try {
disposed = execute(inputClass, inputClassName, fieldAccess);
} catch (NotFoundException e) {
String msg = e.getMessage() + " for input class " + inputClassName;
throw new CannotCompileException(msg, e);
}
modified.set(modified.get() | disposed);
}
}
///遇到new对象会走这个
@Override
public void edit(NewExpr newExpr) throws CannotCompileException {
if (NEW_EXPR.equals(getExecuteType())) {
boolean disposed;
try {
disposed = execute(inputClass, inputClassName, newExpr);
} catch (NotFoundException e) {
String msg = e.getMessage() + " for input class " + inputClassName;
throw new CannotCompileException(msg, e);
}
modified.set(modified.get() | disposed);
}
}
};
//得到默认构造方法函数，
CtConstructor initializer = tryGetClassInitializer(inputClass);
if (initializer != null) {
if (instrument(initializer, editor)) {
modified.set(true);
}
}
//得到类的所有方法
CtMethod[] declaredMethods = tryGetDeclaredMethods(inputClass);
for (CtMethod method : declaredMethods) {
if (instrument(method, editor)) {
modified.set(true);
}
}
//得到所有声明的构造方法
CtConstructor[] declaredConstructors = tryGetDeclaredConstructors(inputClass);
for (CtConstructor constructor : declaredConstructors) {
if (instrument(constructor, editor)) {
modified.set(true);
}
}
return modified.get();
2.5：这个方法主要也是做了三件事，检查这个methodCall的调用类是不是source中的类，是的话检测是在前插入代码还是后插入代码，后和前将原来代码放在中间替换原来的代码，这样就实现了代码的前或后插入。replaceInstrument（）函数将原来的替换成新的码
/如果是super的直接不予修改
if (methodCall.isSuper()) {
return false;
}
String insnClassName = methodCall.getClassName();
String insnName = methodCall.getMethodName();
String insnSignature = methodCall.getSignature();
//是否能找到这个方法的调用
CtClass insnClass = tryGetClass(insnClassName, inputClassName);
if (insnClass == null) {
return false;
}
//判断这个类是否是source处
if (!isMatchSourceMethod(insnClass, insnName, insnSignature)) {
return false;
}
String target = getTarget();
int line = methodCall.getLineNumber();
if (!target.endsWith(";")) target = target + ";";
String before = isAsBefore() ? target : "";
String after = isAsAfter() ? target : "";
String proceed = isVoidSourceReturnType() ? "$proceed($$);" : "$_ =$proceed($$);";
String statement = before + proceed + after;
//将原来代码替换为附加代码
String replacement = replaceInstrument(methodCall, statement);
if (isAsBefore()) {
Logger.warning(getPrettyName() + " insert before call by: " + replacement
+ " at " + inputClassName + ".java" + ":" + line);
}
if (isAsAfter()) {
Logger.warning(getPrettyName() + " insert after call by: " + replacement
+ " at " + inputClassName + ".java" + ":" + line);
}
return true;
