Java深度探险.docx

资源描述

Java深度探险.docx

《Java深度探险.docx》由会员分享，可在线阅读，更多相关《Java深度探险.docx（47页珍藏版）》请在冰豆网上搜索。

Java深度探险.docx

Java深度探险

Jingweisun@

Java深度探险系列

作者：

成富，组织：

孙景卫

一、Java深度历险

（一）Java字节代码的操纵3

动态编译Java源文件3

Java字节代码增强6

java.lang.instrument7

总结8

参考资料9

二、Java深度历险

（二）——Java类的加载、链接和初始化9

相关赞助商9

Java类的加载10

Java类的链接10

Java类的初始化11

创建自己的类加载器13

参考资料14

三、Java深度历险（三）——Java线程：

基本概念、可见性与同步14

Java线程基本概念14

可见性15

Java中的锁16

Java线程的同步16

中断线程17

参考资料18

四、Java深度历险（四）——Java垃圾回收机制与引用类型18

Java垃圾回收机制18

Java引用类型19

强引用20

软引用20

弱引用21

幽灵引用21

引用队列22

参考资料23

五、Java深度历险（五）——Java泛型23

类型擦除23

实例分析24

通配符与上下界25

类型系统25

开发自己的泛型类26

最佳实践27

参考资料27

六、Java深度历险（六）——Java注解27

使用注解27

开发注解28

处理注解28

实例分析32

参考资料33

七、Java深度历险（七）——Java反射与动态代理33

基本用法33

处理泛型35

动态代理36

使用案例37

参考资料37

八、Java深度历险（八）——JavaI/O37

流38

流的使用38

缓冲区40

字符与编码41

通道42

文件通道42

套接字通道43

参考资料45

九、感谢45

十、备注45

一、Java深度历险

（一）Java字节代码的操纵

作者成富

【编者按】Java作为业界应用最为广泛的语言之一，深得众多软件厂商和开发者的推崇，更是被包括Oracle在内的众多JCP成员积极地推动发展。

但是对于Java语言的深度理解和运用，毕竟是很少会有人涉及的话题。

InfoQ中文站特地邀请IBM高级工程师成富为大家撰写这个《Java深度历险》专栏，旨在就Java的一些深度和高级特性分享他的经验。

在一般的Java应用开发过程中，开发人员使用Java的方式比较简单。

打开惯用的IDE，编写Java源代码，再利用IDE提供的功能直接运行Java程序就可以了。

这种开发模式背后的过程是：

开发人员编写的是Java源代码文件（.java），IDE会负责调用Java的编译器把Java源代码编译成平台无关的字节代码（bytecode），以类文件的形式保存在磁盘上（.class）。

Java虚拟机（JVM）会负责把Java字节代码加载并执行。

Java通过这种方式来实现其“编写一次，到处运行（Writeonce,runanywhere）”的目标。

Java类文件中包含的字节代码可以被不同平台上的JVM所使用。

Java字节代码不仅可以以文件形式存在于磁盘上，也可以通过网络方式来下载，还可以只存在于内存中。

JVM中的类加载器会负责从包含字节代码的字节数组（byte[]）中定义出Java类。

在某些情况下，可能会需要动态的生成Java字节代码，或是对已有的Java字节代码进行修改。

这个时候就需要用到本文中将要介绍的相关技术。

首先介绍一下如何动态编译Java源文件。

动态编译Java源文件

在一般情况下，开发人员都是在程序运行之前就编写完成了全部的Java源代码并且成功编译。

对有些应用来说，Java源代码的内容在运行时刻才能确定。

这个时候就需要动态编译源代码来生成Java字节代码，再由JVM来加载执行。

典型的场景是很多算法竞赛的在线评测系统（如PKUJudgeOnline），允许用户上传Java代码，由系统在后台编译、运行并进行判定。

在动态编译Java源文件时，使用的做法是直接在程序中调用Java编译器。

JSR199引入了Java编译器API。

如果使用JDK6的话，可以通过此API来动态编译Java代码。

