1. 全栈程序员必看首页

【ClassLoader】实现自定义类加载器加载指定路径下的Class文件和Jar包[通俗易懂]

全栈程序员-用户IM • • 未分类

【ClassLoader】实现自定义类加载器加载指定路径下的Class文件和Jar包[通俗易懂]自定义类加载器：1.加载指定目录下的.class文件2.加载指定目录下的jar包

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

文章目录

前言

在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啦！

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/196703.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号