一. 自定义一个类加载器
基本思路：
- 实现自定义的类加载器需要继承抽象类ClassLoader，并重写findClass方法，如果出现加载异常，则抛出ClassNotFoundException异常；
- 需要指定类加载器扫描Calss文件的路径；
- 找到Class文件，将Class文件写入到一个字节数组；
- 将字节数组转化为一个Class对象。
自定义类加载器实现：
/**
* 自定义类加载器
*/
public class MyClassLoader extends ClassLoader {
/**
* 自定义类加载器默认扫描class文件路径
*/
private final static String DEEFAULT_DIR = "E:\\myclassloader\\lib";
/**
* 扫描class文件路径
*/
private String dir = DEEFAULT_DIR;
/**
* 类加载器名
*/
private String classLoaderName;
public MyClassLoader() {
super();
}
public MyClassLoader(String classLoaderName) {
super();
this.classLoaderName = classLoaderName;
}
/**
* 传入类加载器名和父类加载器的构造器
* @param classLoaderName 类加载器名
* @param parent 父类加载器
*/
public MyClassLoader(String classLoaderName, ClassLoader parent) {
super(parent); // 调用父类构造器
this.classLoaderName = classLoaderName;
}
/**
* 实现自定义的类加载器需要继承抽象类ClassLoader，并重写findClass方法
* @param name 待加载的类全类名
* @return Class对象
* @throws ClassNotFoundException 未找到class文件异常
*/
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String classPath = name.replace(".", "/");
File classFile = new File(dir, classPath + ".class");
if (!classFile.exists()) {
throw new ClassNotFoundException("The class " + name + " not found under " + dir);
}
byte[] classBytes = loadClassBytes(classFile);
if (classBytes == null || classBytes.length == 0) {
throw new ClassNotFoundException("Load the class " + name + "failed.");
}
// Converts an array of bytes into an instance of class
return this.defineClass(name, classBytes, 0, classBytes.length);
}
/**
* 将class文件转为字节数组
* @param classFile class文件
* @return 字节数组
*/
private byte[] loadClassBytes(File classFile) {
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
FileInputStream fis = new FileInputStream(classFile)) {
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
baos.write(buffer, 0, len);
}
baos.flush();
return baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
public String getDir() {
return dir;
}
public void setDir(String dir) {
this.dir = dir;
}
public String getClassLoaderName() {
return classLoaderName;
}
public void setClassLoaderName(String classLoaderName) {
this.classLoaderName = classLoaderName;
}
}
定义一个对象，编译后将其放入自定义类加载对应的扫描目录
public class MyObject {
static {
System.out.println("My Object static block.");
}
public String hello() {
return "Hello World.";
}
}
类加载器扫描的路径.png
测试代码：
public class MyClassLoaderTest {
public static void main(String[] args)
throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
// 实例化类一个加载器
final MyClassLoader myClassLoader = new MyClassLoader("MyClassLoader");
// 加载MyObject类
Class<?> aClass = myClassLoader.loadClass("com.herohua.classloader.chapter1.MyObject");
System.out.println(aClass);
System.out.println(aClass.getClassLoader());
// 通过泛着实例化一个对象，并调用其hello方法
Object obj = aClass.newInstance();
Method method = obj.getClass().getMethod("hello", new Class<?>[]{});
Object result = method.invoke(obj, new Object[]{});
System.out.println(result);
}
}
测试结果：
测试结果.png
二. 父类委托机制的验证
验证思路：
- 实例化两个自定义类加载器对象，分别是myClassLoader1和myClassLoader2，并将myClassLoader1设置为myClassLoader2的父加载器。
- 修改myClassLoader2的扫描目录，同时将myClassLoader1的扫描目录中的class文件拷贝至myClassLoader2的扫描目录，即两个类加载器都拥有相同的class文件。
- 通过myClassLoader2取加载MyObject类，观察最终是由哪个类加载器加载的。
测试代码
public class MyClassLoaderTest2 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
// instance myClassLoader1
final MyClassLoader myClassLoader1 = new MyClassLoader("myClassLoader1");
// instance myClassLoader2
final MyClassLoader myClassLoader2 = new MyClassLoader("myClassLoader2", myClassLoader1);
// modify myClassLoader2's dir of class files
myClassLoader2.setDir("E:\\myclassloader\\lib2");
// scan MyObject.class by myClassLoader2
Class<?> aClass = myClassLoader2.loadClass("com.herohua.classloader.chapter1.MyObject");
// print Class<?>
System.out.println(aClass);
// print classLoadName
System.out.println(((MyClassLoader) aClass.getClassLoader()).getClassLoaderName());
Object obj = aClass.newInstance();
Method method = obj.getClass().getMethod("hello", new Class<?>[]{});
Object result = method.invoke(obj, new Object[]{});
System.out.println(result);
}
}
测试结果：
测试结果2.png
可以发现，虽然代码中使用myClassLoader1加载的，但是实际上使用myClassLoader2类加载器加载的，从而证明了父类委托机制。
类加载器之间的关系.png
父子类加载器之间的关系-包装关系。
父类委托机制的优点是能够提高系统的安全性，在此机制下，用户自定义的类加载器不可能加载应该有父加载器加载的可靠类，因此可以防止恶意的代码代替父加载器的可靠代码。
三. 自定义解密类加载器
如果待加载的class文件被加密算法加密了，那么我们用刚才自定义的类加载器就不能正确加载类，必须在加载的时候通过对应的解密算法解密class文件，才能正确加载该类。
准备一个加密算法：
public final class EncryptUtils {
private static final byte ENCRYPT_FACTORY = (byte) 0xff;
private EncryptUtils() {
}
public static void doEncrypt(String source, String target) {
try (FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(target)) {
int data;
while ((data = fis.read()) != -1)
fos.write(data ^ ENCRYPT_FACTORY);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
doEncrypt("E:\\myclassloader\\lib\\com\\herohua\\classloader\\chapter1\\MyObject.class",
"E:\\myclassloader\\lib\\com\\herohua\\classloader\\chapter1\\MyObject.class1");
}
}
将MyObject.class先加密成MyObject.class1，然后再将MyObject.class1文件名改回为MyObject.class。
加密class文件.png
-
用常规的自定义的类加载器加载：
image.png
显而易见，采用常规的类加载器不能正确加载加了密的类。
- 用解密加载器的类加载器加载：
用同样的算法进行解密，只需要修改loadClassBytes方法即可
private byte[] loadClassBytes(File classFile) {
try (FileInputStream fis = new FileInputStream(classFile);
ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
byte[] buffer = new byte[1024];
int data;
while ((data = fis.read()) != -1) {
// 解密
baos.write(data ^ EncryptUtils.ENCRYPT_FACTORY);
}
baos.flush();
return baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
测试结果：
测试结果.png
可以看出，使用了解密类加载器可以加载加了密的class文件。
四. 打破双亲委托机制实战
Java类加载器的双亲委托机制的加载逻辑是定义在ClassLoader类的loadClass方法中的：
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();
// 如果父类加载器没有加载到目标class，则用自己加载
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;
}
}
所以可以通过子类重写loadClass方法，达到改变加载逻辑的目的。我们在上面的自定义加载器MyClassLoader中重写该方法：
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
Class<?> clazz;
// Object类所有类的父类，加载任何类都需要先加载Object类
// 所以为了能够加载Object，jdk的源码类还是用系统加载器加载
if (name.startsWith("java.")) {
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
clazz = systemClassLoader.loadClass(name);
if (clazz != null) {
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
}
// 自己定义的类，用自定义类加载器加载
clazz = findClass(name);
// 如果没有加载到，则用父加载器进行加载
if (clazz == null && getParent() != null) {
clazz = getParent().loadClass(name);
}
return clazz;
}
测试结果：
测试结果.png
可以看出能正确加载MyObject类，这里我们调整了类加载器的加载顺序，先用自定义的类加载器架子啊，如果加载不到，尝试用父类类加载器进行加载，从而破坏了双亲委托机制。
