java 类加载器有几种_Java的类加载器(ClassLoader)简介

最新推荐文章于 2024-05-28 13:54:52 发布

傲世少年

最新推荐文章于 2024-05-28 13:54:52 发布

阅读量1.7k

点赞数 2

文章标签： java 类加载器有几种

本文链接：https://blog.csdn.net/weixin_29619665/article/details/115043459

版权

Java的类加载器(ClassLoader)简介

ClassLoader是Java的类加载器，用于把class文件加载到JVM中，下面大概了解一下Java类加载器的概况。

一，java提供的加载器

Java提供了三个ClassLoader：

1，BootstrapClassLoader

用于加载JAVA核心类库，也就是环境变量的%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar等。

在JVM启动时加入-Xbootclasspath参数，可以把对应路径也加载到Bootstrap的路径列表中来，这个参数有两种用法：

1)，-Xbootclasspath/a:{人工指定路径}，把对应路径加载到Bootstrap默认路径后面，也就是说，如果有class重复，以Bootstrap默认路径下的类为准(因为是按照路径列表顺序加载的)，举例：java -Xbootclasspath/a:D:\test\Test.jar

2)，-Xbootclasspath/p: {人工指定路径}，把对应路径加载到Bootstrap默认路径后面，也就是说，如果有class重复，以指定路径下的类为准，举例：java -Xbootclasspath/p:D:\test\Test.jar

2，Extention ClassLoader

扩展类加载器，加载环境变量%JRE_HOME%\lib\ext目录下的class文件

这个加载器也可以在JVM启动时使用参数改变加载的行为，参数是-D java.ext.dirs=，作用是替换Java扩展类加载器所加载的文件目录。

注意，该参数是替换而不是追加，因为这个加载器的加载路径只有一个，也就是说，%JRE_HOME%\lib\ext是扩展类加载器的默认路径，如果我们在启动时使用-Djava.ext.dirs=d:/test，那么java就不再加载%JRE_HOME%\lib\ext路径下的文件。

3，AppclassLoader

加载classpath中的class类，通过在JVM启动命令中的-classpath参数指定路径，可以指定绝对路径、相对路径、环境变量等，举例：java –classpath %CLASSPATH%

二，各种加载器之间的关系

从加载关系来说：1，BootstrapClassLoader是Extention ClassLoader的父加载器。

2，ExtentionClassLoader是AppclassLoader的父加载器。

注意，这里的父加载器并不是java语言里的父类，只是逻辑上的。

从Java语言的角度来说：1，ExtentionClassLoader对应的java类是ExtClassLoader，他的父类是java.net.URLClassLoader。

2，AppclassLoader对应的java类是AppClassLoader，他的父类也是java.net.URLClassLoader，没错，和ExtClassLoader一样。

3，BootstrapClassLoader是C++编写的，压根没有对应的java类，当然也成不了别人的父类。

ClassLoader类有getParent()方法，可以得到父加载器，一个加载器的父加载器是在他初始化的时候指定的。

AppclassLoader用getParent()方法得到的是ExtClassLoader。

ExtClassLoader用getParent()方法得到的是null。

如果我们自定义一个加载器，往往要继承ClassLoader类，此时默认的父加载器是AppClassLoader。

三，加载器的加载顺序

加载器在JVM启动时的加载顺序是：1，BootstrapClassLoader

2，ExtentionClassLoader

3，AppclassLoader

关于这个加载顺序可以参考sun.misc.Launcher类，这个类在JVM启动时初始化了各个加载器，代码如下：/**

*This class is used by the system to launch the main application.

Launcher */

