您的位置：首页 > 其它

通过自定义Gradle插件修改编译后的class文件

2016-07-04 18:37 483 查看
我的简书同步发布:通过自定义Gradle插件修改编译后的class文件

转载请注明出处：【huachao1001的专栏：http://blog.csdn.net/huachao1001】

或许你会觉得没有必要这样做，可是有一种应用场景就是，为每个编译后的class文件添加一行代码。比如：在每个Java类的构造函数中加一句
System.out.println("I Love HuaChao!");
（PS:莫吐槽~，莫嘲笑~），如果你每次创建一个类的时候都手动加这么一句话，先不谈容易出错，我们说说工作量。或许你觉得，你愿意手动加，那我再跟你提新需求，我现在不要这句代码了，我要的是
System.out.println("I Love MaYun!");
你给我改去吧~，这时候你会不会想骂人~。忍住！我们上一篇《在AndroidStudio中自定义Gradle插件》 不是学过自定义Gradle插件了吗？我们为什么要手动写呢？直接通过Gradle插件来帮我们干！

1 认识Project对象

还记得上一篇文章中，我们自定义的插件类是通过实现
Plugin
接口，并将
org.gradle.api.Project
作为模板参数吗？
org.gradle.api.Project
的实例对象将作为参数传给
void apply(Project project)
函数。接下来我看看
Project
类。

根据Gradle官网的介绍，
Project
是你与Gradle交互的主接口，通过
Project
你可以通过代码使用所有的Gradle特性，
Project
与
build.gradle
是一对一的关系。简单来说，你想要通过代码使用
Gradle
，通过
Project
这个入口，就可以啦~

我们先看一个简单的通过
Project
访问的使用场景：
Extension
。可能你对
Extension
不熟悉，但是，我给你看一个你熟悉的内容：

