java 使用ClassLoader动态加载jar,zip文件

最新推荐文章于 2023-05-05 10:34:56 发布
最新推荐文章于 2023-05-05 10:34:56 发布
阅读量230 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/ososchina/blog/352008
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

java ClassLoader的使用

public class Main {
    public static void main(String[] args) {
        
        URL[] urls = new URL[] {};
        MyClassLoader classLoader = new MyClassLoader(urls, null);
        String path = "E:/WorkSpace/MapSDKLibrary/libs/commons-codec-1.6.jar";
        try {
            classLoader.addJar(new File(path).toURI().toURL());
            Class<?> clazz = classLoader.loadClass("org.apache.commons.codec.digest.DigestUtils");
            Method md5Method = clazz.getDeclaredMethod("md5Hex",byte[].class);
            Object returnValue = md5Method.invoke(null, "hello world".getBytes("utf-8"));
            System.out.println("length="+returnValue.toString().length()+",result="+returnValue.toString());
            classLoader.close();
            
            /**
            ClassLoader cl = new URLClassLoader(new URL[]{new File(path).toURI().toURL()});
            Class<?> clazz2 = classLoader.loadClass("org.apache.commons.codec.digest.DigestUtils");
            Method md5Method2 = clazz.getDeclaredMethod("md5Hex",byte[].class);
            Object returnValue2 = md5Method.invoke(clazz2.newInstance(), "hello world".getBytes("utf-8"));
            System.out.println("length="+returnValue2.toString().length()+",result="+returnValue2.toString());
           **/
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    static class MyClassLoader extends URLClassLoader {

        public MyClassLoader(URL[] urls) {
            super(urls);
        }

        public MyClassLoader(URL[] urls, ClassLoader parent) {
            super(urls, parent);
        }

        public void addJar(URL url) {
            this.addURL(url);
        }

    }

}

这里我们给出一个比较好的类加载工具

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.List;

public class ClassUtil
{

    public static final String ARRAY_SUFFIX = "[]";

    public static final Class EMPTY_CLASS_ARRAY[] = new Class[0];

    private static final char INNER_CLASS_SEPARATOR_CHAR = 36;

    private static final char PACKAGE_SEPARATOR_CHAR = 46;

    private static Class PRIMITIVE_CLASSES[];

    static 
    {
        PRIMITIVE_CLASSES = (new Class[] {
            Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE
        });
    }

    public static String addResourcePathToPackagePath(Class clazz, String resourceName)
    {
        if(!resourceName.startsWith("/"))
            return (new StringBuilder()).append(classPackageAsResourcePath(clazz)).append("/").append(resourceName).toString();
        else
            return (new StringBuilder()).append(classPackageAsResourcePath(clazz)).append(resourceName).toString();
    }

    public static String classPackageAsResourcePath(Class clazz)
    {
        if(clazz == null || clazz.getPackage() == null)
            return "";
        else
            return clazz.getPackage().getName().replace('.', '/');
    }

    private static List getAllInterfacesExclude(Class clazz, String itfNames[], List list)
    {
        if(list == null)
            list = new ArrayList();
        if(clazz != null)
        {
            Class interfaces[] = clazz.getInterfaces();
            for(int i = 0; i < interfaces.length; i++)
            {
                boolean needAdded = true;
                if(list.contains(interfaces[i]))
                    continue;
                if(itfNames != null)
                {
                    for(int j = 0; j < itfNames.length && needAdded; j++)
                    {
                        if(!interfaces[i].getName().startsWith(itfNames[j]))
                            continue;
                        if(clazz.isInterface())
                            list.remove(clazz);
                        needAdded = false;
                    }

                }
                if(needAdded)
                {
                    list.add(interfaces[i]);
                    getAllInterfacesExclude(interfaces[i], itfNames, list);
                }
            }

            clazz = clazz.getSuperclass();
            getAllInterfacesExclude(clazz, itfNames, list);
        }
        return list;
    }

    public static Constructor getConstructor(Class clz, Class expectedTypes[])
    {
        Constructor constructor = null;
        try
        {
            Constructor constructors[] = clz.getConstructors();
            for(int i = 0; i < constructors.length; i++)
            {
                Constructor creator = constructors[i];
                if(isAssignable(expectedTypes, creator.getParameterTypes()))
                    if(constructor == null)
                        constructor = creator;
                    else
                    if(isAssignable(creator.getParameterTypes(), constructor.getParameterTypes()))
                        constructor = creator;
            }

        }
        catch(Throwable thr)
        {
            String msg = (new StringBuilder()).append("Class: ").append(clz.getName()).append(", ").append(clz.getProtectionDomain().getCodeSource().getLocation()).append(", ").append(clz.getClassLoader()).toString();
            throw new RuntimeException(msg, thr);
        }
        return constructor;
    }

    public static ClassLoader getContextClassLoader()
    {
        return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction() {

            public ClassLoader run()
            {
                return Thread.currentThread().getContextClassLoader();
            }

        });
    }

    public static Class[] getInterfaces(Class clazz)
    {
        List interfaces = new ArrayList();
        interfaces = getAllInterfacesExclude(clazz, null, interfaces);
        return (Class[])(Class[])interfaces.toArray(new Class[interfaces.size()]);
    }

    public static Class[] getInterfaces(Class clazz, String excludes[])
    {
        List interfaces = new ArrayList();
        interfaces = getAllInterfacesExclude(clazz, excludes, interfaces);
        return (Class[])(Class[])interfaces.toArray(new Class[interfaces.size()]);
    }

    public static Method getMethod(Class clz, String methodName, Class expectedTypes[])
        throws NoSuchMethodException
    {
        Method method = null;
        try
        {
            method = clz.getMethod(methodName, expectedTypes);
        }
        catch(NoSuchMethodException e)
        {
            Method methods[] = clz.getMethods();
            for(int i = 0; i < methods.length; i++)
            {
                Method _method = methods[i];
                if(!_method.getName().equals(methodName) || !isAssignable(expectedTypes, _method.getParameterTypes()))
                    continue;
                if(method == null)
                {
                    method = _method;
                    continue;
                }
                if(isAssignable(_method.getParameterTypes(), method.getParameterTypes()))
                    method = _method;
            }

            if(method == null)
                throw e;
        }
        return method;
    }

    public static String getShortName(Class clazz)
    {
        return getShortName(clazz.getName());
    }

    public static String getShortName(String className)
    {
        char charArray[] = className.toCharArray();
        int lastDot = 0;
        for(int i = 0; i < charArray.length; i++)
        {
            if(charArray[i] == '.')
            {
                lastDot = i + 1;
                continue;
            }
            if(charArray[i] == '$')
                charArray[i] = '.';
        }

        return new String(charArray, lastDot, charArray.length - lastDot);
    }

    public static Method getStaticMethod(Class clazz, String methodName, Class args[])
    {
        try
        {
            Method method = clazz.getDeclaredMethod(methodName, args);
            if((method.getModifiers() & 8) != 0)
                return method;
        }
        catch(NoSuchMethodException ex) { }
        return null;
    }

    public static boolean hasAtLeastOneMethodWithName(Class clazz, String methodName)
    {
        do
        {
            for(int i = 0; i < clazz.getDeclaredMethods().length; i++)
            {
                Method method = clazz.getDeclaredMethods()[i];
                if(methodName.equals(method.getName()))
                    return true;
            }

            clazz = clazz.getSuperclass();
        } while(clazz != null);
        return false;
    }
    public static boolean isAssignable(Class cls, Class toClass)
    {
        if(toClass == null)
            return false;
        if(cls == null)
            return !toClass.isPrimitive();
        if(cls.equals(toClass))
            return true;
        if(cls.isPrimitive())
        {
            if(!toClass.isPrimitive())
                return false;
            if(Integer.TYPE.equals(cls))
                return Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass);
            if(Long.TYPE.equals(cls))
                return Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass);
            if(Boolean.TYPE.equals(cls))
                return false;
            if(Double.TYPE.equals(cls))
                return false;
            if(Float.TYPE.equals(cls))
                return Double.TYPE.equals(toClass);
            if(Character.TYPE.equals(cls))
                return Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass);
            if(Short.TYPE.equals(cls))
                return Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass);
            if(Byte.TYPE.equals(cls))
                return Short.TYPE.equals(toClass) || Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass);
            else
                return false;
        } else
        {
            return toClass.isAssignableFrom(cls);
        }
    }
    public static boolean isAssignable(Class classArray[], Class toClassArray[])
    {
        if(classArray.length != toClassArray.length)
            return false;
        if(classArray == null)
            classArray = EMPTY_CLASS_ARRAY;
        if(toClassArray == null)
            toClassArray = EMPTY_CLASS_ARRAY;
        for(int i = 0; i < classArray.length; i++)
            if(!isAssignable(classArray[i], toClassArray[i]))
                return false;

        return true;
    }
    public static boolean isAssignableFrom(Class original, Class checkedClasses[])
    {
        if(checkedClasses == null)
            return false;
        for(int i = 0; i < checkedClasses.length; i++)
            if(original.isAssignableFrom(checkedClasses[i]))
                return true;

        return false;
    }
    public static Class loadClass(final String name)
        throws ClassNotFoundException
    {
        if(name.length() <= 8)
        {
            for(int i = 0; i < PRIMITIVE_CLASSES.length; i++)
            {
                Class clazz = PRIMITIVE_CLASSES[i];
                if(clazz.getName().equals(name))
                    return clazz;
            }

        }
        if(name.endsWith("[]"))
        {
            String elementClassName = name.substring(0, name.length() - "[]".length());
            Class elementClass = loadClass(elementClassName);
            return Array.newInstance(elementClass, 0).getClass();
        }
        Class result = null;
        try
        {
            result = Class.forName(name);
            if(result != null)
            {
            	return result;
            }
        }
        catch(ClassNotFoundException e) { 
        	
        }
        
        Object obj = AccessController.doPrivileged(new PrivilegedAction() {

        	@Override
        	public Object run()
            {
                ClassLoader threadCL = ClassUtil.getContextClassLoader();
                if(threadCL != null)
                    try
                    {
                        return threadCL.loadClass(name);
                    }
                    catch(ClassNotFoundException ex)
                    {
                        return ex;
                    }
                else
                    return null;
            }

        });
        if(obj instanceof Class)
            return (Class)obj;
        else
            throw new ClassNotFoundException("Not Found the class which name of"+name);
    }

    public ClassUtil()
    {
    }


