java自定义类加载器

类加载器加载类的过程，首先调用loadClass()方法，在该方法中调用findClass()方法。最后在findClass()方法中调用defineClass()方法。

loadClass源码：

protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 检查此类是否已经被加载
Class<?> c = findLoadedClass(name);
if (c == null) {
// 没被加载使用双亲委派机制找到父类加载器递归执行此方法
long t0 = System.nanoTime();
try {
// parent == null 代表当前是扩展类加载器
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
}
// 父类加载器也没加载此类 自己尝试加载，假如调用loadClass()方法
// 的类加载器是系统类加载器，那么第一次执行到这的类加载器是其父类加载器
// 扩展类加载器
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
PerfCounter.getParentDelegationTime().addTime(t1 - t0);
PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}

自定义类加载器的实现方式大概有两种：1、继承ClassLoader类，重写loadClass()方法，2、继承ClassLoader类、重写findClass()方法。由于loadClass()方法主要的操作是实现双亲委派机制。所以这里选择重写findClass()方法。

public class MyClassLoader extends ClassLoader {
// 此类加载器加载的路径
private String root;
public MyClassLoader(ClassLoader parent, String root) {
super(parent);
this.root = root;
}
public MyClassLoader(String root) {
this.root = root;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
// IO流读取字节码文件为二进制流
try (BufferedInputStream bis = new BufferedInputStream((new FileInputStream(root + name + ".class")));
ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
int len;
byte[] bytes = new byte[1024];
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0, len);
}
bos.flush();
bytes = bos.toByteArray();
return defineClass(null,bytes,0,bytes.length);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}

待加载类

public class Person {
private int age;
private String name;
public Person(int age, String name) {
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + ''' +
'}';
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

使用javac将其编译为class文件存到d盘

测试：

public static void main(String[] args) throws Exception {
// class文件存放路径
MyClassLoader classLoader = new MyClassLoader("d:/");
// class文件名
Class<?> person = classLoader.loadClass("Person");
System.out.println(person.getDeclaredConstructor(int.class,String.class).
newInstance(21,"张三"));
}
结果：
Person{age=21, name='张三'}

自定义类加载器的用途，实现热部署：

修改测试代码并启动

while (true) {
MyClassLoader classLoader = new MyClassLoader("d:/");
Class<?> person = classLoader.loadClass("Person");
System.out.println(person.getDeclaredConstructor(int.class,String.class).
newInstance(21,"张三"));
Thread.sleep(5000);
}

修改Person类中的toString()方法，重新编译，将编译好的class文件放到d盘替换原class文件

@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + ''' +
'}' + "n====测试热部署=====";
}

程序输出结果：

Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
Person{age=21, name='张三'}
====测试热部署=====
Person{age=21, name='张三'}
====测试热部署=====

这样就实现了热部署

最后

以上就是会撒娇短靴为你收集整理的java自定义类加载器的全部内容，希望文章能够帮你解决java自定义类加载器所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。