一个自定义类加载器ClassLoader示例

我们的自定义类加载器

package cn.gd.cjz.class_loader;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
* 自定义类加载器
*/
public class CustomClassLoader extends ClassLoader {
/**类名**/
private String name;
/**通过构造方法设置父类加载器和要热加载的类名**/
public CustomClassLoader(ClassLoader parent , String name) {
super(parent);
if(name == null || name.length() <= 0)
throw new NullPointerException();

this.name = name;
}

@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
Class<?> clazz = null;
/**如果是我们想要热加载的类则调用我们重写的findClass方法来加载**/
if(this.name.equals(name) && !"java".equals(name)){
/**先看看要热加载的类之前是否已经加载过了，因为一个类加载器只能加载一个类一次，加载多次会报异常**/
clazz = findLoadedClass(name);
/**clazz==null说明之前没有加载过**/
if(clazz == null)
clazz = findClass(name);

/**
* 类的生命周期包括：加载、验证、准备、解析、初始化、使用、卸载。其中验证、准备、解析统称为连接
* 如果要连接类
*/
if(resolve)
resolveClass(clazz);//如果类已连接过，resolveClass方法会直接返回
return clazz;
}
return super.loadClass(name , resolve);
}

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String fileName = c2f(name);
byte[] bytes = f2b(fileName);
return defineClass(name, bytes, 0, bytes.length);
}

/**
* 类名转为文件名
* @param name
* @return
*/
private String c2f(String name){
/**编译后的class文件存放的目录**/
String baseDir = "F:\\idea_workspace\\Test\\target\\classes\\";
name = name.replace("." , File.separator);
name = baseDir + name + ".class";
return name;
}

/**
* 读取文件byte数组
* @param fileName
* @return
*/
private byte[] f2b(String fileName){
RandomAccessFile file = null;
FileChannel channel = null;
byte[] bytes = null;
try {
/**随机存取文件对象，只读取模式**/
file = new RandomAccessFile(fileName , "r");
/**NIO文件通道**/
channel = file.getChannel();
/**NIO字节缓冲**/
ByteBuffer buffer = ByteBuffer.allocate(1024);
int size = (int) channel.size();
bytes = new byte[size];
int index = 0;
/**从NIO文件通道读取数据**/
while (channel.read(buffer) > 0){
/**字节缓冲从写模式转为读取模式**/
buffer.flip();
while (buffer.hasRemaining()){
bytes[index] = buffer.get();
++index;
}
/**字节缓冲的readerIndex、writerIndex置零**/
buffer.clear();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (channel != null) {
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (file != null) {
try {
file.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return bytes;
}

/**
* 热加载类
* @return
*/
public Class<?> loadClass(){
try {
return loadClass(name);
} catch (ClassNotFoundException e) {
e.printStackTrace();
return null;
}
}
}


将要被热加载的类接口
package cn.gd.cjz.class_loader;

/**
* 测试类接口
*/
public interface IPrinter {
public void print();
}


将要被热加载的类
package cn.gd.cjz.class_loader;

/**
* 测试类
*/
public class Printer implements IPrinter {
@Override
public void print() {
System.out.println("彪悍的人生不需要解释是谁说的？");
}
}

好了，写个测试类来测试一下
package cn.gd.cjz.class_loader;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/***
* 自定义类加载器测试类
*/
public class CustomClassTest {
public static void main(String[] args) {
/**要进行热加载的类名**/
String name = "cn.gd.cjz.class_loader.Printer";
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
IPrinter printer = null;
while (true) {
System.out.println("输入任意字符进行热加载，直接敲回车键退出程序");
try {
String line = reader.readLine();
if(line != null && line.length() > 0){
CustomClassLoader loader = new CustomClassLoader(Thread.currentThread().getContextClassLoader() , name);
Class<?> clazz = loader.loadClass();
/**
* 被子加载器加载的类拥有被父加载器加载的类的可见性
* Printer是由自定义类加载器加载的，
* 而它的父类IPrinter是由系统类加载器加载的，
* 因此IPrinter对于Printer具有可见性，
* 因此转型成功，并不会因为类加载器不同导致ClassCastException异常
*/
printer = (IPrinter) clazz.newInstance();
/**看看是否热加载成功了**/
printer.print();
}else{
break;
}
} catch (IOException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}


首先运行测试类，输入任意字符看看控制台输出了什么？再把Printer类改成下面的代码，编译后再在控制台输入任意字符，看看控制台又输出了什么？
package cn.gd.cjz.class_loader;

/**
* 测试类
*/
public class Printer implements IPrinter {
@Override
public void print() {
System.out.println("锤子老罗说的。");
}
}


以下是我的测试结果：