public class Launcher {

private static URLStreamHandlerFactory factory = new Factory();

private static Launcher launcher = new Launcher();

private static String bootClassPath =

System.getProperty("sun.boot.class.path");

public static Launcher getLauncher() {

return launcher;

}

private ClassLoader loader;

public Launcher() {

// Create the extension class loader

ClassLoader extcl;

try {

extcl = ExtClassLoader.getExtClassLoader();

} catch (IOException e) {

throw new InternalError(

"Could not createextension class loader", e);

}

// Now create the class loader to use to launch the application

try {

loader = AppClassLoader.getAppClassLoader(extcl);

} catch (IOException e) {

throw new InternalError(

"Could not create applicationclass loader", e);

}

// Also set the context class loader for the primordial thread.

Thread.currentThread().setContextClassLoader(loader);

// Finally, install a security manager if requested

String s = System.getProperty("java.security.manager");

if (s != null) {

SecurityManager sm = null;

if ("".equals(s) || "default".equals(s)) {

sm = newjava.lang.SecurityManager();

} else {

try {

sm =(SecurityManager)loader.loadClass(s).newInstance();

} catch (IllegalAccessExceptione) {

} catch (InstantiationExceptione) {

} catch (ClassNotFoundExceptione) {

} catch (ClassCastException e){

}

if (sm != null) {

System.setSecurityManager(sm);

} else {

throw new InternalError(

"Could not createSecurityManager: " + s);

}

……后面还有很多

}

可以看到，在Launcher的无参构造中，先是初始化了ExtClassLoader，然后初始化AppClassLoader，其实Bootstrap ClassLoader在这之前就加载完了，类中有这样一个属性：private static String bootClassPath =

System.getProperty("sun.boot.class.path");

这个就是Bootstrap ClassLoader类加载的路径，可以自己写一段代码看看这个路径是什么：System.out.println(System.getProperty("sun.boot.class.path"));

输出结果：C:\ProgramFiles\Java\jre7\lib\resources.jar;

C:\Program Files\Java\jre7\lib\rt.jar;

C:\ProgramFiles\Java\jre7\lib\sunrsasign.jar;

C:\Program Files\Java\jre7\lib\jsse.jar;

C:\Program Files\Java\jre7\lib\jce.jar;

C:\ProgramFiles\Java\jre7\lib\charsets.jar;

C:\Program Files\Java\jre7\lib\jfr.jar;

C:\Program Files\Java\jre7\classes

实际输出结果是没有换行的，我在分号处加了换行。

Launcher类中加载的ExtClassLoader和AppClassLoader这两个类的定义也是在Launcher中，源码也可以看一下

ExtClassLoader类的定义：/*

* The class loader used for loading installed extensions.

static class ExtClassLoader extends URLClassLoader {

static {

ClassLoader.registerAsParallelCapable();

}

/**

* create an ExtClassLoader. The ExtClassLoader is created

* within a context that limits which files it can read

public static ExtClassLoader getExtClassLoader() throws IOException

{

final File[] dirs = getExtDirs();

try {

// Prior implementations of this doPrivileged() block supplied

// aa synthesized ACC via a call to the private method

// ExtClassLoader.getContext().

return AccessController.doPrivileged(

new PrivilegedExceptionAction() {

public ExtClassLoader run() throws IOException {

int len = dirs.length;

for (int i = 0; i

MetaIndex.registerDirectory(dirs[i]);

}

return new ExtClassLoader(dirs);

}

});

} catch (java.security.PrivilegedActionException e) {

throw (IOException) e.getException();

}

void addExtURL(URL url) {

super.addURL(url);

}

* Creates a new ExtClassLoader for the specified directories.

public ExtClassLoader(File[] dirs) throws IOException {

super(getExtURLs(dirs), null, factory);

SharedSecrets.getJavaNetAccess().

getURLClassPath(this).initLookupCache(this);

}

private static File[] getExtDirs() {

String s = System.getProperty("java.ext.dirs");

File[] dirs;

if (s != null) {

StringTokenizer st =

new StringTokenizer(s, File.pathSeparator);

int count = st.countTokens();

dirs = new File[count];

for (int i = 0; i

dirs[i] = new File(st.nextToken());

}

} else {

dirs = new File[0];

}

return dirs;

}

private static URL[] getExtURLs(File[] dirs) throws IOException {

Vector urls = new Vector();

for (int i = 0; i

String[] files = dirs[i].list();

if (files != null) {

for (int j = 0; j

if (!files[j].equals("meta-index")) {

File f = new File(dirs[i], files[j]);

urls.add(getFileURL(f));

}

URL[] ua = new URL[urls.size()];

urls.copyInto(ua);

return ua;

}

* Searches the installed extension directories for the specified

* library name. For each extension directory, we first look for

* the native library in the subdirectory whose name is the value

* of the system property os.arch. Failing that, we

* look in the extension directory itself.

public String findLibrary(String name) {

name = System.mapLibraryName(name);

URL[] urls = super.getURLs();

File prevDir = null;

for (int i = 0; i

// Get the ext directory from the URL

File dir = new File(urls[i].getPath()).getParentFile();

if (dir != null && !dir.equals(prevDir)) {

// Look in architecture-specific subdirectory first

// Read from the saved system properties to avoid deadlock

String arch = VM.getSavedProperty("os.arch");

if (arch != null) {

File file = new File(new File(dir, arch), name);

if (file.exists()) {

return file.getAbsolutePath();

}

// Then check the extension directory

File file = new File(dir, name);

if (file.exists()) {

return file.getAbsolutePath();

}

prevDir = dir;

}

return null;

}

private static AccessControlContext getContext(File[] dirs)

throws IOException

{

PathPermissions perms =

new PathPermissions(dirs);

ProtectionDomain domain = new ProtectionDomain(

new CodeSource(perms.getCodeBase(),

(java.security.cert.Certificate[]) null),

perms);

AccessControlContext acc =

new AccessControlContext(new ProtectionDomain[] { domain });

return acc;

}

可以看到里面的getExtDirs()方法中，获得了java.ext.dirs参数的内容，这个地址也可以打印出来看看：System.out.println(System.getProperty("java.ext.dirs"));

输出的结果：C:\Program Files\Java\jre7\lib\ext;

C:\Windows\Sun\Java\lib\ext

AppClassLoader类的定义：/**

* The class loader used for loading from java.class.path.

* runs in a restricted security context.

static class AppClassLoader extends URLClassLoader {

static {

ClassLoader.registerAsParallelCapable();

}

public static ClassLoader getAppClassLoader(final ClassLoader extcl)

throws IOException

{

final String s = System.getProperty("java.class.path");

final File[] path = (s == null) ? new File[0] : getClassPath(s);

// Note: on bugid 4256530

// Prior implementations of this doPrivileged() block supplied

// a rather restrictive ACC via a call to the private method

// AppClassLoader.getContext(). This proved overly restrictive

// when loading classes. Specifically it prevent

// accessClassInPackage.sun.* grants from being honored.

return AccessController.doPrivileged(

new PrivilegedAction() {

public AppClassLoader run() {

URL[] urls =

(s == null) ? new URL[0] : pathToURLs(path);

return new AppClassLoader(urls, extcl);

}

});

}

final URLClassPath ucp;

* Creates a new AppClassLoader

AppClassLoader(URL[] urls, ClassLoader parent) {

super(urls, parent, factory);

ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

ucp.initLookupCache(this);

}

/**

* Override loadClass so we can checkPackageAccess.

public Class> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

int i = name.lastIndexOf('.');

if (i != -1) {

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

sm.checkPackageAccess(name.substring(0, i));

}

if (ucp.knownToNotExist(name)) {

// The class of the given name is not found in the parent

// class loader as well as its local URLClassPath.

// Check if this class has already been defined dynamically;

// if so, return the loaded class; otherwise, skip the parent

// delegation and findClass.

Class> c = findLoadedClass(name);

if (c != null) {

if (resolve) {

resolveClass(c);

}

return c;

}

throw new ClassNotFoundException(name);

}

return (super.loadClass(name, resolve));

}

/**

* allow any classes loaded from classpath to exit the VM.

protected PermissionCollection getPermissions(CodeSource codesource)

{

PermissionCollection perms = super.getPermissions(codesource);

perms.add(new RuntimePermission("exitVM"));

return perms;

}

/**

* This class loader supports dynamic additions to the class path

* at runtime.

* @see java.lang.instrument.Instrumentation#appendToSystemClassPathSearch

private void appendToClassPathForInstrumentation(String path) {

assert(Thread.holdsLock(this));

// addURL is a no-op if path already contains the URL

super.addURL( getFileURL(new File(path)) );

}

/**

* create a context that can read any directories (recursively)

* mentioned in the class path. In the case of a jar, it has to

* be the directory containing the jar, not just the jar, as jar

* files might refer to other jar files.

private static AccessControlContext getContext(File[] cp)

throws java.net.MalformedURLException

{

PathPermissions perms =

new PathPermissions(cp);

ProtectionDomain domain =

new ProtectionDomain(new CodeSource(perms.getCodeBase(),

(java.security.cert.Certificate[]) null),

perms);

AccessControlContext acc =

new AccessControlContext(new ProtectionDomain[] { domain });

return acc;

}

这个类的getAppClassLoader()方法中，获得了java.class.path参数，可以打印出来：System.out.println(System.getProperty("java.class.path"));

输出结果：D:\workspace\test\bin;

C:\Users\lk\Downloads\asm-4.2.jar;

C:\Users\lk\Desktop\dubbo-2.8.3.2.jar;

C:\Users\lk\Downloads\cglib-2.2.jar;

C:\Users\lk\Downloads\netty-3.2.5.Final.jar

都是我在classpath里面配的目录和jar包。

四，查找class和双亲委托

java的加载器在查找或加载class时，需要确认这个class是否已经被加载了，如果已经被加载了自己就不再重复加载。

类加载器查找class的方式叫做双亲委托模式，基本方法是：1，自己先查缓存，验证类是否已加载，如果缓存中没有则向上委托父加载器查询。

2，父加载器接到委托也是查自己的缓存，如果没有再向上委托。

3，直到最顶级的BootstrapClassLoader也没在缓存中找到该类，则Bootstrap ClassLoader从他自己的加载路径中查找该类，如果找不到则返回下一级加载器。

4，下一级加载器也从他自己的加载路径中查找该类，如果找不到则返回下一级加载器，直到返回最开始的加载器。

简单来说，就是从下往上查缓存，然后从上往下扫描路径。如果在其中任何一步发现已经加载了该类，都会立刻返回，不再进行后面的查找。

画个图来表示这个流程的话，应该是这样的：

图1

查找的顺序就是图上从①到⑥

五，自定义ClassLoader

自定义的ClassLoader类，一般需要满足以下条件：1，继承java.lang.ClassLoader类，或者继承他的子类比如java.net.URLClassLoader。

2，重写findClass()方法或者重写loadClass()方法，findClass()会在调用加载器的loadClass()方法时调用。

3，在findClass()中使用defineClass()方法，这个方法不需要自己实现，是父类ClassLoader的方法。这个方法的参数在后面的例子中再详解。

使用自定义的ClassLoader类，一般需要以下步骤：1，初始化ClassLoader。

2，调用ClassLoader的loadClass()方法加载目标class，参数是String类型，内容包括目标类的包名和类名，不包括”.class”，这个方法是父类ClassLoader的方法，不需要自己定义。在调用这个方法时，就会调用自己在加载器中写的findClass()方法。

3，使用加载好的类的class.newInstance()就可以得到目标类的对象。

下面举个例子

首先是目标Class，简单写一个：package classloader;

public class Test {

public void hello() {

System.out.println("hello world");

}

下面是重点，自定义ClassLoader：package classloader;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

public class MyClassLoader extends ClassLoader {

private String myClassPath;

public MyClassLoader(String path) {

myClassPath = path;

}

@Override

protected Class> findClass(String name) throws ClassNotFoundException {

File file = new File(myClassPath, name+".class");

try {

FileInputStream is = new FileInputStream(file);

ByteArrayOutputStream bos = new ByteArrayOutputStream();

int len = 0;

try {

while ((len = is.read()) != -1) {

bos.write(len);

}

} catch (IOException e) {

e.printStackTrace();

}

byte[] data = bos.toByteArray();

is.close();

bos.close();

return defineClass(name, data, 0, data.length, null);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return super.findClass(name);

}

自定义的ClassLoader可以继承ClassLoader类，并重写findClass(String name)方法，这个方法中的内容，基本就是为了最后的调用defineClass()方法做准备。

defineClass()方法在父类中有多个重载的方法，他们最终调用的是一个5个参数的defineClass()方法，这5个参数分别是：1，文件名(带”.class”)

2，class文件内容的二进制数组

3，二进制数组中表示class数据开始的下标

4，class二进制数据的长度

5，protectionDomain，标识了类的封装域的权限信息，可以没有(本例就没有)，详解可参考JDK文档。

从这个方法的定义来看，似乎是可以支持一长串二进制数组，开发者只需要指定数组中代表目标Class的开始下标和长度，java就可以从中截取出目标Class的信息并装载，但我没想到有什么场景可以用到这个设定。(本例中二进制数组来源于完整的class文件，所以开始下标是0，并且java需要读取整个数组)

最后写一个类使用一下我们自定义的加载器：package classloader;

import java.lang.reflect.Method;

public class ClassLoaderTest {

public static void main(String[] args) {

try {

// 初始化加载器

MyClassLoader myLoader = new MyClassLoader("D:\\workspace\\test\\bin");

// 加载class

Class c = myLoader.loadClass("classloader.Test");

// 验证

Object obj = c.newInstance();

Method method = c.getDeclaredMethod("hello", null);

method.invoke(obj, null);

} catch (Exception e) {

e.printStackTrace();

}

运行这个类，控制台输出hello world，说明目标类加载成功。

loadClass()方法在是在ClassLoader类中定义的，方法代码如下：protected Class> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

synchronized (getClassLoadingLock(name)) {

// First, check if the class has already been loaded

Class> c = findLoadedClass(name);

if (c == null) {

long t0 = System.nanoTime();

try {

if (parent != null) {

c = parent.loadClass(name, false);

} else {

c = findBootstrapClassOrNull(name);

}

} catch (ClassNotFoundException e) {

// ClassNotFoundException thrown if class not found

// from the non-null parent class loader

}

if (c == null) {

// If still not found, then invoke findClass in order

// to find the class.

long t1 = System.nanoTime();

c = findClass(name);

// this is the defining class loader; record the stats

sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);

sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

sun.misc.PerfCounter.getFindClasses().increment();

}

if (resolve) {

resolveClass(c);

}

return c;

}

可以看到，方法首先检查这个类有没有被加载，如果没有被加载，则先去父加载器加载。如果没有父加载器，则使用Bootstrap ClassLoader加载。如果父加载器没能加载这个类，则调用findClass()方法加载。

六，重新加载class，热替换

首先是基础知识：1，java目前没有专门的API，用来卸载JVM中加载的类。

2，要卸载JVM中的类，需要该类的对象都被回收，加载该类的ClassLoader也被回收，使用该类的线程结束等条件，比较严格。

3，在java中，不同的ClassLoader可以加载同一个类，即使class文件是同一个也可以被加载。但是同一个ClassLoader不能重复加载一个类，重复加载会报错。

总的来说，在不停服务的情况下热替换class不是很靠谱，现在的java版本也根本没打算让开发者这么做。

虽然可以通过新建ClassLoader实例的方法来改变新加载的Class内容，但之前ClassLoader加载的类和对象不会被修改，什么时候能被GC回收也很不可控，玩玩可以，线上环境慎用，后续的坑很多。

还是老老实实重启比较靠谱。

不过我们依然可以做出一个山寨版的热替换功能，方案就是之前提到的新建ClassLoader实例。

首先我准备了两个目标类，分别编译成class文件

第一个：package classloader;

public class Test {

public void hello() {

System.out.println("hello world");

// System.out.println("Are you OK");

}

第二个：package classloader;

public class Test {

public void hello() {

// System.out.println("hello world");

System.out.println("Are you OK");

}

我把第二个类编译出的class文件单独保存，将来要替换第一个class。

然后是自己定义的ClassLoader类：package classloader;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

public class MyClassLoader2 extends ClassLoader {

private String myClassPath;

public MyClassLoader2(String path) {

myClassPath = path;

}

public Class> loadMyClass(String name){

System.out.println("重新加载:"+name);

File file = new File(myClassPath+File.separator+name.substring(0,name.indexOf(".")), name.substring(name.indexOf(".")+1,name.length())+".class");

if(!file.exists()){

return null;

}

try {

FileInputStream is = new FileInputStream(file);

ByteArrayOutputStream bos = new ByteArrayOutputStream();

int len = 0;

try {

while ((len = is.read()) != -1) {

bos.write(len);

}

} catch (IOException e) {

e.printStackTrace();

}

byte[] data = bos.toByteArray();

is.close();

bos.close();

return defineClass(name, data, 0, data.length, null);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

@Override

public Class> loadClass(String name) throws ClassNotFoundException {

System.out.println("loadClass():"+name);

Class> cls = null;

if (cls == null){

cls=loadMyClass(name);

}

if(cls==null){

cls = getSystemClassLoader().loadClass(name);

System.out.println("getSystemClassLoader():"+ getSystemClassLoader());

}

if (cls == null){

throw new ClassNotFoundException(name);

}

return cls;

}

这个自定义的加载器重写了ClassLoader类的loadClass()方法。注意，对于目标路径下的类，每次都会重新加载，没有判断重复。

在classLoader()方法中先过自己的加载器，自己的加载器必须在特定目录中存在class文件才可以加载，否则就用系统定义的加载器加载，因为重写loaderClass()方法之后，目标类所有的相关类也会用这个方法加载(比如目标类的父类java.lang.Object)。

最后是测试类：package classloader;

import java.lang.reflect.Method;

public class ClassLoaderTest {

public static void main(String[] args) {

// loadClass();

loadClass2();

}

public static void loadClass(){

try {

// 初始化加载器

MyClassLoader myLoader = new MyClassLoader("D:\\workspace\\test\\bin");

// 加载class

Class c = myLoader.loadClass("classloader.Test");

// 验证

Object obj = c.newInstance();

Method method = c.getDeclaredMethod("hello", null);

method.invoke(obj, null);

} catch (Exception e) {

e.printStackTrace();

}

public static void loadClass2(){

try {

while(true){

// 初始化加载器

MyClassLoader2 myLoader = new MyClassLoader2("D:\\workspace\\test\\bin");

// 加载class

Class c = myLoader.loadClass("classloader.Test");

System.out.println(c.getClassLoader());

System.out.println(Class.forName("classloader.Test").getClassLoader().toString());

System.out.println();

// 验证

Object obj = c.newInstance();

Method method = c.getDeclaredMethod("hello", null);

method.invoke(obj, null);

Thread.sleep(1000);

}

} catch (Exception e) {

e.printStackTrace();

}

测试类实际上是每隔一秒钟新建一个ClassLoader的实例，并用新ClassLoader加载目标类。

在程序启动之前，编译路径下是第一个目标类的Class文件(hello world)，在程序启动之后把第二个Class文件(Are you OK)替换第一个，新加载的目标类就可以调用第二个目标类的方法。

运行后输出的结果如下：loadClass():classloader.Test

重新加载:classloader.Test

loadClass():java.lang.Object

重新加载:java.lang.Object