JVM类加载机制（三）：自定义类加载器

版权声明：欢迎转载，请注明出处： https://blog.csdn.net/u014179251/article/details/86138051

自己编写类加载器的意义

• 当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();
		}
	}

}