转载于:https://my.oschina.net/ososchina/blog/352008

weixin_34279579
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA动态加载JAR zip包
07-24
JAVA动态加载JAR，zip包例子 有在项目中用到
android动态加载jar文件中的图片
04-08
在Android应用中，我们不能直接使用`ClassLoader`加载jar文件，因为Android系统默认只加载APK内的资源。因此，我们需要将jar文件放在外部存储（如SD卡）或者应用私有的`assets`或`raw`目录中。如果是外部存储，可以...
实现java classloader 动态加载jar包
AS_JOPO的专栏
12-29 1517
业务描述 : 有两个jar包mylib.jar,mylib2.jar , 其中mylib.jar依赖mylib2.jar     我在eclipse的classpath上不加载这两个jar包     但是我想要正常运行mylib.jar中的方法,并且该方法调用了mylib2.jar中的方法 实现 : import java.io.File; import java.lang.reflect.
java的classloader_java 使用ClassLoader动态加载jar,zip文件
weixin_31874327的博客
02-15 385
java ClassLoader的使用publicclassMain{publicstaticvoidmain(String[]args){URL[]urls=newURL[]{};MyClassLoaderclassLoader=newMyClassLoader(urls,null);Stringpath="E:/WorkSpace/MapSDKLibr...
利用classloader动态加载jar包
zsllxbb的博客
11-18 9895
利用classloader动态加载jar包
使用classloader加载文件
u011385186的专栏
12-25 359
在使用classloader加载文件之前首先要知道当前的classloader的种类： ExtClassLoader: 对应的是jre\lib\ext 目录 AppClassLoader: 对应的是classpath 用户自定义的需要具体分析，例如tomcat 的standardClassloader：对应WEB-INF\classes；WEB-INF\lib 在确定了该C
Java虚拟机JVM类加载初始化
最新发布
10-03
- 压缩文件加载：从`.jar`、`.zip`等压缩文件中查找并加载类，自动解析`.jar`文件中的`.class`文件。 - 动态编译：从`.java`源代码文件编译成`.class`文件，然后加载。 类加载器的层次结构包括引导类加载器...
javajar.zip
05-20
2. **集成到其他Java应用**：通过`Class.forName()`或`ClassLoader.loadClass()`加载JAR文件中的类，并调用其方法。 3. **开发环境**：在IDE中，可以设置项目依赖JAR文件，以便在开发和运行时自动加载。 **总结** ...
动态加载jar包的实现
04-13
在Java编程环境中，动态加载jar包是一项重要的技术，它允许我们无需重启服务器就能引入新的功能或更新已有的类。这在大型系统维护和迭代中尤为关键，因为它提高了系统的灵活性和可扩展性。以下是对"动态加载jar包的...
使用URLClassLoader动态加载jar
杜海的博客
12-31 3057
背景介绍 在某些项目中会使用插件化技术实现一些动态“插拔”或热更新的功能。一般的做法是，定义一个标准接口，然后将实现分离进行独立部署或更新。 现在有个场景，系统希望引入一些特殊的业务“函数”，并支持热更新。来看看我们是怎么实现的。 业务函数接口：IFunction.java /** 业务函数接口 **/ public interface IFunction { /** 函数名称 **/ public String getName(); /** 函数描述 **/
定义ClassLoader调用外部jar包
03-14
NULL 博文链接：https://fly-hyp.iteye.com/blog/296625
用Class和ClassLoader加载文件
snowboy886的博客
02-26 91
一： 要加载的文件和.class文件在同一目录下，例如：com.x.y 下有类Test.class ,同时有资源文件config.properties   那么，应该有如下代码：   //前面没有“/”代表当前类的目录   InputStream is1 = Test.class.getResourceAsStream(“config.properties”); System.ou...
使用类加载器(ClassLoader)加载配置文件 [Java]
m0_57001006的博客
01-23 5260
使用类加载器(ClassLoader)加载配置文件 我们之前就知道Properties是用来读取配置文件的类,但是我们使用Properties读取配置文件之前,我们先要将我们的配置文件加载到内存中来 将配置文件加载到内存中来就是将配置文件从硬盘中读取到内存中来,而加载的方式有两种: 方式一: 使用输入流将配置文件加载到内存中来 eg: package 反射.类加载器加载配置文件; import java.io.IOException; import java.util.Properties; im
Java URLClassLoader动态加载外部java代码
Code changes the world！
08-14 6118
外部代码 package priv.tuyou; public class Say { public void say(){ System.out.println("say priv.tuyou.hello"); } } 存放路径 动态加载示例 import java.lang.reflect.InvocationTargetException;
ClassLoader加载项目下的资源文件
p7+的博客
12-27 1313
Bootstrap、ExtClassLoader、AppClassLoader 首先先要知道三种类加载器的作用。 启动类加载器（Bootstrap） 启动类加载器是C++实现的，负责将<JAVA_HOME>/lib路径下的核心类库或-Xbootclasspath参数指定的路径下的jar包加载到内存中，出于安全考虑，Bootstrap只加载包名为java、javax、sun等开头的类 ##扩展类加载器（ExtClassLoader） ExtClassLoader是Java实现的，是sun.misc
Java-springboot动态加载jar包，动态配置
1
05-05 9274
服务中有众多任务，当其中任一任务有改动需要升级或新增一个任务时，都需要将服务重启，会影响其他任务的正常运行。因此采用java动态加载的方式，将不同任务插件化形式加载到服务中心，配合xxl-job任务调度框架统一管理。实现了插件化任务管理。
maven 手动加载第三方jar、zip包
weixin_30869099的博客
04-12 83
1.加载jar包到本地 （以加载saxon-dom-9.0.jar为例） <dependency> <groupId>net.sf.saxon</groupId> <artifactId>saxon-dom</artifactId> <version>9.0</version> &...
java基础 ---- 动态加载Java文件
miracle_8的博客
07-16 2185
动态加载java文件 package com.m.test; import java.io.FileWriter; import java.lang.reflect.Constructor; import java.net.URL; import java.net.URLClassLoader; import javax.tools.JavaCompiler; import javax.to...
java classloader jar_Java自定义ClassLoader加载lib包（jar或者zip）
weixin_30995363的博客
02-12 440
package cn.hopegroup.startup;import java.io.File;import java.net.MalformedURLException;import java.net.URL;import java.net.URLClassLoader;import java.util.ArrayList;import java.util.List;public class ...
Java如何使用classloader重新加载class文件
02-22
Classloader可以用来重新加载class文件...Java中使用ClassLoader类可以从指定路径加载class文件，并将其作为Java类实例化。通过调用ClassLoader对象的loadClass()方法，可以将外部class文件加载到JVM，然后进行实例化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值