ClassLoader】实现自定义类载器装载指定路径下的Class文件和Jar包
文章目录
- 前言
- 自定义类加载器加载.class文件
- 自定义类加载器加载jar包文件
前言
在web开发中,一般我们是不需要去自己实现类加载器的,常见的web容器已经帮我们实现了指定路径下的加载,比如我们熟悉的tomcat容器,关于tomcat类加载机制可以阅读博主的这篇文章:
Java类加载机制和Tomcat模型
有些时候我们需要实现自定义的类加载器来重定向我们的.class文件的加载路径或者jar包里的打包的内容,那么我们通常来说有2种办法:
1.我们可以把我们待加载的内容放到JDK中已有的加载路径下去,比如ApplicationClassLoader就是在系统变量下加载的,我们可以放进去,用它来实现加载。
2.我们可以实现一个自定义的类加载器,用它来加载我们所需要加载的内容,然后通过反射生成一个调用对象。
本文主要介绍第二种方式。
自定义类加载器加载.class文件
想要实现一个自定义的类加载器,首先要继承JDK中的ClassLoader
类,如果我们要打破双亲委派模型,就去重写他的loadClass
方法;如果我们想遵循双亲委派模型,只是实现自定义的加载路径,我们只需要重写findClass
。
重写findClass
时有一个核心方法defineClass
, 他可以将一个字节数组转为Class对象,这个字节数组就是.class文件读取后最终的字节数组,也就是说我们只需要通过文件流字节流FileInputStream
把.class文件中的字节流读进来,然后通过defineClass
反序列化成一个Class对象即可,是不是很方便,我们马上来实践一下。
/**
* @author cry777
* @description
* @create 2022-03-02
*/
public class MyClassLoader extends ClassLoader {
private String classPath;
public AgentClassLoader(String classPath) {
this.classPath = classPath;
}
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + name
+ ".class");
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
return defineClass(name, data, 0, data.length);
} catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
}
}
}
这样其实代码就已经写完了,我们来建一个测试类User测试一下:
public class User {
private int id;
private String name;
public User() {
}
public User(int id, String name) {
super();
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void sout() {
System.out.println("=======自己的加载器加载类调用方法=======");
}
public static void main(String[] args) {
User user = new User();
}
}
下面是测试代码:
补充细节: 初始化自定义类加载器,会先初始化父类ClassLoader,其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
public class MyClassLoaderTest {
public static void main(String args[]) throws Exception {
MyClassLoader classLoader = new MyClassLoader ("D:\\test");
Class clazz = classLoader.loadClass("com.cry.User");
Object obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader().getClass().getName());
}
}
我们可以通过clazz.getClassLoader().getClass().getName()
来打印出当前所用到的类加载器全限定名。
补充测试的细节: 测试时候要注意先编译,然后把得到的User.class复制到你的指定目录下,然后要记得删除编译过后的User.class,因为双亲委派模型会先去查缓存,如果你不删除缓存JDK还是会用父类加载器去加载。
这样我们的.class文件就已经加载完了,这个比较简单,下面我们来加载一下jar包,因为jar包是一个压缩文件,所以我们肯定要先解压缩后才能处理,这方面JDK为我们提供了一个JarFile的工具类,可以借助它来实现压缩的效果。
自定义类加载器加载jar包文件
首先我们还是要继承ClassLoader
这个类,去重写它的findClass
方法,里面最关键的方法是jarFile.getJarEntry
:获取一个Class对象,每个JarEntry都对应着一个Class对象, 然后我们就可以把这个JarEntry转换成一个输入流:InputStream is = jarFile.getInputStream(entry);
,这边要注意一个细节:findClass(String name)
这个方法的name入参是com.cry.User
格式的,而jarFile.getJarEntry(jarEntryName)
需要传入的入参是com/cry/User.class
这样格式的,需要对Name做一个格式的转换,贴心的博主这里已经写好了:
public String classNameToJarEntry(String name){
String s = name.replaceAll("\\.", "\\/");
StringBuilder stringBuilder = new StringBuilder(s);
stringBuilder.append(".class");
return stringBuilder.toString();
}
下面我们就把其他部分的代码补充一下吧
public class JarClassLoader extends ClassLoader {
public JarFile jarFile;
public ClassLoader parent;
public JarClassLoader(JarFile jarFile) {
super(Thread.currentThread().getContextClassLoader());
this.parent = Thread.currentThread().getContextClassLoader();
this.jarFile = jarFile;
}
public JarClassLoader(JarFile jarFile, ClassLoader parent) {
super(parent);
this.parent = parent;
this.jarFile = jarFile;
}
public String classNameToJarEntry(String name){
String s = name.replaceAll("\\.", "\\/");
StringBuilder stringBuilder = new StringBuilder(s);
stringBuilder.append(".class");
return stringBuilder.toString();
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
Class c = null;
if (null != jarFile) {
String jarEntryName = classNameToJarEntry(name);
JarEntry entry = jarFile.getJarEntry(jarEntryName);
if (null != entry) {
InputStream is = jarFile.getInputStream(entry);
int availableLen = is.available();
int len = 0;
byte[] bt1 = new byte[availableLen];
while (len < availableLen) {
len += is.read(bt1, len, availableLen - len);
}
c = defineClass(name, bt1, 0, bt1.length);
} else {
if (parent != null) {
return parent.loadClass(name);
}
}
}
return c;
} catch (IOException e) {
throw new ClassNotFoundException("Class " + name + " not found.");
}
}
@Override
public InputStream getResourceAsStream(String name) {
InputStream is = null;
try {
if (null != jarFile) {
JarEntry entry = jarFile.getJarEntry(name);
if (entry != null) {
is = jarFile.getInputStream(entry);
}
if (is == null) {
is = super.getResourceAsStream(name);
}
}
} catch (IOException e) {
// logger.error(e.getMessage());
System.out.println(e.getMessage());
}
return is;
}
}
测试一下结果:
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
JarClassLoader jarClassLoader = new JarClassLoader(new JarFile(new File("D:\\test\\test.jar")));
Enumeration<JarEntry> entries = jarClassLoader.jarFile.entries();
while (entries.hasMoreElements()) {
String name = entries.nextElement().getName();
System.out.println("name: " + name);
}
Class clazz1 = jarClassLoader.loadClass("User");
Object obj1 = clazz1.newInstance();
Method method1 = clazz1.getDeclaredMethod("sout", null);
method1.invoke(obj1, null);
System.out.println(clazz1.getClassLoader().getClass().getName());
}
下面让我们来用一下,比如我们可以用自己的加载器,来生成一个Object:
public static MyInterface createAgentInstance(ClassLoader myClassLoader,String entryClass) throws Exception{
MyInterface myInstance = null;
Thread currentThread = Thread.currentThread();
ClassLoader beforeClassLoader = currentThread.getContextClassLoader();
currentThread.setContextClassLoader(entryClass);
try {
Class<?> entryClass= myClassLoader.loadClass(entryClass);
Constructor<?> constructor = entryClass.getDeclaredConstructor();
Object instance = constructor.newInstance();
if (instance instanceof MyInterface ){
myInstance = (MyInterface ) instance;
}
} finally {
currentThread.setContextClassLoader(beforeClassLoader);
}
return myInstance ;
}
然后就可以愉快的操作这个instance啦!
推荐阅读
-
ClassLoader】实现自定义类载器装载指定路径下的Class文件和Jar包
-
手写类加载器演示 自定义加载类 (1) 创建一个新的 java 文件,并将其保存在适当的目录下。 (2) 使用 cmd 命令进入 world class 的父目录,运行 javac 命令生成 .class 文件。 (3) 创建自己定义的 classload 类。 // 继承 ClassLoader 类并覆盖 findclass 方法。 公共类 MyClassloader extends ClassLoader { private String path; private String classloaderName; private ClassLoader; classloaderName. public MyClassloader(String path,String classloaderName){ this. this.classloaderName = classloaderName; public MyClassloader(String path,String classloaderName){ this.path = path; this.classloaderName = classloaderName; this.classloaderName = classloaderName } // 用于查找类文件 @Override public Class findClass(String name){ byte b =loadClassData(name); return defineClass(name,b,0,b.length); } return defineClass(name,b,0,b.length); } public byte loadClassData(String name) { name = path + name + ".class"; } public byte loadClassData(String name) { name = path + name + ".class"; } InputStream in = null; ByteArrayOutputStream out = null; try { in = new FileInputStream(new File(name)); out = new ByteArrayOutputStream out = new ByteArrayOutputStream; int i = 0; out = new ByteArrayOutputStream out = new ByteArrayOutputStream; int i = 0; while ((i = in.read)) while ((i = in.read) != -1){ out.write(i); } } } catch (Exception e) { e.printStackTrace; }finally { out.write(i) 最后 { try { out.close; in.close; }finally { try { out.close; in.close. in.close. } catch (IOException e) { e.printStackTrace; }catch (IOException e) { e.printStackTrace } } return out.toByteArray; } } } (4) 创建一个测试类并测试结果。 公共类 ClassLoderCheck { public static void main(String args) 抛出 IllegalAccessException、InstantiationException、ClassNotFoundException { MyClassloader classloader = new MyClassloader("D:/jvm/", "myclasscloderz"); 类 c = classloader.loadClass("World"); System.out.println(System.out.println) System.out.println(c.getClassLoader); System.out.println(c.getClassLoader.getParent); System.out.println(c.getClassLoader.getParent.getParent); system.out.println(c.getClassLoader.getParent); c.newInstance; } } 运行结果如下 自定义类加载器的作用:jvm 自带的三个加载器只能加载指定路径下的类字节码。如果在某种情况下,我们需要加载类文件之外的应用程序?例如,本地 D 盘,或在网络上加载类文件,这种情况下可以使用自定义加载器。