如何利用缓存机制实现JAVA类反射性能提升30倍-深蓝源码网

时间: 2020-09-03 00:08:26 人气: 2278 评论: 0

一次性能提高30倍的JAVA类反射性能优化实践

文章来源：宜信技术学院 & 宜信支付结算团队技术分享第4期-支付结算部支付研发团队高级工程师陶红《JAVA类反射技术&优化》
分享者：宜信支付结算部支付研发团队高级工程师陶红
原文首发于宜信支付结算技术团队公号：野指针

在实际工作中的一些特定应用场景下，JAVA类反射是经常用到、必不可少的技术，在项目研发过程中，我们也遇到了不得不运用JAVA类反射技术的业务需求，并且不可避免地面临这个技术固有的性能瓶颈问题。

通过近两年的研究、尝试和验证，我们总结出一套利用缓存机制、大幅度提高JAVA类反射代码运行效率的方法，和没有优化的代码相比，性能提高了20～30倍。本文将与大家分享在探索和解决这个问题的过程中的一些有价值的心得体会与实践经验。

简述：JAVA类反射技术

首先，用最简短的篇幅介绍JAVA类反射技术。

如果用一句话来概述，JAVA类反射技术就是：

绕开编译器，在运行期直接从虚拟机获取对象实例/访问对象成员变量/调用对象的成员函数。

抽象的概念不多讲，用代码说话……举个例子，有这样一个类：

public class ReflectObj {
	private String field01;
	public String getField01() {
		return this.field01;
	}
	public void setField01(String field01) {
		this.field01 = field01;
	}
}

如果按照下列代码来使用这个类，就是传统的“创建对象－调用”模式：

	ReflectObj obj = new ReflectObj();
	obj.setField01("value01");
	System.out.println(obj.getField01());

如果按照如下代码来使用它，就是“类反射”模式：

	// 直接获取对象实例
	ReflectObj obj = ReflectObj.class.newInstance();
	// 直接访问Field
	Field field = ReflectObj.class.getField("field01");
	field.setAccessible(true);
	field.set(obj, "value01");
	// 调用对象的public函数
	Method method = ReflectObj.class.getMethod("getField01");
	System.out.println((String) method.invoke(obj));

类反射属于古老而基础的JAVA技术，本文不再赘述。

从上面的代码可以看出：

相比较于传统的“创建对象－调用”模式，“类反射”模式的代码更抽象、一般情况下也更加繁琐；
类反射绕开了编译器的合法性检测——比如访问了一个不存在的字段、调用了一个不存在或不允许访问的函数，因为编译器设立的防火墙失效了，编译能够通过，但是运行的时候会报错；
实际上，如果按照标准模式编写类反射代码，效率明显低于传统模式。在后面的章节会提到这一点。

缘起：为什么使用类反射

前文简略介绍了JAVA类反射技术，在与传统的“创建对象－调用”模式对比时，提到了类反射的几个主要弱点。但是在实际工作中，我们发现类反射无处不在，特别是在一些底层的基础框架中，类反射是应用最为普遍的核心技术之一。最常见的例子：Spring容器。

这是为什么呢？我们不妨从实际工作中的具体案例出发，分析类反射技术的不可替代性。

大家几乎每天都和银行打交道，通过银行进行存款、转帐、取现等金融业务，这些动账操作都是通过银行核心系统（包括交易核心/账务核心/对外支付/超级网银等模块）完成的，因为历史原因造成的技术路径依赖，银行核心系统的报文几乎都是xml格式，而且以这种格式最为普遍：

<?xml version='1.0' encoding='UTF-8'?>
<service>
	<sys-header>
		<data name="SYS_HEAD">
			<struct>
				<data name="MODULE_ID">
					<field type="string" length="2">RB</field>
				</data>
				<data name="USER_ID">
					<field type="string" length="6">OP0001</field>
				</data>
				<data name="TRAN_TIMESTAMP">
					<field type="string" length="9">003026975</field>
				</data>
				<!-- 其它字段略过 -->
			</struct>
		</data>
	</sys-header>
	<!-- 其它段落略过 -->
	<body>
		<data name="REF_NO">
			<field type="string" length="23">OPS18112400302633661837</field>
		</data>
	</body>
