这种模式， 就好象servlet，整个java的servlet几乎都是接口。 但是apache的tomcat的jar包实现了接口。 这样的话， 我们就可以通过加载类文件的形式使用实现类。
假设， 我们有一个接口， 叫做Service：
package plugin;
public interface Service {
void service();
}
然后我在 plugin.alexplugin下实现了这个Service接口。主要是两个类： AlexService，以及AlexDao
然后， 我把这2个类打成jar包。在主函数中， 我首先需要做的是获取jar包， 并得到一个字节码序列， 注意实现中如何使用ByteArrayOutputStream类。然后就是解析Jar包， 把获取的jar包内的类的全名以及类的数据放到一个Map中。然后遍历这个Map，定义所有的类和包。最后一句很关键：Thread.currentThread().setContextClassLoader(loader); // 将解析用loader绑定到操作用的线程上。最后返回一个Class类型， 并完成类的初始化。
public class Main {
public static void main(String[] args) {
byte[] resource = JarLoader.getDataSource("/home/alex/桌面/alex.jar");
try {
Class clz = JarLoader.load(resource);
Service service = (Service) clz.newInstance();
service.service();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class JarLoader extends ClassLoader {
// 资源缓存
public static Hashtable resources = new Hashtable();
public static JarLoader loader = new JarLoader();
public static Class load(byte[] resource) throws Exception {
// 主函数所在类全称
String mainClassName = "";
// class资源及实体缓存
ArrayList classNames = new ArrayList();
ArrayList classBuffers = new ArrayList();
// 存储依赖类
HashMap depends = new HashMap();
// 将byte[]转为JarInputStream
JarInputStream jar = new JarInputStream(new ByteArrayInputStream(
resource));
Manifest manifest = jar.getManifest();
// 当Main-Class被声明时,获得主函数所在类全称
if (manifest != null) {
mainClassName = manifest.getMainAttributes().getValue("Main-Class");
}
//TODO：测试用：
mainClassName = "plugin.alexplugin.AlexService";
// 依次获得对应JAR文件中封装的各个被压缩文件的JarEntry
JarEntry entry;
while ((entry = jar.getNextJarEntry()) != null) {
// 当找到的entry为class时
if (entry.getName().toLowerCase().endsWith(".class")) {
// 将类路径转变为类全称
String name = entry
.getName()
.substring(0,
entry.getName().length() - ".class".length())
.replace('/', '.');
// 加载该类
byte[] data = getResourceData(jar);
// 缓存类名及数据
classNames.add(name);
classBuffers.add(data);
} else {
// 非class结尾但开头字符为'/'时
if (entry.getName().charAt(0) == '/') {
resources.put(entry.getName(), getResourceData(jar));
// 否则追加'/'后缓存
} else {
resources.put("/" + entry.getName(), getResourceData(jar));
}
}
}
// 当获得的class资源不为空时
while (classNames.size() > 0) {
// 获得类路径全长
int n = classNames.size();
for (int i = classNames.size() - 1; i >= 0; i--) {
try {
// 查询指定类
loader.defineClass((String) classNames.get(i),
(byte[]) classBuffers.get(i), 0,
((byte[]) classBuffers.get(i)).length);
// 获得类名
String pkName = (String) classNames.get(i);
if (pkName.lastIndexOf('.') >= 0) {
pkName = pkName.substring(0, pkName.lastIndexOf('.'));
if (loader.getPackage(pkName) == null) {
loader.definePackage(pkName, null, null, null,
null, null, null, null);
}
}
// /查询后删除缓冲
classNames.remove(i);
classBuffers.remove(i);
} catch (NoClassDefFoundError e) {
depends.put((String) classNames.get(i), e.getMessage()
.replaceAll("/", "."));
} catch (UnsupportedClassVersionError e) {
// jre版本错误提示
throw new UnsupportedClassVersionError(classNames.get(i)
+ ", " + System.getProperty("java.vm.name") + " "
+ System.getProperty("java.vm.version") + ")");
}
}
if (n == classNames.size()) {
for (int i = 0; i < classNames.size(); i++) {
System.err.println("NoClassDefFoundError:"
+ classNames.get(i));
String className = (String) classNames.get(i);
while (depends.containsKey(className)) {
className = (String) depends.get(className);
}
}
break;
}
}
try {
// 加载
Thread.currentThread().setContextClassLoader(loader);
// 获得指定类,查找其他类方式相仿
return Class.forName(mainClassName, true, loader);
} catch (ClassNotFoundException e) {
String className = mainClassName;
while (depends.containsKey(className)) {
className = (String) depends.get(className);
}
throw new ClassNotFoundException(className);
}
}
// 获得指定路径文件的byte[]形式
final static public byte[] getDataSource(String name) {
FileInputStream fileInput;
try {
fileInput = new FileInputStream(new File(name));
} catch (FileNotFoundException e) {
fileInput = null;
}
BufferedInputStream bufferedInput = new BufferedInputStream(fileInput);
return getDataSource(bufferedInput);
}
// 获得指定InputStream的byte[]形式
final static public byte[] getDataSource(InputStream is) {
if (is == null) {
return null;
}
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte[] arrayByte = null;
try {
byte[] bytes = new byte[8192];
bytes = new byte[is.available()];
int read;
while ((read = is.read(bytes)) >= 0) {
byteArrayOutputStream.write(bytes, 0, read);
}
arrayByte = byteArrayOutputStream.toByteArray();
} catch (IOException e) {
return null;
} finally {
try {
if (byteArrayOutputStream != null) {
byteArrayOutputStream.close();
byteArrayOutputStream = null;
}
if (is != null) {
is.close();
is = null;
}
} catch (IOException e) {
}
}
return arrayByte;
}
// 获得指定JarInputStream的byte[]形式
final static private byte[] getResourceData(JarInputStream jar)
throws IOException {
ByteArrayOutputStream data = new ByteArrayOutputStream();
byte[] buffer = new byte[8192];
int size;
while (jar.available() > 0) {
size = jar.read(buffer);
if (size > 0) {
data.write(buffer, 0, size);
}
}
return data.toByteArray();
}
// 重载的getResource,检查是否重复包含
public URL getResource(String name) {
if (resources.containsKey("/" + name)) {
try {
return new URL("file:///" + name);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
return super.getResource(name);
}
// 执行指定class类
public static void callVoidMethod(Class clz, String methodName,
String[] args) {
Class[] arg = new Class[1];
arg[0] = args.getClass();
try {
Method method = clz.getMethod(methodName, arg);
Object[] inArg = new Object[1];
inArg[0] = args;
method.invoke(clz, inArg);
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
// 重载的getResourceAsStream,检查是否重复包含
public InputStream getResourceAsStream(String name) {
if (name.charAt(0) == '/') {
name = name.substring(1);
}
if (resources.containsKey("/" + name)) {
return new ByteArrayInputStream((byte[]) resources.get("/" + name));
}
return super.getResourceAsStream(name);
}
}
利用这个模型， 可以动态加载类文件以及jar包， 而无需重启系统了。源码。
浙公网安备 33010602011771号