Proguard源码分析(五) ConfigurationParser.keep参数
本章节我们绕回来讲Keep参数,也就是ConfigurationParser 这个类。
ConfigurationParser这个类是非常重要的类,如果你已经开始看源码,你会发现所有的类和功能都围着它来转,本章节我们来揭开它的地一层面纱。
else if (ConfigurationConstants.KEEP_OPTION.startsWith(nextWord))
configuration.keep = parseKeepClassSpecificationArguments(
configuration.keep, true, false, false);
else if (ConfigurationConstants.KEEP_CLASS_MEMBERS_OPTION
.startsWith(nextWord))
configuration.keep = parseKeepClassSpecificationArguments(
configuration.keep, false, false, false);
else if (ConfigurationConstants.KEEP_CLASSES_WITH_MEMBERS_OPTION
.startsWith(nextWord))
configuration.keep = parseKeepClassSpecificationArguments(
configuration.keep, false, true, false);
else if (ConfigurationConstants.KEEP_NAMES_OPTION
.startsWith(nextWord))
configuration.keep = parseKeepClassSpecificationArguments(
configuration.keep, true, false, true);
else if (ConfigurationConstants.KEEP_CLASS_MEMBER_NAMES_OPTION
.startsWith(nextWord))
configuration.keep = parseKeepClassSpecificationArguments(
configuration.keep, false, false, true);
else if (ConfigurationConstants.KEEP_CLASSES_WITH_MEMBER_NAMES_OPTION
.startsWith(nextWord))
configuration.keep = parseKeepClassSpecificationArguments(
configuration.keep, false, true, true);
可见,所有以keep打头的参数都是调用的parseKeepClassSpecificationArguments
跟一下这个函数的逻辑
while (true) {
readNextWord("keyword '" + ConfigurationConstants.CLASS_KEYWORD
+ "', '" + ClassConstants.EXTERNAL_ACC_INTERFACE
+ "', or '" + ClassConstants.EXTERNAL_ACC_ENUM + "'",
false, true);
if (!ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD
.equals(nextWord)) {
// Not a comma. Stop parsing the keep modifiers.
break;
}
readNextWord("keyword '"
+ ConfigurationConstants.ALLOW_SHRINKING_SUBOPTION + "', '"
+ ConfigurationConstants.ALLOW_OPTIMIZATION_SUBOPTION
+ "', or '"
+ ConfigurationConstants.ALLOW_OBFUSCATION_SUBOPTION + "'");
if (ConfigurationConstants.ALLOW_SHRINKING_SUBOPTION
.startsWith(nextWord)) {
allowShrinking = true;
} else if (ConfigurationConstants.ALLOW_OPTIMIZATION_SUBOPTION
.startsWith(nextWord)) {
allowOptimization = true;
} else if (ConfigurationConstants.ALLOW_OBFUSCATION_SUBOPTION
.startsWith(nextWord)) {
allowObfuscation = true;
} else {
throw new ParseException("Expecting keyword '"
+ ConfigurationConstants.ALLOW_SHRINKING_SUBOPTION
+ "', '"
+ ConfigurationConstants.ALLOW_OPTIMIZATION_SUBOPTION
+ "', or '"
+ ConfigurationConstants.ALLOW_OBFUSCATION_SUBOPTION
+ "' before " + reader.locationDescription());
}
}
ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD
.equals(nextWord)代表以非ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD 作为终结符号,也就是说在keep之后可以跟一些参数,这些参数我们来看一下~
public static final String ALLOW_SHRINKING_SUBOPTION = "allowshrinking";
public static final String ALLOW_OPTIMIZATION_SUBOPTION = "allowoptimization";
public static final String ALLOW_OBFUSCATION_SUBOPTION = "allowobfuscation";
也就是说你可以采用下面这种写法:
-keep,allowshrinking,allowoptimization public class *;
我们来看一下这三个参数的影响:
if ((shrinking && !keepClassSpecification.allowShrinking) ||
(optimizing && !keepClassSpecification.allowOptimization) ||
(obfuscating && !keepClassSpecification.allowObfuscation))
{
ClassPoolVisitor classPoolVisitor = createClassPoolVisitor(keepClassSpecification,
classVisitor,
memberVisitor);
multiClassPoolVisitor.addClassPoolVisitor(classPoolVisitor);
}
结果似乎并不是我想的那样,要对这个类不做任何处理,必须保证这三个参数都为true.
在这之后会调用parseClassSpecificationArguments() 来生成一个ClassSpecification 的原始数据
classSpecification.requiredSetAccessFlags,
classSpecification.requiredUnsetAccessFlags,
classSpecification.annotationType,
classSpecification.className,
classSpecification.extendsAnnotationType,
classSpecification.extendsClassName,
classSpecification.fieldSpecifications,
classSpecification.methodSpecifications
requiredSetAccessFlags 和requiredUnsetAccessFlags 两个是必须设置的
它是检测是否加载该类的入口之一。他们的值是:
public static final int INTERNAL_ACC_PUBLIC = 0x0001;
public static final int INTERNAL_ACC_PRIVATE = 0x0002;
public static final int INTERNAL_ACC_PROTECTED = 0x0004;
public static final int INTERNAL_ACC_STATIC = 0x0008;
public static final int INTERNAL_ACC_FINAL = 0x0010;
public static final int INTERNAL_ACC_SUPER = 0x0020;
public static final int INTERNAL_ACC_SYNCHRONIZED = 0x0020;
public static final int INTERNAL_ACC_VOLATILE = 0x0040;
public static final int INTERNAL_ACC_TRANSIENT = 0x0080;
public static final int INTERNAL_ACC_BRIDGE = 0x0040;
public static final int INTERNAL_ACC_VARARGS = 0x0080;
public static final int INTERNAL_ACC_NATIVE = 0x0100;
public static final int INTERNAL_ACC_INTERFACE = 0x0200;
public static final int INTERNAL_ACC_ABSTRACT = 0x0400;
public static final int INTERNAL_ACC_STRICT = 0x0800;
public static final int INTERNAL_ACC_SYNTHETIC = 0x1000;
public static final int INTERNAL_ACC_ANNOTATTION = 0x2000;
public static final int INTERNAL_ACC_ENUM = 0x4000;
parseClassSpecificationArguments() 方法中定义了class的写法
当你的:
if (accessFlag == ClassConstants.INTERNAL_ACC_ANNOTATTION) {
// Already read the next word.
readNextWord("annotation type or keyword '"
+ ClassConstants.EXTERNAL_ACC_INTERFACE + "'", false,
false);
// Is the next word actually an annotation type?
if (!nextWord.equals(ClassConstants.EXTERNAL_ACC_INTERFACE)
&& !nextWord.equals(ClassConstants.EXTERNAL_ACC_ENUM)
&& !nextWord.equals(ConfigurationConstants.CLASS_KEYWORD)) {
// Parse the annotation type.
annotationType = ListUtil.commaSeparatedString(
parseCommaSeparatedList("annotation type", false,
false, false, false, true, false, false,
true, null), false);
// Continue parsing the access modifier that we just read
// in the next cycle.
continue;
}
// Otherwise just handle the annotation modifier.
}
accessFlag 为注解符号的时候,大致写法是这样的:
-keep @com.test.TestAnno
public class * {
*;
}
-keepclassmembers class * {
@com.test.TestAnno <methods>;
}
也就是说完全按照java的语法标准来实现。
解析完注解之后直到解析class interface enum 这些关键字
if (strippedWord.equals(ClassConstants.EXTERNAL_ACC_INTERFACE)
|| strippedWord.equals(ClassConstants.EXTERNAL_ACC_ENUM)
|| strippedWord.equals(ConfigurationConstants.CLASS_KEYWORD)) {
// The interface or enum keyword. Stop parsing the class flags.
break;
}
得到externalClassName
之后调用
if (!configurationEnd()) {
// Parse 'implements ...' or 'extends ...' part, if any.
if (ConfigurationConstants.IMPLEMENTS_KEYWORD.equals(nextWord)
|| ConfigurationConstants.EXTENDS_KEYWORD.equals(nextWord)) {
readNextWord("class name or interface name", false, true);
// Parse the annotation type, if any.
LOG.log("start ");
if (ConfigurationConstants.ANNOTATION_KEYWORD.equals(nextWord)) {
extendsAnnotationType = ListUtil.commaSeparatedString(
parseCommaSeparatedList("annotation type", true,
false, false, false, true, false, false,
true, null), false);
}
String externalExtendsClassName = ListUtil
.commaSeparatedString(
parseCommaSeparatedList(
"class name or interface name", false,
false, false, false, true, false,
false, false, null), false);
extendsClassName = ConfigurationConstants.ANY_CLASS_KEYWORD
.equals(externalExtendsClassName) ? null : ClassUtil
.internalClassName(externalExtendsClassName);
}
}
configurationEnd() 的结束条件是-和@,那么括号里面的又是干什么用的呢？
这是一种语法结构大致结构是这个样子的:
-keep public class * extends @com.test.TestAnno * #here
{
*;
}
解析到here这个位置,代表保持这个这个标注注解类的子类
最后将定义个类的元数据:
ClassSpecification classSpecification = new ClassSpecification(
lastComments, requiredSetClassAccessFlags,
requiredUnsetClassAccessFlags, annotationType, className,
extendsAnnotationType, extendsClassName);
进行下一次的匹配,
if (!configurationEnd()) {
// Check the class member opening part.
if (!ConfigurationConstants.OPEN_KEYWORD.equals(nextWord)) {
throw new ParseException("Expecting opening '"
+ ConfigurationConstants.OPEN_KEYWORD + "' at "
+ reader.locationDescription());
}
// Parse all class members.
while (true) {
readNextWord("class member description" + " or closing '"
+ ConfigurationConstants.CLOSE_KEYWORD + "'", false,
true);
if (nextWord.equals(ConfigurationConstants.CLOSE_KEYWORD)) {
// The closing brace. Stop parsing the class members.
readNextWord();
break;
}
parseMemberSpecificationArguments(externalClassName,
classSpecification);
}
}
这个匹配必须是非结束符号也就是不是 - 或者@
这就说明proguard的语法支持
-keep public class ...或者
-keep public class ...{...}
我们来看下第二种它是怎么做的：
if (nextWord.equals(ConfigurationConstants.CLOSE_KEYWORD)) {
// The closing brace. Stop parsing the class members.
readNextWord();
break;
}
当读入的字符不为}的时候将继续读入
解析成员通过方法parseMemberSpecificationArguments 来生成
这个方法跟类分析程序非常相似多了一些参数的条件,比如static native transient volatile final 这类用来形容方法或者变量的属性当然在这之前有过注解验证,也就是说支持:
{
@anno
static test
}
这种写法
接下来会通过
if ( ConfigurationConstants.ANY_CLASS_MEMBER_KEYWORD.equals(nextWord)
|| ConfigurationConstants.ANY_FIELD_KEYWORD.equals(nextWord)
|| ConfigurationConstants.ANY_METHOD_KEYWORD.equals(nextWord))
三个方法来对三种通配符号做处理,这三种通配符号分别是:*，<fields>,<methods>
匹配完成之后会生成叫做MemberSpecification 的对象来倒入到class的配置中
*可以看作是后面两个东西的集合,所以在proguard处理的时候会同时调用
classSpecification.addField(new MemberSpecification(
requiredSetMemberAccessFlags,
requiredUnsetMemberAccessFlags, annotationType, null,
null));
classSpecification.addMethod(new MemberSpecification(
requiredSetMemberAccessFlags,
requiredUnsetMemberAccessFlags, annotationType, null,
null));
这两个方法。
如果你不采用通配符号的方式来写的话,也就是说你默认会给出一个精确表达式，也有可能是一个模式匹配的表达式。我们来看一下Proguard对它的处理流程:
ConfigurationConstants.OPEN_ARGUMENTS_KEYWORD.equals(name)
proguard会先检测是否是携带参数:
这里它对构造器方法和一些错误的可能做的屏蔽处理:
if (!(type.equals(ClassConstants.INTERNAL_METHOD_NAME_INIT)
|| type.equals(externalClassName) || type
.equals(ClassUtil
.externalShortClassName(externalClassName)))) {
throw new ParseException("Expecting type and name "
+ "instead of just '" + type + "' before "
+ reader.locationDescription());
}
原理很简单,由于构造器是没有返回值的,所以你之前期望得到的返回类型应该就是构造器的方法名<init>
if (ConfigurationConstants.SEPARATOR_KEYWORD.equals(nextWord)) {
// It's a field.
checkFieldAccessFlags(requiredSetMemberAccessFlags,
requiredUnsetMemberAccessFlags);
// We already have a field descriptor.
String descriptor = ClassUtil.internalType(type);
// Add the field.
classSpecification.addField(new MemberSpecification(
requiredSetMemberAccessFlags,
requiredUnsetMemberAccessFlags, annotationType, name,
descriptor));
} else if (ConfigurationConstants.OPEN_ARGUMENTS_KEYWORD
.equals(nextWord)) {
// It's a method.
checkMethodAccessFlags(requiredSetMemberAccessFlags,
requiredUnsetMemberAccessFlags);
// Parse the method arguments.
String descriptor = ClassUtil.internalMethodDescriptor(
type,
parseCommaSeparatedList("argument", true, true, true,
false, true, false, false, false, null));
if (!ConfigurationConstants.CLOSE_ARGUMENTS_KEYWORD
.equals(nextWord)) {
throw new ParseException("Expecting separating '"
+ ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD
+ "' or closing '"
+ ConfigurationConstants.CLOSE_ARGUMENTS_KEYWORD
+ "' before " + reader.locationDescription());
}
// Read the separator after the closing parenthesis.
readNextWord("separator '"
+ ConfigurationConstants.SEPARATOR_KEYWORD + "'");
if (!ConfigurationConstants.SEPARATOR_KEYWORD.equals(nextWord)) {
throw new ParseException("Expecting separator '"
+ ConfigurationConstants.SEPARATOR_KEYWORD
+ "' before " + reader.locationDescription());
}
// Add the method.
classSpecification.addMethod(new MemberSpecification(
requiredSetMemberAccessFlags,
requiredUnsetMemberAccessFlags, annotationType, name,
descriptor));
} else {
// It doesn't look like a field or a method.
throw new ParseException("Expecting opening '"
+ ConfigurationConstants.OPEN_ARGUMENTS_KEYWORD
+ "' or separator '"
+ ConfigurationConstants.SEPARATOR_KEYWORD
+ "' before " + reader.locationDescription());
}
这段代码也非常好理解,对于只有名字然后直接跟分号的话,它认为是成员变量参数,如果是(则是方法,对于方法来说最重要的就是方法的签名,我们来关注一下方法是如何获得签名的.
方法签名是通过String descriptor = ClassUtil.internalMethodDescriptor(
type,
parseCommaSeparatedList("argument", true, true, true,
false, true, false, false, false, null));
来获得,其中type就是你的返回值,我们不说详细过程,只注重一些细节的结果parseCommaSeparatedList的参数列表最后得到相应的方法签名例如:
(ILcom/test/Base;)V
第一个I代表的是INT ,如果你想关注这些,不妨看一下jvm汇编一类的知识,其实c++的方法签名方式也大同小异。所以如果你之前从事过这方面的话,应该是不会陌生的。
转载于:https://www.cnblogs.com/feizimo/p/3523832.html
Proguard源码分析(五) ConfigurationParser.keep参数相关推荐
- Mybatis-Spring源码分析(五) MapperMethod和MappedStatement解析
前言 基本上这就是Mybatis-Spring源码的最后一篇了,如果想起来什么再单开博客.比起来Spring源码,Mybatis的确实简单一些,本篇就说一下Mybatis中两个十分重要的类Mapper ...
- Vue.js 源码分析(五) 基础篇 方法 methods属性详解
methods中定义了Vue实例的方法,官网是这样介绍的: 例如:: <!DOCTYPE html> <html lang="en"> <head&g ...
- openstack-nova源码分析(五）flavor extra_specs 扩展属性
Flavors extra-specs (flavors, os-flavor-extra-specs) Flavor 扩展属性设置, 扩展属性可以用来对虚拟机做一些额外的限制设置,具体的参数,将在后 ...
- MPTCP 源码分析(五) 接收端窗口值
简述: 在TCP协议中影响数据发送的三个因素分别为:发送端窗口值.接收端窗口值和拥塞窗口值. 本文主要分析MPTCP中各个子路径对接收端窗口值rcv_wnd的处理. 接收端窗口值的初始化 根据< ...
- 【转】ABP源码分析五：ABP初始化全过程
ABP在初始化阶段做了哪些操作,前面的四篇文章大致描述了一下. 为个更清楚的描述其脉络,做了张流程图以辅助说明.其中每一步都涉及很多细节,难以在一张图中全部表现出来.每一步的细节(会涉及到较多接口,类 ...
- 谷歌chrome浏览器的源码分析(五)
上一次说到类RenderThread和类RenderView把消息处理,那么这两个类是怎么样处理消息的呢?又是怎么样处理浏览的消息呢?现在就带着这两个问题去分析它的源码,理解它处理消息的方法.类Ren ...
- Myabtis源码分析五-Mybatis配置加载完全图解，建造者模式的使用，涵盖Java各种技术栈
private SqlSessionFactory sqlSessionFactory; @Before public void init() throws IOException { //----- ...
- tcp/ip 协议栈Linux源码分析五 IPv6分片报文重组分析一
做防火墙模块的时候遇到过IPv6分片报文处理的问题是,当时的问题是netfilter无法基于传输层的端口拦截IPv6分片报文,但是IPv4的分片报文可以.分析了内核源码得知是因为netfilter的连 ...
- motan源码分析五：cluster相关
上一章我们分析了客户端调用服务端相关的源码,但是到了cluster里面的部分我们就没有分析了,本章将深入分析cluster和它的相关支持类. 1.clustersupport的创建过程,上一章的Ref ...
最新文章
- windows下如何在一台机器上安装两个MYSQL数据库
- linux ssh和sftp区别,使用 SSH 和 SFTP 协议
- python编写程序的一般步骤-Python编写win程序的操作流程
- ACM-ICPC 2018 徐州赛区网络预赛 D. EasyMath
- java 委托_java 能不能自己写一个类叫 java.lang.System/String 正确答案
- 新娘JAVA_Java之趣味编程结婚问题
- SQL50道练习题（1-15）
- sql union和unmion all区别
- 机器学习算法——决策树3（CART决策树算法）
- 基于C#和遥感软件二次开发的宜居度综合方法
- Ubuntu18.04安装网易云音乐后通过图标打不开
- windows局域网的一个经典的入侵方法
- 驱动备份及还原命令-手记
- mastercam9.1按alt键卡机，mastercam输入参数卡机需要win10输入法兼容性设置
- jQueryDay04:distpicker省市县三级联动， Layer插件，Laydate插件
- Windows7/10耳机插入前面板没反应的解决方案
- 如何在Ubuntu上使用Ensemble数据库Biomart预测目标基因可能结合的转录因子
- openGauss并行解码浅谈
- 第七十篇：从ADAS到自动驾驶（三）：车道检测
- Java中%是什么意思？