</service>

和常用的xml格式进行对比：

<?xml version="1.0" encoding="UTF-8"?>
<recipe>
		<recipename>Ice Cream Sundae</recipename>
		<ingredlist>
			<listitem>
				<quantity>3</quantity>
				<itemdescription>chocolate syrup or chocolate fudge</itemdescription>
			</listitem>
			<listitem>
				<quantity>1</quantity>
				<itemdescription>nuts</itemdescription>
			</listitem>
			<listitem>
				<quantity>1</quantity>
				<itemdescription>cherry</itemdescription>
			</listitem>
		</ingredlist>
		<preptime>5 minutes</preptime>
</recipe>

银行核心系统的xml报文不是用标签的名字区分元素，而是用属性（name属性）区分，在解析的时候，不管是用DOM、SAX，还是Digester或其它方案，都要用条件判断语句、分支处理，伪代码如下：

// ……
接口类实例 obj = new 接口类();
List<Node> nodeList = 获取xml标签列表
for (Node node: nodeList) {
if (node.getProperty("name") == "张三") obj.set张三 (node.getValue());
	else if (node.getProperty("name") == "李四") obj.set李四 (node.getValue());
	// ……
}
// ……

显而易见，这样的代码非常粗劣、不优雅，每解析一个接口的报文，都要写一个专门的类或者函数，堆砌大量的条件分支语句，难写、难维护。如果报文结构简单还好，如果有一百个甚至更多的字段，怎么办？毫不夸张，在实际工作中，我遇到过一个银行核心接口有140多个字段的情况，而且这还不是最多的！

试水：优雅地解析XML

当我们碰到这种结构的xml、而且字段还特别多的时候，解决问题的钥匙就是类反射技术，基本思路是：

从xml中解析出字段的name和value，以键值对的形式存储起来；
用类反射的方法，用键值对的name找到字段或字段对应的setter（这是有规律可循的）；
然后把value直接set到字段，或者调用setter把值set到字段。

接口类应该是这样的结构：

nodes是存储字段的name－value键值对的列表，MessageNode就是键值对，结构如下：

public class MessageNode {
	private String name;
	private String value;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getValue() {
		return value;
	}
	public void setValue(String value) {
		this.value = value;
	}
	public MessageNode() {
		super();
	}
}

createNode是在解析xml的时候，把键值对添加到列表的函数；
initialize是用类反射方法，根据键值对初始化每个字段的函数。

这样，解析xml的代码可以变得非常优雅、简洁。如果用Digester解析之前列举的那种格式的银行报文，可以这样写：

	Digester digester = new Digester();
	digester.setValidating(false);
	digester.addObjectCreate("service/sys-header", SysHeader.class);
	digester.addCallMethod("service/sys-header/data/struct/data", "createNode", 2);
	digester.addCallParam("service/sys-header/data/struct/data", 0, "name");
	digester.addCallParam("service/sys-header/data/struct/data/field", 1);
	parseObj = (SysHeader) digester.parse(new StringReader(msg));
	parseObj.initialize();

initialize函数的代码，可以写在一个基类里面，子类继承基类即可。具体代码如下：

public void initialize() {
for (MessageNode node: nodes) {
    	try {
    		/**
    		 * 直接获取字段、然后设置字段值
    		 */
			//String fieldName = StringUtils.camelCaseConvert(node.getName());
    		// 只获取调用者自己的field（private/protected/public修饰词皆可）
			//Field field = this.getClass().getDeclaredField(fieldName);
    		// 获取调用者自己的field（private/protected/public修饰词皆可）和从父类继承的field（必须是public修饰词）
			//Field field = this.getClass().getField(fieldName);
    		// 把field设为可写
			//field.setAccessible(true);
    		// 直接设置field的值
			//field.set(this, node.getValue());
    		/**
    		 * 通过setter设置字段值
    		 */
			Method method = this.getSetter(node.getName());
			// 调用setter
			method.invoke(this, node.getValue());
		} catch (Exception e) {
			log.debug("It's failed to initialize field: {}, reason: {}", node.getName(), e);
		};
	}
	}

上面被注释的段落是直接访问Field的方式，下面的段落是调用setter的方式，两种方法在效率上没有差别。

