ClassLoader类
loadClass(String name, boolean resolve):根据指定的二进制名称来加载类,该方法为ClassLoader的入口点,系统就是调用ClassLoader的该方法来获取指定类对应的Class对象。
findClass(String name):根据二进制名称来查找类。
如果需要实现自定义的ClassLoader,可以通过重写以上两个方法来实现,优先推荐重写findClass(String name)方法。因为重写 findClassO方法可以避免覆盖默认类加载器的父类委托 和缓冲机制两种策略 ; 如果重写 loadClassO方法 ,则实现逻辑更为复杂。
loadClass()方法的执行步骤如下 :
1、用 findLoadedClass(String) 来检查是否己经加载类 , 如果已经加载则直接返回 。 在父类加载器上调用
2、 loadClassO方法。 如果父类加载器为 null ,则使用根类加载器来加载 。
3、 调用 findClass(String)方法查找类。
ClassLoader 里还包含如下一些普通方法:
1、 findSystemClass(String name): 从本地文件系统装入文件 。 它在本地文件系统中寻找类文件,如果存在,就使用 defineClassO方法将原始字节转换成 Class 对象,以将该文件转换成类。
2、static getSystemClassLoaderO: 这是一个静态方法,用于返回系统类加载器
3、getParent(): 获取该类加载器的父类加载器 。
4、resolveClass(Class<?> c): 链接指定的类 。 类加载器可以使用此方法来链接类 c 。
5、findLoadedClass(String name): 如果此 Java 虚拟机己加载了名为 name 的类,则直接返回该类对应的Class 实例,否则返回 null。该方法是 Java 类加载缓存机制的体现。
源码展示:
import java.io.*;
import java.lang.reflect.*;
public class CompileClassLoader extends ClassLoader
{
private byte[] getBytes(String filename)
throws IOException
{
File file = new File(filename);
long len = file.length();
byte[] raw = new byte[(int)len];
try(
FileInputStream fin = new FileInputStream(file))
{
int r = fin.read(raw);
if(r != len)
throw new IOException("无法读取全部文件"
+ r + " != " + len);
return raw;
}
}
private boolean compile(String javaFile)
throws IOException
{
System.out.println("CompileClassLoader:正在编译 "
+ javaFile + "...");
// 调用系统的javac命令
Process p = Runtime.getRuntime().exec("javac " + javaFile);
try
{
// 其他线程等待这个线程完成
p.waitFor();
}
catch(InterruptedException ie)
{
System.out.println(ie);
}
int ret = p.exitValue();
return ret == 0;
}
protected Class<?> findClass(String name)
throws ClassNotFoundException
{
Class clazz = null;
String fileStub = name.replace("." , "/");
String javaFilename = fileStub + ".java";
String classFilename = fileStub + ".class";
File javaFile = new File(javaFilename);
File classFile = new File(classFilename);
if(javaFile.exists() && (!classFile.exists()
|| javaFile.lastModified() > classFile.lastModified()))
{
try
{
if(!compile(javaFilename) || !classFile.exists())
{
throw new ClassNotFoundException(
"ClassNotFoundExcetpion:" + javaFilename);
}
}
catch (IOException ex)
{
ex.printStackTrace();
}
}
if (classFile.exists())
{
try
{
byte[] raw = getBytes(classFilename);
clazz = defineClass(name,raw,0,raw.length);
}
catch(IOException ie)
{
ie.printStackTrace();
}
}
if(clazz == null)
{
throw new ClassNotFoundException(name);
}
return clazz;
}
public static void main(String[] args) throws Exception
{
if (args.length < 1)
{
System.out.println("缺少目标类,请按如下格式运行java源文件:");
System.out.println("java CompileClassLoader ClassName");
}
String progClass = args[0];
String[] progArgs = new String[args.length-1];
System.arraycopy(args , 1 , progArgs
, 0 , progArgs.length);
CompileClassLoader ccl = new CompileClassLoader();
Class<?> clazz = ccl.loadClass(progClass);
Method main = clazz.getMethod("main" , (new String[0]).getClass());
Object[] argsArray = {progArgs};
main.invoke(null,argsArray);
}
}
URLClassLoader类
Java为ClassLoader提供了一个URLClassLoader实现类,该类也是系统类加载器和扩展类加载器的父类(此处是父类,而不是父类加载器,这里是类与类之间的继承关系),URLClassLoader功能比较强大,它既可以从本地文件系统获取二进制文件来加载类,也可以从远程主机获取二进制文件来加载类。
应用程序中可以直接使用URLClassLoader来加载类,URLClassLoader类提供了如下两个构造器:
URLClassLoader(URL[] urls):使用默认的父类加载器创建一个ClassLoader对象,该对象将从urls所指定的系列路径来查询、并加载类。
URLClassLoader(URL[] urls, ClassLoader parent):使用指定的父类加载器创建一个ClassLoader对象,其他功能前一个构造器相同。
类加载器
java虚拟机的类加载器一共有三种,分别是启动类加载器(引导类加载器(根类加载器):Bootstrap ClassLoader)
,扩展类加载器(Extension ClassLoader)
,应用程序类加载器(系统类加载器 AppClassLoader)
。还有就是在java程序中,我们可以自行定义一个类加载器,这个类加载器被划分为自定义类加载器。如图:
实例代码:
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
public class ClassLoaderTest {
public static void main(String[] args) {
// 获取系统类加载器
ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
System.out.println("系统类加载器:"+systemLoader); // sun.misc.Launcher$AppClassLoader@18b4aac2
// 获取系统类加载器的上层,扩展类加载器
ClassLoader parent = systemLoader.getParent();
System.out.println(parent); // sun.misc.Launcher$ExtClassLoader@61bbe9ba
Enumeration<URL> eml = null;
try {
eml = systemLoader.getResources("");
} catch (IOException e) {
e.printStackTrace();
}
while(eml.hasMoreElements()){
System.out.println(eml.nextElement()); // 代码路径/java/AnnotationAndReflection/target/classes/
}
//获取系统类加载器的父类加载器,得到扩展类加载器
ClassLoader extensionLader = systemLoader.getParent();
System.out.println( " 扩展类加载器 : " + extensionLader);// sun.misc.Launcher$ExtClassLoader@61bbe9ba
System.out.println(" 扩展类加载器的加载路径: "
+ System.getProperty (" java.ext.dirs " ));
System.out.println("扩展类加载器的 parent: "
+ extensionLader . getParent());
}
}
结果: 系统类加载器的加载路径是程序运行的当前路径,扩展类加载器的加载路径是 null,扩展类加载器的父加载器是 null,并不是根类加载器。这是 因为根类加载器并没有继承 ClassLoader 抽象类 ,所以扩展类加载器的getParent()方法返回 null 。但实际上,扩展类加载器的父类加载器是根类加载器,只是根类加载器并不是 Java 实现的,而且由于程序通常无须访问根类加载器,因此访问扩展类加载器的父类加载器时返回 null 。
启动类加载器
- 这个类加载器使用C/C++实现的,内嵌在jvm的内部(一般的类加载器访问不到)
- 它用来加载java的核心类库,(比如JAVA_HOME/jre/lib/resources.jar或者是sun.boot.class.path路径下的内容)用于提供jvm需要的类
- 不继承自java.lang.ClassLoader,没有父类加载器。(它最大)
- 加载扩展类加载器和应用程序类加载器,并且为他们指定父类加载器。
- 为了安全考虑,BootstrapClassLoader只是会加载sun、javax、java等开头的类。
- 启动类加载器是无法被Java程序直接引用的。
扩展类加载器
- java 语言编写的,由sun.misc.Launcher$ExtClassLoader实现。
- 派生于ClassLoader类
- 父类加载器为启动类加载器
- 从java.ext.dirs系统属性所指定的目录中加载类库,或者是从jdk安装的目录jre/lib/ext子目录的(扩展类库)下加载类库,如果用户创建jar文件放在此目录下也会自动有扩展类加载器加载。
应用程序类加载器
- java 语言编写,由sun.misc.Launcher$AppClassLoader实现
- 派生于ClassLoader类
- 父类加载器为扩展类加载器
- 它负责加载环境变量classpath或是系统属性,java.class.path路径下的类库。
- 该类是程序中默认的类加载器。java的应用的类都是由该加载完成。
- 通过ClassLoader.getSystemClassLoader()可以获取该类加载器。
- 开发者可以直接使用该类加载器,如果应用程序中没有自定义过自己的类加载器,一般情况下这个就是程序中默认的类加载器。
自定义类的加载器
在java程序开发的过程中,类的加载基本上都是由上述三类加载器加载完成,在必要的时候可以自己定义类加载器。
自定义类加载器可以实现一下几种常见的功能:
执行代码前自动验证数字签名
根据用户提供的密码解密代码,从而实现代码混淆器来避免反编译*.class文件
根据用户需求来动态地加载类
根据应用需求把其他数据以字节码的形式加载到应用中。
自定义类加载器好处:
1、隔离加载类
2、修改类加载的方式
3、扩展加载源
4、防止源码泄露
类加载器的数据来源
类的加载器加载的数据来源有以下几种:
1、从本地文件系统加载 class 文件,这是绝大部分示例程序的类加载方式 。
2、从 JAR 包加载 class 文件,jvm可以从 JAR 文件中 直接加载该 class 文件 。
3、通过网络加载class文件
4、把一个java的源文件动态编译并执行加载
5、从专有的数据库中提取class文件,比较少见。
6、从加密文件中获取,这是典型的防止class文件被反编译的措施。
7、由其他文件生成,典型的场景:jsp应用。
类加载器加载class的步骤
- 检测此 Class 是否载入过(即在缓存区中是否有此 Class ) ,如果有则直接进入第 8 步,否则接着执行第 2 步 。
- 如果父类加载器不存在( 如果没有父类加载器 ,则要么 parent 一定是根类加载器,要么本身就是根类加载器) ,则跳到第 4 步执行 :如果父类加载器存在 ,则接着执行第 3 步。
- 请求使用 父类加载器去载入目标类 ,如果成功载入则跳到第 8 步 , 否则接着执行第 5 步。
- 请求使用根类加载器来载入目标类,如果成功载入则跳到第 8 步 , 否则跳到第 7 步。
- 当前类加载器尝试寻找 Class 文件 ( 从与此 ClassLoader 相关的类路径中寻找),如果找到则执行第 6 步 , 如果找不到则跳到第 7 步。
- 从文件中载入 Class , 成功载入后跳到第 8 步。
- 抛出 ClassNotFoundException 异常。
- 返回对应的 java .lang.Class 对象。
其中 ,第 5 、6 步允许重写 ClassLoader的 findClassO方法来实现自己的载入策略 ,甚至重写 loadClass()方法来实现自己的载入过程 。
文章参考
- java全栈知识体系
- http://www.cnblogs.com/ityouknow/p/5603287.html
- http://blog.csdn.net/ns_code/article/details/17881581
- https://segmentfault.com/a/1190000005608960
- http://www.importnew.com/18548.html
- http://zyjustin9.iteye.com/blog/2092131
- http://www.codeceo.com/article/java-class-loader-learn.html