1、实例1：自定义类加载器
工具类：
public class User {
public static int age = 13;
}
自定义类加载器：
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class MyTest17 extends ClassLoader {
private String classLoaderName;
private final String fileExtension = ".class";
public MyTest17(String classLoaderName) {
super(); // 将系统类加载器作为该类加载器的父类加载器
this.classLoaderName = classLoaderName;
}
public MyTest17(ClassLoader parent, String classLoaderName) {
super(parent); // 显式指定该类加载器的父加载器
this.classLoaderName = classLoaderName;
}
@Override
public String toString() {
return "MyTest17{" +
"classLoaderName='" + classLoaderName + '\'' +
'}';
}
@Override
protected Class<?> findClass(String className) throws ClassNotFoundException {
// 父类中findClass方法返回的是一个异常，所以必须要重写
byte[] data = this.loadClassData(className);
return this.defineClass(className, data, 0, data.length);
}
private byte[] loadClassData(String name) {
InputStream is = null;
byte[] data = null;
ByteArrayOutputStream baos = null;
try {
name = name.replace(".", "/");
is = new FileInputStream(new File(name + this.fileExtension));
System.out.println(name);
baos = new ByteArrayOutputStream();
int ch;
while (-1 != (ch = is.read())) {
baos.write(ch);
}
data = baos.toByteArray();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
is.close();
baos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
return data;
}
public static void test(ClassLoader classLoader) throws Exception {
Class<?> aClass =
classLoader.loadClass(
"com.jvm.classloader.User");
System.out.println(aClass.getClassLoader());
User user = (User) aClass.newInstance();
System.out.println(user.age);
}
public static void main(String[] args) throws Exception {
MyTest17 loader1 = new MyTest17("loader1");
test(loader1);
}
}
输出结果：
sun.misc.Launcher$AppClassLoader@18b4aac2
13
自己实现的这个类加载器重写了findClass方法，在父类的该方法中，只返回了一个异常，所以实现类必须重写这个方法，在这个方法里面返回寻找的那个二进制名字对应的类的Class对象，这个是最关键的一环。
同时，在使用自定义类加载器进行加载的时候使用的是loadClass方法，而该方法会调用findClass方法，这个就是完整的加载流程。
这个列子中最后的类加载器是系统类加载器，而非我们自己的类加载器。是因为在main方法中未指定父类加载器，所以在构造方法中会调用super方法指定默认的父加载器，即系统类加载器。加载的时候父类会先尝试去加载这个类，而父类是可以加载成功的，所以这个User类的类加载器就是系统类加载器。
2、实例2：设置加载class文件目录，从而使用自定义加载器进行加载
如果将class文件放到非appclassloader可以加载的文件夹下，并且删除appclassloader可以加载的文件夹下的class文件。然后指定位置的话，也会使用自定义的类加载器进行加载。
实例：
在桌面上建立目录：com/jvm/classloader，并把User类的class文件放进去，并删除ide里面的class文件，代码如下:
package com.jvm.classloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class MyTest17 extends ClassLoader {
private String classLoaderName;
private String path; // class文件路径
private final String fileExtension = ".class";
public MyTest17(String classLoaderName) {
super(); // 将系统类加载器作为该类加载器的父类加载器
this.classLoaderName = classLoaderName;
}
public void setPath(String path) {
this.path = path;
}
public MyTest17(ClassLoader parent, String classLoaderName) {
super(parent); // 显式指定该类加载器的父加载器
this.classLoaderName = classLoaderName;
}
@Override
public String toString() {
return "MyTest17{" +
"classLoaderName='" + classLoaderName + '\'' +
'}';
}
@Override
protected Class<?> findClass(String className) throws ClassNotFoundException {
System.out.println("findClass:" + className);
System.out.println("class loader name:" + this.classLoaderName);
// 父类中findClass方法返回的是一个异常，所以必须要重写
byte[] data = this.loadClassData(className);
return this.defineClass(className, data, 0, data.length);
}
private byte[] loadClassData(String className) {
InputStream is = null;
byte[] data = null;
ByteArrayOutputStream baos = null;
className = className.replace(".", "/");
try {
is = new FileInputStream(new File(this.path + className + this.fileExtension));
System.out.println(this.path + className + this.fileExtension);
baos = new ByteArrayOutputStream();
int ch;
while (-1 != (ch = is.read())) {
baos.write(ch);
}
data = baos.toByteArray();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
is.close();
baos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
return data;
}
public static void main(String[] args) throws Exception {
MyTest17 loader1 = new MyTest17("loader1");
loader1.setPath("C:/Users/lifeline张/Desktop/");
Class<?> aClass = loader1.loadClass("com.jvm.classloader.User");
System.out.println("aClass" + aClass.hashCode());
System.out.println(aClass.getClassLoader());
}
}
运行结果：
findClass:com.jvm.classloader.User
class loader name:loader1
C:/Users/lifeline张/Desktop/com/jvm/classloader/User.class
aClass1956725890
MyTest17{classLoaderName='loader1'}
可以看到，虽然有默认的父加载器，但是父加载器并没有在自己的加载目录中找到class文件，所以会使用自定义类加载器进行加载。
重新生成ide中的user类的class文件，同时改变main方法为：
public static void main(String[] args) throws Exception {
MyTest17 loader1 = new MyTest17("loader1");
loader1.setPath("C:/Users/lifeline张/Desktop/");
Class<?> aClass = loader1.loadClass("com.jvm.classloader.User");
System.out.println("aClass" + aClass.hashCode());
System.out.println(aClass.getClassLoader());
System.out.println("==========");
MyTest17 loader2 = new MyTest17("loader1");
loader2.setPath("C:/Users/lifeline张/Desktop/");
Class<?> aClass2 = loader2.loadClass("com.jvm.classloader.User");
System.out.println("aClass2" + aClass2.hashCode());
System.out.println(aClass2.getClassLoader());
}
结果为：
aClass460141958
sun.misc.Launcher$AppClassLoader@18b4aac2
==========
aClass2460141958
sun.misc.Launcher$AppClassLoader@18b4aac2
可以看到，都使用了app加载器进行加载，并且两个Class对象的hashcode一样，是同一个对象。这是因为自定义加载器将类加载委托给了app加载器，app加载器加载到了class文件，并且在第二次加载的时候会先判断这个类是否加载过。因为第一次的时候已经加载了，所以第二次直接使用第一次加载的，所以是同一个对象。
保持main方法不变，删除ide中的class文件，此时运行结果为：
findClass:com.jvm.classloader.User
class loader name:loader1
C:/Users/lifeline张/Desktop/com/jvm/classloader/User.class
aClass1956725890
MyTest17{classLoaderName='loader1'}
==========
findClass:com.jvm.classloader.User
class loader name:loader1
C:/Users/lifeline张/Desktop/com/jvm/classloader/User.class
aClass221685669
MyTest17{classLoaderName='loader1'}
此时两次加载的app加载器都没有找到class文件，所以都自己进行了加载，并且两个加载出来的class对象并不相同。这是因为：
对于任意一个类，都必须由加载他的类加载器和这个类本身一起共同确立其在java虚拟机中的唯一性，每一个类加载器，都有一个独立的类名称空间。换句话说：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个class文件，被同一个java虚拟机加载，只要加载他们的类加载器不同，那这两个类就必定不相等。
命名空间由该加载器及所有父加载器所加载的类组成
在同一个命名空间中，不会出现类的完整名字（包括类的包名）相同的两个类。
在不同的命名空间中，有可能会出现类的完整名字（包括类的包名）相同的两个类。
3、对2的练习
删除ide中的user的class文件，改变main方法为：
public static void main(String[] args) throws Exception {
MyTest17 loader1 = new MyTest17("loader1");
loader1.setPath("C:/Users/lifeline张/Desktop/");
Class<?> aClass = loader1.loadClass("com.jvm.classloader.User");
System.out.println("aClass" + aClass.hashCode());
System.out.println(aClass.getClassLoader());
System.out.println("==========");
MyTest17 loader2 = new MyTest17(loader1, "loader1");
loader2.setPath("C:/Users/lifeline张/Desktop/");
Class<?> aClass2 = loader2.loadClass("com.jvm.classloader.User");
System.out.println("aClass2" + aClass2.hashCode());
System.out.println(aClass2.getClassLoader());
}
结果为：
findClass:com.jvm.classloader.User
class loader name:loader1
C:/Users/lifeline张/Desktop/com/jvm/classloader/User.class
aClass1956725890
MyTest17{classLoaderName='loader1'}
==========
aClass21956725890
MyTest17{classLoaderName='loader1'}
这是因为将loader1作为2的弗雷加载器，2在加载的时候先委托给了1，而1已经自己加载过了，所以2不会再次加载，并且对象也都是同一个。
扫一扫
1118
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