考虑到JAVA语法规范（书写bean的规范），调用setter是更通用的办法，因为接口类可能是被继承、派生的，子类无法访问父类用private关键字修饰的Field。

getSetter函数很简单，就是用Field的名字反推setter的名字，然后用类反射的办法获取setter。代码如下：

    private Method getSetter(String fieldName) throws NoSuchMethodException, SecurityException {
	String methodName = String.format("set%s", StringUtils.upperFirstChar(fieldName));
	// 获取field的setter，只要是用public修饰的setter、不管是自己的还是从父类继承的，都能取到
	return this.getClass().getMethod(methodName, String.class);
    }

如果设计得好，甚至可以用一个解析函数处理所有的接口，这涉及到Digerser的运用技巧和接口类的设计技巧，本文不作深入讲解。

2017年，我们在一个和银行有关的金融增值服务项目中使用了这个解决方案，取得了非常不错的效果，之后在公司内部推广开来成为了通用技术架构。经过一年多的实践，证明这套架构性能稳定、可靠，极大地简化了代码编写和维护工作，显著提高了生产效率。

问题：类反射性能差

但是，随着业务量的增加，2018年末在进行压力测试的时候，发现解析xml的代码占用CPU资源居高不下。进一步分析、定位，发现问题出在类反射代码上，在某些极端的业务场景下，甚至会占用90％的CPU资源！这就提出了性能优化的迫切要求。

类反射的性能优化不是什么新课题，因此有一些成熟的第三方解决方案可以参考，比如运用比较广泛的ReflectASM，据称可以比未经优化的类反射代码提高1/3左右的性能。

（参考资料：Java高性能反射工具包ReflectASM，ReflectASM-invoke,高效率java反射机制原理）

在研究了ReflectASM的源代码以后，我们决定不使用现成的第三方解决方案，而是从底层入手、自行解决类反射代码的优化问题。主要基于两点考虑：

ReflectASM的基本技术原理，是在运行期动态分析类的结构，把字段、函数建立索引，然后通过索引完成类反射，技术上并不高深，性能也谈不上完美；
类反射是我们系统使用的关键技术，使用场景、调用频率都非常高，从自主掌握和控制基础、核心技术，实现系统的性能最优化角度考虑，应该尽量从底层技术出发，独立、可控地完成优化工作。

思路和实践：缓存优化

前面提到ReflectASM给类的字段、函数建立索引，借此提高类反射效率。进一步分析，这实际上是变相地缓存了字段和函数。那么，在我们面临的业务场景下，能不能用缓存的方式优化类反射代码的效率呢？

我们的业务场景需要以类反射的方式频繁调用接口类的setter，这些setter都是用public关键字修饰的函数，先是getMethod()、然后invoke()。基于以上特点，我们用如下逻辑和流程进行了技术分析：

用调试分析工具统计出每一句类反射代码的执行耗时，结果发现性能瓶颈在getMethod()；
分析JAVA虚拟机的内存模型和管理机制，寻找解决问题的方向。JAVA虚拟机的内存模型，可以从下面两个维度来描述：

A.类空间/对象空间维度

B.堆/栈维度

从JAVA虚拟机内存模型可以看出，getMethod()需要从不连续的堆中检索代码段、定位函数入口，获得了函数入口、invoke()之后就和传统的函数调用差不多了，所以性能瓶颈在getMethod()；
代码段属于类空间（也有资料将其描述为“函数空间”/“代码空间”），类被加载后，除非虚拟机关闭，函数入口不会变化。那么，只要把setter函数的入口缓存起来，不就节约了getMethod()消耗的系统资源，进而提高了类反射代码的执行效率吗？

把接口类修改为这样的结构（标红的部分是新增或修改）：

setterMap就是缓存字段setter的HashMap。为什么是两层嵌套结构呢？因为这个Map是写在基类里面的静态变量，每个从基类派生出的接口类都用它缓存setter，所以第一层要区分不同的接口类，第二层要区分不同的字段。如下图所示：

当ClassLoader加载基类时，创建setterMap（内容为空）：

	static {
		setterMap = new 
						 技术沙龙 教程文章 热点综合

分享链接