ClassLoader实现自定义类加载器加载指定路径下的Class文件和Jar包

Posted Cry丶

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了ClassLoader实现自定义类加载器加载指定路径下的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包的主要内容,如果未能解决你的问题,请参考以下文章

java自定义ClassLoader加载指定的class文件

类加载器ClassLoader

自定义类加载器classLoader

自定义classLoader

java 自定义类的加载器

6. 通过demo分析自定义类加载器以及Launcher源码分析