小编给大家分享一下Java中如何实现动态加载jar和class文件，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！

创新互联凭借在网站建设、网站推广领域领先的技术能力和多年的行业经验，为客户提供超值的营销型网站建设服务，我们始终认为：好的营销型网站就是好的业务员。我们已成功为企业单位、个人等客户提供了成都网站设计、成都网站建设服务，以良好的商业信誉，完善的服务及深厚的技术力量处于同行领先地位。

具体如下。

JAVA中类文件加载是动态的。也就是说当我们用到的时候才会去加载，如果不用的话，就不会去加载我们的类。

JAVA为我们提供了两种动态机制。第一种是隐式机制。第二种是显示机制。如下:

两种方法：

• 隐式机制 ：new一个对象 + 调用类的静态方法

• 显式机制 ：由 java.lang.Class的forName()方法加载
   由 java.lang.ClassLoader的loadClass()方法加载

1、Class.forName

Class.forName()方法具有两个形式：

• public static Class forName(String className)

• public static Class forName(String className, boolean initialize,ClassLoader loader)

参数说明：

• className - 所需类的完全限定名 (必须包含包名,否则出错!)

• initialize - 是否必须初始化类 (静态代码块的初始化)

• loader - 用于加载类的类加载器

调用只有一个参数的forName()方法等效于 Class.forName(className, true, loader)。

这两个方法，最后都要连接到原生方法forName0().

而三个参数的forName()，最后调用的是: forName0(name, initialize, loader);

不管使用的是new 來实例化某个类、或是使用只有一个参数的Class.forName()方法，内部都隐含了“载入类 ＋ 运行静态代码块”的步骤。

而使用具有三个参数的Class.forName()方法时，如果第二个参数为false，那么类加载器只会加载类，而不会初始化静态代码块，只有当实例化这个类的时候，静态代码块才会被初始化，静态代码块是在类第一次实例化的时候才初始化的。

2、java.lang.ClassLoader

ClassLoader就是用来Load Class的，当一个Class被加载的时候，这个Class所引用到的所有Class也会被加载，而且这种加载是递归的，也就是说，如果A引用到B，B 引用到C，那么当A被加载的时候，B也会被加载，而B被加载的时候，C也会加载。如此递归直到所有需要的Class都加载好。

package com.demo.test;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class DynamicLoadDemo {
	enum FileType {
		JAR, CLASS, OTHER
	}
	static class MyClassLoader extends ClassLoader {
		public synchronized Class loadClass(String name, File file) throws FileNotFoundException {
			Class cls = findLoadedClass(name);
			if(cls != null) {
				return cls;
			}
			FileInputStream fis = new FileInputStream(file);
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int len;
			try {
				while (true) {
					len = fis.read(buffer);
					if (len == -1) {
						break;
					}
					baos.write(buffer, 0, len);
				}
				//FileInputStream的flush是空操作，因为flush的作用是把缓存中的东西写入实体(硬盘或网络流)中，这里没有这种必要所以为空
				//baos.flush();
				byte[] data = baos.toByteArray();
				return defineClass(null, data, 0, data.length);
			}
			catch (IOException e) {
				e.printStackTrace();
			}
			finally {
				try {
					baos.close();
				}
				catch (IOException e) {
					e.printStackTrace();
				}
				try {
					fis.close();
				}
				catch (IOException e) {
					e.printStackTrace();
				}
			}
			return null;
		}
	}
	public static void main(String[] args) {
		String className = "com.demo.test.HelloWorld";
		String paths[] = { "HelloWorld.jar", "HelloWorld.class" };
		for (String path : paths) {
			String lowerPath = path.toLowerCase();
			FileType fileType = FileType.OTHER;
			if (lowerPath.endsWith(".jar") || lowerPath.endsWith(".zip")) {
				fileType = FileType.JAR;
			} else if (lowerPath.endsWith(".class")) {
				fileType = FileType.CLASS;
			}
			if (fileType == FileType.OTHER) {
				return;
			}
			File file = new File(path);
			if (!file.exists()) {
				return;
			}
			try {
				URL url = file.toURI().toURL();
				System.out.println(url.toString());
				Class cls = null;
				switch (fileType) {
					case JAR:
					          URLClassLoader classLoader = new URLClassLoader(new URL[] { url }, Thread.currentThread().getContextClassLoader());
					cls = classLoader.loadClass(className);
					break;
					case CLASS:
					          MyClassLoader myClassLoader = new MyClassLoader();
					cls = myClassLoader.loadClass(className, file);
					break;
					default:
					          break;
				}
				if (cls == null) {
					return;
				}
				// 实例变量
				Field field = cls.getDeclaredField("hello");
				if (!field.isAccessible()) {
					field.setAccessible(true);
				}
				System.out.println(field.get(cls.newInstance()));
				// 调用静态不带参数方法
				Method staticMethod = cls.getDeclaredMethod("sayStaticHello", null);
				if (!staticMethod.isAccessible()) {
					staticMethod.setAccessible(true);
				}
				// 如果函数的返回值是void，就会返回null
				staticMethod.invoke(cls, null);
				// 实例带参数方法方法
				Method method = cls.getDeclaredMethod("say", String.class);
				if (!method.isAccessible()) {
					method.setAccessible(true);
				}
				Object ret = method.invoke(cls.newInstance(), "hello world");
				System.out.println(ret);
			}
			catch (MalformedURLException e) {
				e.printStackTrace();
			}
			catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
			catch (NoSuchMethodException e) {
				e.printStackTrace();
			}
			catch (SecurityException e) {
				e.printStackTrace();
			}
			catch (IllegalAccessException e) {
				e.printStackTrace();
			}
			catch (IllegalArgumentException e) {
				e.printStackTrace();
			}
			catch (InvocationTargetException e) {
				e.printStackTrace();
			}
			catch (InstantiationException e) {
				e.printStackTrace();
			}
			catch (NoSuchFieldException e) {
				e.printStackTrace();
			}
			catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}
	}
}

结果：

以上是“Java中如何实现动态加载jar和class文件”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！

网站题目：Java中如何实现动态加载jar和class文件
URL分享：http://cdweb.net/article/igihcd.html