深入浅出Java类加载机制，java软件工程师面试题目

最新推荐文章于 2024-09-18 13:50:15 发布

m0_57540655

最新推荐文章于 2024-09-18 13:50:15 发布

阅读量1k

点赞数 28

分类专栏： 2024年程序员学习文章标签： java 面试 python

本文链接：https://blog.csdn.net/m0_57540655/article/details/136968154

版权

2024年程序员学习专栏收录该内容

235 篇文章 0 订阅

订阅专栏

c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
//如果找不到类，则抛出ClassNotFoundException
}
//第二次检查Class是否被加载–双短检查加锁机制保障Class的唯一性
if (c == null) {
long t1 = System.nanoTime();
//如果仍然找不到，请按顺序调用findClass顺序查找当前Class
c = findClass(name);
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
//是否需要在Class加载后调用class的初始化代码块
if (resolve) {
resolveClass©;
}
return c;
}
}

从上述的源码以及我添加的注释中，我们大概明白了，在loadClass方法执行过程中，还会传递一个resolve标示符，此标示符和forName的initialize参数是一样的，用来判断是否在Class加载后进行初始化代码块的操作，但是我们从上面的方法明显看到，默认传递的值为false，即仅仅加载Class类，并不去调用类的初始化代码块部分，两者的区别至此已经真相大白

自定义ClassLoader

前面我们也多次提到过自定义ClassLoader，此技术也是tomcat、OSGI等实现应用隔离、动态模块加载的基础，那么如何自定义呢？一般来说，我们需要继承类ClassLoader，重写其方法findClass即可，现在我们来看一个开发中常遇到的问题：我们在开发过程中经常遇到本地运行程序的情况，往往有些时候会遇到服务端的jar与我们自定义的代码中有部分类名一致的时候，因为系统加载的时候默认优先显示服务端的jar中的calss，而不是本地的class，那么究其原因，就是jvm默认使用AppClassLoader加载classpath中的类，那么我们能否重写AppClassLoader来实现优先显示本地实现的类，再去加载服务端的jar中呢？说做就做，我们参考系统默认实现的URLClassLoader 类的代码来写一个简单的功能实现，代码如下:

public class MyClassLoader extends URLClassLoader {
public URLClassPath ucp;
private Map<String, Class<?>> cache = new HashMap();
private static final Method defineClassNoVerifyMethod;

static String[] paths = System.getProperty(“java.class.path”).split(“;”);

static URL[] urls = new URL[paths.length];

//初始化每一个类的URL
static{
for(int i=0; i<urls.length; i++){
try {
urls[i] = new URL(“file:”+paths[paths.length-1-i]);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
System.out.println(Arrays.toString(urls));

SharedSecrets.setJavaNetAccess(new JavaNetAccess() {
public URLClassPath getURLClassPath(URLClassLoader u) {
return ((MyClassLoader)u).ucp;
}
@Override
public String getOriginalHostName(InetAddress inetAddress) {
return null;
}
} );

Method m;
try {
m = SecureClassLoader.class.getDeclaredMethod(“defineClassNoVerify”,
new Class[] { String.class, ByteBuffer.class, CodeSource.class });
m.setAccessible(true);
} catch (NoSuchMethodException nsme) {
m = null;
}
defineClassNoVerifyMethod = m;
}

public MyClassLoader(URL[] urls) {
super(MyClassLoader.urls);
this.ucp = new URLClassPath(MyClassLoader.urls);
}

public MyClassLoader(ClassLoader parent) {
super(MyClassLoader.urls, parent);
this.ucp = new URLClassPath(MyClassLoader.urls);
}

//重写loadClass，实现自定义的类加载
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException{
Class c = null;
if (name.contains(“hadoop”)) {
c = (Class)this.cache.get(name);
if (c == null) {
c = findClass(name);
this.cache.put(name, c);
}
} else {
c = loadClass(name, false);
}
return c;
}

protected Class<?> findClass(String name) throws ClassNotFoundException {
//替换路径查找对应的类资源
String path = name.replace(‘.’, ‘/’).concat(“.class”);
Resource res = this.ucp.getResource(path);
if (res != null) {
try {
return defineClass(name, res, true);
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
}
throw new ClassNotFoundException(name);
}

private Class<?> defineClass(String name, Resource res, boolean verify) throws IOException {
int i = name.lastIndexOf(‘.’);
URL url = res.getCodeSourceURL();
if (i != -1) {
//根据class最后一个.的下标截取包名
String pkgname = name.substring(0, i);
Package pkg = getPackage(pkgname);
Manifest man = res.getManifest();
if (pkg != null){
//校验当前包名是否为私密包名
if (pkg.isSealed()){
if (!pkg.isSealed(url)){
throw new SecurityException(
“sealing violation: package " + pkgname +
" is sealed”);
}
}
else if ((man != null) && (isSealed(pkgname, man))) {
throw new SecurityException(
"sealing violation: can’t seal package " +
pkgname + “: already loaded”);
}
}
//Manifest不为null
else if (man != null)
definePackage(pkgname, man, url);
else {
definePackage(pkgname, null, null, null, null, null, null,
null);
}
}

ByteBuffer bb = res.getByteBuffer();
byte[] bytes = bb == null ? res.getBytes() : null;
CodeSigner[] signers = res.getCodeSigners();
CodeSource cs = new CodeSource(url, signers);

if (!verify){
Object[] args = { name, bb == null ? ByteBuffer.wrap(bytes) : bb,cs };
try {
return (Class)defineClassNoVerifyMethod.invoke(this, args);
}
catch (IllegalAccessException localIllegalAccessException) {}
catch (InvocationTargetException ite) {
Throwable te = ite.getTargetException();
if ((te instanceof LinkageError))
throw ((LinkageError)te);
if ((te instanceof RuntimeException)) {
throw ((RuntimeException)te);
}
throw new RuntimeException("Error defining class " + name,
te);
}
}
return defineClass(name, bytes, 0, bytes.length, cs);
}