通过ClassLoader调用外部jar包

我们大家都知道，每个运行中的线程都有一个成员contextClassLoader，用来在运行时动态地载入其它类。

系统默认的contextClassLoader是systemClassLoader，所以一般而言java程序在执行时可以使用JVM自带的类、$JAVA_HOME/jre/lib/ext/中的类和$CLASSPATH/中的类，对于非默认的jar，一般只能手动在配置环境添加。

但事实上，我们可以通过Thread.currentThread().setContextClassLoader()更改当前线程的contextClassLoader行为，实现在程序内加载外部jar。

PS:
ClassLoader的工作原理是：
1) 线程需要用到某个类时，contextClassLoader将被请求来载入该类
2) contextClassLoader请求它的父ClassLoader来完成该载入请求
3) 如果父ClassLoader无法载入类，则contextClassLoader试图自己来载入

package org.loon.framework.jar;

/***/ /**
*<p>Title:LoonFramework</p>
*<p>Description:JarLoader，用于jar包的外部操作</p>
*<p>Copyright:Copyright(c)2007</p>
*<p>Company:LoonFramework</p>
*@authorchenpeng
*@email：ceponline@yahoo.com.cn
*@version0.1
*/
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
import java.util.jar.Manifest;

public class JarLoader extends ClassLoader ... {
//资源缓存
publicstaticHashtableresources=newHashtable();

publicstaticJarLoaderloader=newJarLoader();

publicstaticClassload(byte[]resource)throwsException...{
//主函数所在类全称
StringmainClassName="";
//class资源及实体缓存
ArrayListclassNames=newArrayList();
ArrayListclassBuffers=newArrayList();
//存储依赖类
HashMapdepends=newHashMap();
//将byte[]转为JarInputStream
JarInputStreamjar=newJarInputStream(newByteArrayInputStream(
resource));
Manifestmanifest=jar.getManifest();
//当Main-Class被声明时,获得主函数所在类全称
if(manifest!=null)...{
mainClassName=manifest.getMainAttributes().getValue("Main-Class");
}
//依次获得对应JAR文件中封装的各个被压缩文件的JarEntry
JarEntryentry;
while((entry=jar.getNextJarEntry())!=null)...{
//当找到的entry为class时
if(entry.getName().toLowerCase().endsWith(".class"))...{
//将类路径转变为类全称
Stringname=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));
}
}
}
//当获得的main-class名不为空时
while(classNames.size()>0)...{
//获得类路径全长
intn=classNames.size();
for(inti=classNames.size()-1;i>=0;i--)...{
try...{
//查询指定类
loader.defineClass((String)classNames.get(i),
(byte[])classBuffers.get(i),0,
((byte[])classBuffers.get(i)).length);
//获得类名
StringpkName=(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(NoClassDefFoundErrore)...{
depends.put((String)classNames.get(i),e.getMessage()
.replaceAll("/","."));
}catch(UnsupportedClassVersionErrore)...{
//jre版本错误提示
thrownewUnsupportedClassVersionError(classNames.get(i)
+","+System.getProperty("java.vm.name")+""
+System.getProperty("java.vm.version")+")");
}
}
if(n==classNames.size())...{
for(inti=0;i<classNames.size();i++)...{
System.err.println("NoClassDefFoundError:"
+classNames.get(i));
StringclassName=(String)classNames.get(i);
while(depends.containsKey(className))...{
className=(String)depends.get(className);
}
}
break;
}
}
try...{
//加载
Thread.currentThread().setContextClassLoader(loader);
//获得指定类,查找其他类方式相仿
returnClass.forName(mainClassName,true,loader);
}catch(ClassNotFoundExceptione)...{
StringclassName=mainClassName;
while(depends.containsKey(className))...{
className=(String)depends.get(className);
}
thrownewClassNotFoundException(className);
}
}

/***//**
*获得指定路径文件的byte[]形式
*@paramname
*@return
*/
finalstaticpublicbyte[]getDataSource(Stringname)...{
FileInputStreamfileInput;
try...{
fileInput=newFileInputStream(newFile(name));
}catch(FileNotFoundExceptione)...{
fileInput=null;
}
BufferedInputStreambufferedInput=newBufferedInputStream(fileInput);
returngetDataSource(bufferedInput);
}

/***//**
*获得指定InputStream的byte[]形式
*@paramname
*@return
*/
finalstaticpublicbyte[]getDataSource(InputStreamis)...{
if(is==null)...{
returnnull;
}
ByteArrayOutputStreambyteArrayOutputStream=newByteArrayOutputStream();
byte[]arrayByte=null;
try...{
byte[]bytes=newbyte[8192];
bytes=newbyte[is.available()];
intread;
while((read=is.read(bytes))>=0)...{
byteArrayOutputStream.write(bytes,0,read);
}
arrayByte=byteArrayOutputStream.toByteArray();
}catch(IOExceptione)...{
returnnull;
}finally...{
try...{
if(byteArrayOutputStream!=null)...{
byteArrayOutputStream.close();
byteArrayOutputStream=null;
}
if(is!=null)...{
is.close();
is=null;
}

}catch(IOExceptione)...{
}
}
returnarrayByte;
}

/***//**
*获得指定JarInputStream的byte[]形式
*@paramjar
*@return
*@throwsIOException
*/
finalstaticprivatebyte[]getResourceData(JarInputStreamjar)
throwsIOException...{
ByteArrayOutputStreamdata=newByteArrayOutputStream();
byte[]buffer=newbyte[8192];
intsize;
while(jar.available()>0)...{
size=jar.read(buffer);
if(size>0)...{
data.write(buffer,0,size);
}
}
returndata.toByteArray();
}

/***//**
*重载的getResource,检查是否重复包含
*/
publicURLgetResource(Stringname)...{
if(resources.containsKey("/"+name))...{
try...{
returnnewURL("file:///"+name);
}catch(MalformedURLExceptione)...{
e.printStackTrace();
}
}
returnsuper.getResource(name);
}

/***//**
*执行指定class类
*@paramclz
*@parammethodName
*@paramargs
*/
publicstaticvoidcallVoidMethod(Classclz,StringmethodName,
String[]args)...{
Class[]arg=newClass[1];
arg[0]=args.getClass();
try...{
Methodmethod=clz.getMethod(methodName,arg);
Object[]inArg=newObject[1];
inArg[0]=args;
method.invoke(clz,inArg);
}catch(Exceptione)...{
System.err.println(e.getMessage());
}
}

/***//**
*重载的getResourceAsStream,检查是否重复包含
*/
publicInputStreamgetResourceAsStream(Stringname)...{
if(name.charAt(0)=='/')...{
name=name.substring(1);
}
if(resources.containsKey("/"+name))...{
returnnewByteArrayInputStream((byte[])resources.get("/"+name));
}
returnsuper.getResourceAsStream(name);
}

}

