首页 > 其他分享 >通过类加载机制实现加载相同包名和类名的不同版本的类

通过类加载机制实现加载相同包名和类名的不同版本的类

时间:2022-11-28 23:23:43浏览次数:34  
标签:包名 java entryName jar return new import 类名 加载

有些地方有这种需求,要同时用到两个不兼容的jar包版本的某个工具类,它们的包名和类名又是一样的,即比如都叫org.xxx.Foo;

在项目里已经用到了该jar包的1.0版本,但是现在新的需求要用该jar包的2.0版本,但是2.0版本的jar包的工具类也是叫org.xxx.Foo;

这就导致了需要同时加载这两个签名一样的类(无法改造为一个jar,领导不允许)

可以用URLClassLoader实现:

package org;

import java.io.File;
import java.lang.reflect.Method;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class Main {

    public static void main(String[] args) throws Exception {
        File jar1 = new File("E:\\Projects\\bcprovextjdk15on_unionpay\\out\\artifacts\\jar1.jar");
        File jar2 = new File("E:\\Projects\\bcprovextjdk15on_unionpay\\out\\artifacts\\jar2.jar");
        JarURLClassLoader loader1 = new JarURLClassLoader(jar1.toURI().toURL());
        JarURLClassLoader loader2 = new JarURLClassLoader(jar2.toURI().toURL());

        Class<?> clazzTest1 = loader1.loadClass("me.silentdoer.Test");
        Class<?> clazzTest2 = loader2.loadClass("me.silentdoer.Test");

        Object o1 = clazzTest1.newInstance();
        System.err.println(o1.getClass());
        Method prints1 = clazzTest1.getMethod("prints");
        prints1.invoke(o1);

        Object o2 = clazzTest2.newInstance();
        System.err.println(o2.getClass());
        Method prints2 = clazzTest2.getMethod("prints");
        prints2.invoke(o2);
    }

    public static class JarURLClassLoader {
        private URL jar;
        private URLClassLoader classLoader;

        public JarURLClassLoader(URL jar) {
            this.jar = jar;
            classLoader = new URLClassLoader(new URL[]{jar});
        }

        /**
         * 加载类,如:me.silentdoer.AClass
         *
         * @param name
         * @return
         */
        private Class<?> loadClass(String name) {
            try {
                return classLoader.loadClass(name);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }

        /**
         * 在指定包路径下加载子类
         *
         * @param superClass
         * @param basePackage
         * @return
         */
        public Set<Class> loadClass(Class<?> superClass, String basePackage) {
            JarFile jarFile;
            try {
                // 将jar文件的URL转换为JarFile对象
                jarFile = ((JarURLConnection) jar.openConnection()).getJarFile();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            return loadClassFromJar(superClass, basePackage, jarFile);
        }

        private Set<Class> loadClassFromJar(Class<?> superClass, String basePackage, JarFile jar) {
            Set<Class> classes = new HashSet<>();
            String pkgPath = basePackage.replace(".", "/");
            Enumeration<JarEntry> entries = jar.entries();
            Class<?> clazz;
            while (entries.hasMoreElements()) {
                JarEntry jarEntry = entries.nextElement();
                String entryName = jarEntry.getName();
                if (entryName.charAt(0) == '/') {
                    entryName = entryName.substring(1);
                }
                if (jarEntry.isDirectory() || !entryName.startsWith(pkgPath) || !entryName.endsWith(".class")) {
                    continue;
                }
                String className = entryName.substring(0, entryName.length() - 6);
                clazz = loadClass(className.replace("/", "."));
                if (clazz != null && !clazz.isInterface() && superClass.isAssignableFrom(clazz)) {
                    classes.add(clazz);
                }
            }
            return classes;
        }
    }
}

 

标签:包名,java,entryName,jar,return,new,import,类名,加载
From: https://www.cnblogs.com/silentdoer/p/16934111.html

相关文章