JVM第四天自定义类加载器及加载原理

Java的类加载器自从JDK1.2开始便引入了一条机制，叫做父类委托机制。也就是说，一个类需要被加载的时候， 
JVM先会调用他的父类加载器进行加载。如果父类加载器加载不了，再使用其子类进行加载。当然，这类所说的父类加 
载器，不一定他们之间是继承的关系，有可能仅仅是包装的关系。不能片面理解。 
Java之所以出现这条机制，因为是处于安全性考虑。害怕用户自己定义class文件然后自己写一个类加载器来加载 
原本应该是JVM自己加载的类。这样会是JVM虚拟机混乱或者说会影响到用户的安全。 

下面我们来自己实现一个类加载器，其中主要就是继承ClassLoader类

package com.bird.classLoad;


import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;


public class MyClassLoader extends ClassLoader {


private String name; // 类加载器的名字


private String path = "d://"; // 加载类的路径


private final String fileType = ".class"; // .class文件扩展名


public MyClassLoader(String name) {
super();// 让系统加载器成为该类的加载器的父类加载器


this.name = name;
}


public MyClassLoader(ClassLoader parent, String name) {
super(parent); // 显示指定该类加载器的父加载器
this.name = name;
}


@Override
public String toString() {
return this.name;
}


public String getPath() {
return path;
}


public void setPath(String path) {
this.path = path;
}

/**
* 读取class文件作为二进制流放入到byte数组中去
* @param name
* @return 
*/
private byte[] loadClassData(String name) {
InputStream in = null;
byte[] data = null;
ByteArrayOutputStream baos = null;


try {
name = name.replace(".", "\\");
in = new BufferedInputStream(new FileInputStream(new File(path
+ name + fileType)));
baos = new ByteArrayOutputStream();
int ch = 0;
while (-1 != (ch = in.read())) {
baos.write(ch);
}
data = baos.toByteArray();
} catch (Exception e) {


e.printStackTrace();
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return data;
}

/**
* JVM调用的加载器的方法
*/


@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] data = this.loadClassData(name);
return this.defineClass(name, data, 0, data.length);
}

public static void main(String[] args) throws Exception {
MyClassLoader loader1 = new MyClassLoader("loader1");
loader1.setPath("d://");
test(loader1);
}

public static void test(ClassLoader loader) throws Exception{
Class<?> clazz = loader.loadClass("com.bird.classLoad.Simple");
Object object = clazz.newInstance();
}

}

总结：

1. 自定义类加载器，第一需要继承ClassLoader类，第二重写findClass方法

2. 原理分析：

MyClassLoader loader1 = new MyClassLoader("loader1");
loader1.setPath("d://");
Class<?> clazz = loader1.loadClass("com.bird.classLoad.Simple");
Object object = clazz.newInstance();

此处调用父类的loadClass方法，ClassLoader会按照以下步骤执行（委托机制，安全考虑）

1，是否加载过，如果加载过，返回

2.  如果没有加载过，查找是否存在父加载器，存在，则在父加载器寻找，

3.  不存在父加载器，直接去bootstrpt寻找

4，还是没有找到则调用findClass，方法，

如下代码：

    protected synchronized Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
    {
// First, check if the class has already been loaded
Class c = findLoadedClass(name);
if (c == null) {
   try {
if (parent != null) {
   c = parent.loadClass(name, false);
} else {
   c = findBootstrapClass0(name);
}
   } catch (ClassNotFoundException e) {
       // If still not found, then invoke findClass in order
       // to find the class.
       c = findClass(name);
   }
}
if (resolve) {
   resolveClass(c);
}
return c;
    }

1、jre需要一个类,假如为a.class，会让Application classloader找，
 
2、Application classloade 就委托他的上一层次加载器extension classloader找，
 
3、Extension classloader 委托他的上一层,让bootstap classloader 找，
 
4、Bootstrap classloader是最高层的，他就亲自找啊，但是没有找到，于是就告诉Extension classloader说他这没有，你自己找去。
 
5、Extesion classloader 就在ext目录下找，发现也没，于是说：“兄弟，哥这也没，你自己找去。”
 
6、于是application classloader就在classpath里面找，如果找到了返回给jre，如果没有找到，就告诉jre没找到，jre此时非常生气：“李大爷的，逗了这么大圈，居然没有找到，靠：ClassNotFoundException ”
 

参考链接：

http://guosxu.iteye.com/blog/1271821

http://blog.csdn.net/a352193394/article/details/7343385