比如下面的代码用来动态编译最简单的HelloWorld类。

该Java类的代码是保存在一个字符串中的。

publicclassCompilerTest{

publicstaticvoidmain（String[]args）throwsException{

Stringsource="publicclassMain{publicstaticvoidmain（String[]args）{System.out.println（\"HelloWorld!

\"）;}}";

JavaCompilercompiler=ToolProvider.getSystemJavaCompiler（）;

StandardJavaFileManagerfileManager=compiler.getStandardFileManager（null,null,null）;

StringSourceJavaObjectsourceObject=newCompilerTest.StringSourceJavaObject（"Main",source）;

IterablefileObjects=Arrays.asList（sourceObject）;

CompilationTasktask=compiler.getTask（null,fileManager,null,null,null,fileObjects）;

booleanresult=task.call（）;

if（result）{

System.out.println（"编译成功。

"）;

}

staticclassStringSourceJavaObjectextendsSimpleJavaFileObject{

privateStringcontent=null;

publicStringSourceJavaObject（Stringname,Stringcontent）?

throwsURISyntaxException{

super（URI.create（"string:

///"+name.replace（'.','/'）+Kind.SOURCE.extension）,Kind.SOURCE）;

this.content=content;

}

publicCharSequencegetCharContent（booleanignoreEncodingErrors）?

throwsIOException{

returncontent;

}

如果不能使用JDK6提供的Java编译器API的话，可以使用JDK中的工具类com.sun.tools.javac.Main，不过该工具类只能编译存放在磁盘上的文件，类似于直接使用javac命令。

另外一个可用的工具是EclipseJDTCore提供的编译器。

这是EclipseJava开发环境使用的增量式Java编译器，支持运行和调试有错误的代码。

该编译器也可以单独使用。

Play框架在内部使用了JDT的编译器来动态编译Java源代码。

在开发模式下，Play框架会定期扫描项目中的Java源代码文件，一旦发现有修改，会自动编译Java源代码。

因此在修改代码之后，刷新页面就可以看到变化。

使用这些动态编译的方式的时候，需要确保JDK中的tools.jar在应用的CLASSPATH中。

下面介绍一个例子，是关于如何在Java里面做四则运算，比如求出来（3+4）*7-10的值。

一般的做法是分析输入的运算表达式，自己来模拟计算过程。

考虑到括号的存在和运算符的优先级等问题，这样的计算过程会比较复杂，而且容易出错。

另外一种做法是可以用JSR223引入的脚本语言支持，直接把输入的表达式当做JavaScript或是JavaFX脚本来执行，得到结果。

下面的代码使用的做法是动态生成Java源代码并编译，接着加载Java类来执行并获取结果。

这种做法完全使用Java来实现。

privatestaticdoublecalculate（Stringexpr）throwsCalculationException {

StringclassName="CalculatorMain";

StringmethodName="calculate";

Stringsource="publicclass"+className

+"{publicstaticdouble"+methodName+"（）{return"+expr+";}}";

//省略动态编译Java源代码的相关代码，参见上一节

booleanresult=task.call（）;

if（result）{

ClassLoaderloader=Calculator.class.getClassLoader（）;

try{

Class

>clazz=loader.loadClass（className）;

Methodmethod=clazz.getMethod（methodName,newClass

>[]{}）;

Objectvalue=method.invoke（null,newObject[]{}）;

return（Double）value;

}catch（Exceptione）{

thrownewCalculationException（"内部错误。

"）;

}

}else{

thrownewCalculationException（"错误的表达式。

"）;

}

上面的代码给出了使用动态生成的Java字节代码的基本模式，即通过类加载器来加载字节代码，创建Java类的对象的实例，再通过Java反射API来调用对象中的方法。

Java字节代码增强

Java字节代码增强指的是在Java字节代码生成之后，对其进行修改，增强其功能。

这种做法相当于对应用程序的二进制文件进行修改。

在很多Java框架中都可以见到这种实现方式。

Java字节代码增强通常与Java源文件中的注解（annotation）一块使用。

注解在Java源代码中声明了需要增强的行为及相关的元数据，由框架在运行时刻完成对字节代码的增强。

Java字节代码增强应用的场景比较多，一般都集中在减少冗余代码和对开发人员屏蔽底层的实现细节上。

用过JavaBeans的人可能对其中那些必须添加的getter/setter方法感到很繁琐，并且难以维护。

而通过字节代码增强，开发人员只需要声明Bean中的属性即可，getter/setter方法可以通过修改字节代码来自动添加。

用过JPA的人，在调试程序的时候，会发现实体类中被添加了一些额外的域和方法。

这些域和方法是在运行时刻由JPA的实现动态添加的。

字节代码增强在面向方面编程（AOP）的一些实现中也有使用。

在讨论如何进行字节代码增强之前，首先介绍一下表示一个Java类或接口的字节代码的组织形式。

类文件{

0xCAFEBABE，小版本号，大版本号，常量池大小，常量池数组，

访问控制标记，当前类信息，父类信息，实现的接口个数，实现的接口信息数组，域个数，

域信息数组，方法个数，方法信息数组，属性个数，属性信息数组

}

如上所示，一个类或接口的字节代码使用的是一种松散的组织结构，其中所包含的内容依次排列。

对于可能包含多个条目的内容，如所实现的接口、域、方法和属性等，是以数组来表示的。

而在数组之前的是该数组中条目的个数。

不同的内容类型，有其不同的内部结构。

对于开发人员来说，直接操纵包含字节代码的字节数组的话，开发效率比较低，而且容易出错。

已经有不少的开源库可以对字节代码进行修改或是从头开始创建新的Java类的字节代码内容。

这些类库包括ASM、cglib、serp和BCEL等。

使用这些类库可以在一定程度上降低增强字节代码的复杂度。

比如考虑下面一个简单的需求，在一个Java类的所有方法执行之前输出相应的日志。

熟悉AOP的人都知道，可以用一个前增强（beforeadvice）来解决这个问题。

如果使用ASM的话，相关的代码如下：

ClassReadercr=newClassReader（is）;

ClassNodecn=newClassNode（）;

cr.accept（cn,0）;

for（Objectobject:

cn.methods）{

MethodNodemn=（MethodNode）object;

if（"".equals（mn.name）||"".equals（mn.name））{

continue;

}

InsnListinsns=mn.instructions;

InsnListil=newInsnList（）;

il.add（newFieldInsnNode（GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;"））;

il.add（newLdcInsnNode（"Entermethod->"+mn.name））;

il.add（newMethodInsnNode（INVOKEVIRTUAL,"java/io/PrintStream","println","（Ljava/lang/String;）V"））;

insns.insert（il）; mn.maxStack+=3;

}

ClassWritercw=newClassWriter（0）;

cn.accept（cw）;

byte[]b=cw.toByteArray（）;

从ClassWriter就可以获取到包含增强之后的字节代码的字节数组，可以把字节代码写回磁盘或是由类加载器直接使用。

上述示例中，增强部分的逻辑比较简单，只是遍历Java类中的所有方法并添加对System.out.println方法的调用。

在字节代码中，Java方法体是由一系列的指令组成的。

而要做的是生成调用System.out.println方法的指令，并把这些指令插入到指令集合的最前面。

ASM对这些指令做了抽象，不过熟悉全部的指令比较困难。

ASM提供了一个工具类ASMifierClassVisitor，可以打印出Java类的字节代码的结构信息。

当需要增强某个类的时候，可以先在源代码上做出修改，再通过此工具类来比较修改前后的字节代码的差异，从而确定该如何编写增强的代码。

对类文件进行增强的时机是需要在Java源代码编译之后，在JVM执行之前。

比较常见的做法有：

∙由IDE在完成编译操作之后执行。

如GoogleAppEngine的Eclipse插件会在编译之后运行DataNucleus来对实体类进行增强。

∙在构建过程中完成，比如通过Ant或Maven来执行相关的操作。

∙实现自己的Java类加载器。

当获取到Java类的字节代码之后，先进行增强处理，再从修改过的字节代码中定义出Java类。

∙通过JDK5引入的java.lang.instrument包来完成。

java.lang.instrument

由于存在着大量对Java字节代码进行修改的需求，JDK5引入了java.lang.instrument包并在JDK6中得到了进一步的增强。

基本的思路是在JVM启动的时候添加一些代理（agent）。

每个代理是一个jar包，其清单（manifest）文件中会指定一个代理类。

这个类会包含一个premain方法。

JVM在启动的时候会首先执行代理类的premain方法，再执行Java程序本身的main方法。

在premain方法中就可以对程序本身的字节代码进行修改。

JDK6中还允许在JVM启动之后动态添加代理。

java.lang.instrument包支持两种修改的场景，一种是重定义一个Java类，即完全替换一个Java类的字节代码；另外一种是转换已有的Java类，相当于前面提到的类字节代码增强。

还是以前面提到的输出方法执行日志的场景为例，首先需要实现java.lang.instrument.ClassFileTransformer接口来完成对已有Java类的转换。

staticclassMethodEntryTransformerimplementsClassFileTransformer{

publicbyte[]transform（ClassLoaderloader,StringclassName,

Class

>classBeingRedefined,?

ProtectionDomainprotectionDomain,byte[]classfileBuffer）

throws IllegalClassFormatException{

try{

ClassReadercr=newClassReader（classfileBuffer）;

ClassNodecn=newClassNode（）;

//省略使用ASM进行字节代码转换的代码

ClassWritercw=newClassWriter（0）;

cn.accept（cw）;

returncw.toByteArray（）;

}catch（Exceptione）{

returnnull;

}

有了这个转换类之后，就可以在代理的premain方法中使用它。

publicstaticvoidpremain（Stringargs,Instrumentationinst）{

inst.addTransformer（newMethodEntryTransformer（））;

}

把该代理类打成一个jar包，并在jar包的清单文件中通过Premain-Class声明代理类的名称。

运行Java程序的时候，添加JVM启动参数-javaagent:

myagent.jar。

这样的话，JVM会在加载Java类的字节代码之前，完成相关的转换操作。

总结

操纵Java字节代码是一件很有趣的事情。

通过它，可以很容易的对二进制分发的Java程序进行修改，非常适合于性能分析、调试跟踪和日志记录等任务。

另外一个非常重要的作用是把开发人员从繁琐的Java语法中解放出来。

开发人员应该只需要负责编写与业务逻辑相关的重要代码。

对于那些只是因为语法要求而添加的，或是模式固定的代码，完全可以将其字节代码动态生成出来。

字节代码增强和源代码生成是不同的概念。

源代码生成之后，就已经成为了程序的一部分，开发人员需要去维护它：

要么手工修改生成出来的源代码，要么重新生成。

而字节代码的增强过程，对于开发人员是完全透明的。

妥善使用Java字节代码的操纵技术，可以更好的解决某一类开发问题。

参考资料

∙Java字节代码格式

∙Java6.0CompilerAPI

∙深入探讨Java类加载器

二、Java深度历险

（二）——Java类的加载、链接和初始化

在上一篇文章中介绍了Java字节代码的操纵，其中提到了利用Java类加载器来加载修改过后的字节代码并在JVM上执行。

本文接着上一篇的话题，讨论Java类的加载、链接和初始化。

Java字节代码的表现形式是字节数组（byte[]），而Java类在JVM中的表现形式是java.lang.Class类的对象。

一个Java类从字节代码到能够在JVM中被使用，需要经过加载、链接和初始化这三个步骤。

这三个步骤中，对开发人员直接可见的是Java类的加载，通过使用Java类加载器（classloader）可以在运行时刻动态的加载一个Java类；而链接和初始化则是在使用Java类之前会发生的动作。

本文会详细介绍Java类的加载、链接和初始化的过程。