android {
compileSdkVersion 24
buildToolsVersion "24.0.0"

defaultConfig {
applicationId "com.hc.hcplugin"
minSdkVersion 15
targetSdkVersion 24
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}


上面的这些你是不是很熟悉呢？你有没有想过，上面的
android{}
、
compileSdkVersion
、
defaultConfig {}
等等这些设置是如何被
Android
的
Gradle
插件读取的呢？想必你已经想到了，没错，就是通过
Extension
。下面我们自定义一个
Extension
，感受一下~。首先，定义两个Groovy类：
Address
和
HCExtension
.注意：为了避免引入插件问题，以下代码全部放入
buildsrc
模块的
build.gradle
文件中:

class Address{
String province=null
String city=null
}
class HCExtension{
String myName = null;

}


再新建一个
Plugin
(同样也放入
build.gradle
中)：

class TestExtensionPlugin implements Plugin<Project> {

@Override
void apply(Project project) {

project.extensions.create('hc', HCExtension);
project.extensions.create('address', Address);

project.task('readExtension') << {
def address=project['address']

println project['hc'].myName
println address.province+" "+address.city

}
}
}


接下来就是把你的配置放进去啦(同样也放入
build.gradle
中)：

apply plugin: TestExtensionPlugin

hc {
address{
province "HuBei"
city "WuHan"
}

myName "huachao"

}


稍微解释一下，
apply plugin: TestExtensionPlugin
这一行会导致直接执行
TestExtensionPlugin
类的
apply
方法。所以，
hc{}
这个块必须放在
apply plugin: TestExtensionPlugin
之后，因为在没有执行
project.extensions.create('hc', HCExtension);
之前，使用
hc{}
会报错！
address{}
也是同理。另外，补充一下：
project.extensions
相当于
project.getExtensions()
即返回的是
ExtensionContainer
对象，而
ExtensionContainer
对象的create方法就是把
hc{}
与
HCExtension
对应起来。其他通过
project.
的方式也是同样的道理。再看看
project.task('readExtension')
，这是创建一个
task
。相当于在
build.gradle
文件中的
task xxx <<{}
只不过这里是通过代码的方式动态创建.

此时你的buildsrc模块中的build.gradle文件应该如下：

apply plugin: 'groovy'

dependencies {
compile gradleApi()//gradle sdk
compile localGroovy()//groovy sdk
compile 'com.android.tools.build:gradle:2.1.0'
}

repositories {
jcenter()
}
class Address{
String province=null
String city=null
}
class HCExtension{
String myName = null;

}
class TestExtensionPlugin implements Plugin<Project> {

@Override
void apply(Project project) {

project.extensions.create('hc', HCExtension);
project.extensions.create('address', Address);

project.task('readExtension') << {
def address=project['address']

println project['hc'].myName
println address.province+" "+address.city

}
}
}

apply plugin: TestExtensionPlugin

hc {
address{
province "HuBei"
city "WuHan"
}

myName "huachao"

}


点击
buildsrc
模块中的
readExtension
如下图：



看看打印信息

···
:buildsrc:readExtension
huachao
HuBei WuHan

···


关于Project对象先介绍到这里，更多内容请查看官方网站：https://docs.gradle.org/current/javadoc/org/gradle/api/Project.html

2 修改编译后的class

接下来回到我们的主题，我们需要修改
class
文件，首先我们得知道什么时候编译完成，并且我们要赶在
class
文件被转化为
dex
文件之前去修改。从
1.5.0-beta1
开始，
android
的
gradle
插件引入了
com.android.build.api.transform.Transform
，可以点击 http://tools.android.com/tech-docs/new-build-system/transform-api 查看相关内容。
Transform
每次都是将一个输入进行处理，然后将处理结果输出，而输出的结果将会作为另一个
Transform
的输入，过程如下：



注意，输出地址不是由你任意指定的。而是根据输入的内容、作用范围等由
TransformOutputProvider
生成，比如，你要获取输出路径：

String dest = outputProvider.getContentLocation(directoryInput.name,
directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)


Transform
是一个抽象类，我们先自定义一个
Transform
，如下：

package com.hc.plugin

import com.android.build.api.transform.*
import com.android.build.gradle.internal.pipeline.TransformManager
import org.apache.commons.codec.digest.DigestUtils
import org.apache.commons.io.FileUtils
import org.gradle.api.Project

/**
* Created by HuaChao on 2016/7/4.
*/
public class MyTransform extends Transform {

Project project

// 构造函数，我们将Project保存下来备用
public MyTransform(Project project) {
this.project = project
}

// 设置我们自定义的Transform对应的Task名称
// 类似：TransformClassesWithPreDexForXXX
@Override
String getName() {
return "MyTrans"
}

// 指定输入的类型，通过这里的设定，可以指定我们要处理的文件类型
//这样确保其他类型的文件不会传入
@Override
Set<QualifiedContent.ContentType> getInputTypes() {
return TransformManager.CONTENT_CLASS
}

// 指定Transform的作用范围
@Override
Set<QualifiedContent.Scope> getScopes() {
return TransformManager.SCOPE_FULL_PROJECT
}

@Override
boolean isIncremental() {
return false
}

//具体的处理
@Override
void transform(Context context, Collection<TransformInput> inputs,
Collection<TransformInput> referencedInputs,
TransformOutputProvider outputProvider, boolean isIncremental)
throws IOException, TransformException, InterruptedException {

}
}


看到函数
transform
,我们还没有具体实现这个函数。这个函数就是具体如何处理输入和输出。可以运行一下看看，注意，这里的运行时直接编译执行我们的apk，而不是像之前那样直接rebuild，因为rebuild并没有执行到编译这一步。由于我们没有实现transform这个函数，导致没有输出！使得整个过程中断了！最终导致apk运行时找不到MainActivity，所以会报错。接下来我们去实现以下这个函数，我们啥也不干，就是把输入内容写入到作为输出内容，不做任何处理，（下面代码参考自这里）：

@Override
void transform(Context context, Collection<TransformInput> inputs,
Collection<TransformInput> referencedInputs,
TransformOutputProvider outputProvider, boolean isIncremental)
throws IOException, TransformException, InterruptedException {
// Transform的inputs有两种类型，一种是目录，一种是jar包，要分开遍历
inputs.each {TransformInput input ->
//对类型为“文件夹”的input进行遍历
input.directoryInputs.each {DirectoryInput directoryInput->
//文件夹里面包含的是我们手写的类以及R.class、BuildConfig.class以及R$XXX.class等

// 获取output目录
def dest = outputProvider.getContentLocation(directoryInput.name,
directoryInput.contentTypes, directoryInput.scopes,
Format.DIRECTORY)

// 将input的目录复制到output指定目录
FileUtils.copyDirectory(directoryInput.file, dest)
}
//对类型为jar文件的input进行遍历
input.jarInputs.each {JarInput jarInput->

//jar文件一般是第三方依赖库jar文件

// 重命名输出文件（同目录copyFile会冲突）
def jarName = jarInput.name
def md5Name = DigestUtils.md5Hex(jarInput.file.getAbsolutePath())
if(jarName.endsWith(".jar")) {
jarName = jarName.substring(0,jarName.length()-4)
}
//生成输出路径
def dest = outputProvider.getContentLocation(jarName+md5Name,
jarInput.contentTypes, jarInput.scopes, Format.JAR)
//将输入内容复制到输出
FileUtils.copyFile(jarInput.file, dest)
}
}
}


注意input的类型，分为”文件夹”和“jar文件”，”文件夹”里面的就是我们写的类对应的class文件，jar文件一般为第三方库。此时，能成功运行，但是我们还没有注入代码呢~，下面我们看看如何注入代码~

3 Javassist

要修改
class
字节码，我们要是自己手动改二进制文件，有点困难，好在有
Javassist
这个库，可以让我们直接修改编译后的
class
二进制代码。关于Javassist的使用，这里不介绍，可以自行搜索。要使用到
Javassist
，我们得在
buildsrc
模块下的
build.gradle
添加依赖包：

compile 'org.javassist:javassist:3.20.0-GA'


使用Javassist也很简单，首先拿到
ClassPool
对象，通过
ClassPool
获取已经编译好的类，如：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("com.hc.MyClass");
cc.setSuperclass(pool.get("com.hc.ParentClass"));
cc.writeFile();


上面代码就实现了修改
MyClass
类的父类为
ParentClass
.

要获取字节码以及加载为Class对象，如下：

byte[] b = cc.toBytecode();
Class clazz = cc.toClass();


前面提到，我们自己创建的Java类编译后是放入到文件夹里面的，因此，我们只需针对这个文件夹里面的class文件进行修改即可，新建一个Groovy类：

package com.hc.plugin

import javassist.ClassPool
import javassist.CtClass
import javassist.CtConstructor
public class MyInject {

private static ClassPool pool = ClassPool.getDefault()
private static String injectStr = "System.out.println(\"I Love HuaChao\" ); ";

public static void injectDir(String path, String packageName) {
pool.appendClassPath(path)
File dir = new File(path)
if (dir.isDirectory()) {
dir.eachFileRecurse { File file ->

String filePath = file.absolutePath
//确保当前文件是class文件，并且不是系统自动生成的class文件
if (filePath.endsWith(".class")
&& !filePath.contains('R$')
&& !filePath.contains('R.class')
&& !filePath.contains("BuildConfig.class")) {
// 判断当前目录是否是在我们的应用包里面
int index = filePath.indexOf(packageName);
boolean isMyPackage = index != -1;
if (isMyPackage) {
int end = filePath.length() - 6 // .class = 6
String className = filePath.substring(index, end)
.replace('\\', '.').replace('/', '.')
//开始修改class文件
CtClass c = pool.getCtClass(className)

if (c.isFrozen()) {
c.defrost()
}

CtConstructor[] cts = c.getDeclaredConstructors()
if (cts == null || cts.length == 0) {
//手动创建一个构造函数
CtConstructor constructor = new CtConstructor(new CtClass[0], c)
constructor.insertBeforeBody(injectStr)
c.addConstructor(constructor)
} else {
cts[0].insertBeforeBody(injectStr)
}
c.writeFile(path)
c.detach()
}
}
}
}
}

}


然后就是在 transform函数中，针对“文件夹”里面的class进行注入，而jar文件类型的input依然不做处理。transform函数如下：

@Override
void transform(Context context, Collection<TransformInput> inputs,
Collection<TransformInput> referencedInputs,
TransformOutputProvider outputProvider, boolean isIncremental)
throws IOException, TransformException, InterruptedException {
// Transform的inputs有两种类型，一种是目录，一种是jar包，要分开遍历
inputs.each { TransformInput input ->
//对类型为“文件夹”的input进行遍历
input.directoryInputs.each { DirectoryInput directoryInput ->
//文件夹里面包含的是我们手写的类以及R.class、BuildConfig.class以及R$XXX.class等
MyInject.injectDir(directoryInput.file.absolutePath,"com\\hc\\hcplugin")
// 获取output目录
def dest = outputProvider.getContentLocation(directoryInput.name,
directoryInput.contentTypes, directoryInput.scopes,
Format.DIRECTORY)

// 将input的目录复制到output指定目录
FileUtils.copyDirectory(directoryInput.file, dest)
}
//对类型为jar文件的input进行遍历
input.jarInputs.each { JarInput jarInput ->

//jar文件一般是第三方依赖库jar文件

// 重命名输出文件（同目录copyFile会冲突）
def jarName = jarInput.name
def md5Name = DigestUtils.md5Hex(jarInput.file.getAbsolutePath())
if (jarName.endsWith(".jar")) {
jarName = jarName.substring(0, jarName.length() - 4)
}
//生成输出路径
def dest = outputProvider.getContentLocation(jarName + md5Name,
jarInput.contentTypes, jarInput.scopes, Format.JAR)
//将输入内容复制到输出
FileUtils.copyFile(jarInput.file, dest)
}
}
}


大功告成，接下来测试一下，在app模块中，新建一个Test类，在MainActivity中调用new Test()；

Test.java

package com.hc.hcplugin;

/**
* Created by HuaChao on 2016/7/4.
*/
public class Test {
}


MainActivity.java

package com.hc.hcplugin;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.e("--->", "===================");
new Test();
Log.e("--->", "===================");
}

}


运行结果如下：



第一个打印是MainActivity的构造函数打印的，第二个是Test的构造函数打印的。看到这里，或许你想说，这有什么用啊？难道搞半天就为了打印这么一句话？其实，真的很有用，如果你看过关于热补丁相关内容，你就知道，还真的需要对每个类加上
System.out.println(xxx)
。不信你看：

https://mp.weixin.qq.com/s?__biz=MzI1MTA1MzM2Nw==&mid=400118620&idx=1&sn=b4fdd5055731290eef12ad0d17f39d4a&scene=1&srcid=1106Imu9ZgwybID13e7y2nEi#wechat_redirect

附上源码：http://download.csdn.net/download/huachao1001/9567113
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航