自己编写类加载器的意义
- 当class文件不在ClassPath目录下时，默认的系统类加载器无法找到该class文件，这时候需要自定义一个ClassLoader来加载特定路径下的class对象
- 当一个class文件需要通过网络传输，甚至可能会进行相应的解密操作时，这时候需要编写自定义的ClassLoader来实现相应逻辑
- 当要实现热部署时（一个class文件通过不同的类加载器产生不同的class对象而实现热部署功能），需要实现自定义的ClassLoader的逻辑
目标
本目录针对以上三个意义，将分类实战完成三类自定义ClassLoader的自定义实现，以便更好的掌握。
- 自定义文件类加载器
- 自定义网络类加载器
- 热部署类加载器
自定义File类加载器
package classloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* 从特定路径的文件获取类的File类加载器
* @author XZP
*
*/
public class FileClassLoader extends ClassLoader {
private String rootDir;
public FileClassLoader(String rootDir) {
this.rootDir = rootDir;
}
/**
* 重写父类的findClass方法
* @param name 文件名
* @return 找到类的字节码就用defineClass返回对应的对象
* @throws ClassNotFoundException
*/
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
// 获取类的class文件字节数组
byte[] classData = getClassDataFromFile(name);
if (classData == null) {
throw new ClassNotFoundException();
} else {
// 直接生成class对象
return defineClass(name, classData, 0, classData.length);
}
}
/**
* 获取class文件并转换为字节码流的逻辑
* @param name 文件名
* @return
*/
private byte[] getClassDataFromFile(String name) {
// 读取类文件的字节
String path = name2Path(name);
System.out.println("path:" + path);
try {
InputStream ins = new FileInputStream(path);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int bufferSize = 4096;
byte[] buffer = new byte[bufferSize];
int bytesNumRead = 0;
// 读取文件字节码
while ((bytesNumRead = ins.read(buffer)) != -1) {
baos.write(buffer, 0, bytesNumRead);
}
return baos.toByteArray();
} catch(IOException io) {
io.printStackTrace();
}
return null;
}
/**
* 通过文件名获取class文件的完全路径
* @param className 文件名
* @return
*/
private String name2Path(String className) {
return rootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
}
}
自定义网络类加载器
package classloader;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.URL;
public class NetClassLoader extends ClassLoader {
private String url; // class文件所在的URL
public NetClassLoader(String url) {
this.url = url;
}
/**
* 重写父类的findClass方法
*/
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] classData = getClassDataFromNet(name);
if (classData == null) {
throw new ClassNotFoundException();
} else {
return defineClass(name,classData, 0, classData.length);
}
}
/**
* 从网络获取class文件，不包含解密
* @param name
* @return
*/
private byte[] getClassDataFromNet(String name) {
String path = name2Path(name);
try {
URL url = new URL(path);
InputStream ins = url.openStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int bufferSize = 4096;
byte[] buffer = new byte[bufferSize];
int hasRead = 0;
while ((hasRead = ins.read(buffer)) != -1) {
baos.write(buffer, 0, hasRead);
}
// 可能还涉及解密，在此省略，但是是非常重要的一个内容
return baos.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 根据文件名得到文件URL
* @param name
* @return
*/
private String name2Path(String name) {
// 得到class文件的URL
return url + "/" + name.replace('.', '/') + ".class"; // 注意网络路径表示和File路径表示还是有区别的
}
}
热部署类加载器
package classloader;
/**
* 热部署的测试类
* 作如下特殊说明：
* 热部署就是利用同一个class文件不同的类加载器在内存创建出两个不同的class对象.
* 由于JVM在加载类之前会检测请求的类是否已加载过(即在loadClass()方法中调用findLoadedClass()方法)，
* 如果被加载过，则直接从缓存获取，不会重新加载。注意同一个类加载器的实例和同一个class文件只能被加载器一次，多次加载将报错.
* 因此我们实现的热部署必须让同一个class文件可以根据不同的类加载器重复加载，以实现热部署：也即为同一个class文件写两个不同的类加载器
* @author XZP
*
*/
public class HotDeployTest {
public static void main(String[] args) {
String rootDir = "F:\\java_workspace\\jvm\\src\\classloader";
// 创建自定义类的加载器:两个不同的对象
FileClassLoader loader1 = new FileClassLoader(rootDir);
FileClassLoader loader2 = new FileClassLoader(rootDir);
try {
// 通过调用loadClass()加载指定的class文件
Class<?> object1 = loader1.loadClass("classloader.FileResObj");
Class<?> object2 = loader2.loadClass("classloader.FileResObj");
System.out.println("obj1 by loadClass:" + object1.hashCode()); // 输出的两者hashCode相等，说明是同一对象
System.out.println("obj2 by loadClass:" + object2.hashCode());
// 通过调用findClass()方法绕过检测，创建不同的class对象
Class<?> object3 = loader1.findClass("FileResObj"); // 输出的两者hashCode不相等说明是不同对象
Class<?> object4 = loader2.findClass("FileResObj");
System.out.println("obj3 by findClass:" + object3.hashCode());
System.out.println("obj4 by findClass:" + object4.hashCode());
} catch (Exception e) {
e.printStackTrace();
}
}
}