运行示例：

package org.loon.framework.jar;


/***/ /**
*<p>
*Title:LoonFramework
*</p>
*<p>
*Description:从外部启动jar包
*</p>
*<p>
*Copyright:Copyright(c)2007
*</p>
*<p>
*Company:LoonFramework
*</p>
*
*@authorchenpeng
*@email：ceponline@yahoo.com.cn
*@version0.1
*/
public class JarTest ... {

publicstaticvoidmain(String[]args)...{
//将jar包转为byte[]
byte[]resource=JarLoader.getDataSource("D:/fps_test.jar");
try...{
//通过byte[]获得主函数所在类
Classclz=JarLoader.load(resource);
//调用main函数
JarLoader.callVoidMethod(clz,"main",newString[]...{""});
}catch(Exceptione)...{
e.getStackTrace();
}

}

}

这时即使指定jar包没有被我们添加到lib中，程序依旧被顺利启动了。

但是有个缺点，在没有优化的前提下，这种直接加载外部包的速度在jvm会有很大损耗。

我们可以看到，fps值降低到正常值的50%左右（此fps实例见我优快云以前的文章），所以并不适合直接运用在需要复杂运算的jar中类调用上（当然，有兴趣的话，可以在代码中优化，我自己在项目中写的另一个例子速度明显比这个快）。但是对于运算量小的外部jar调用，还是很方便的。