我想创建一个父/ last/child-first类加载器,例如一个类加载器,它首先在子类loder中查找类,然后只委托它的父ClassLoader来搜索类.
澄清:
现在我知道,要得到完整的类加载分离-我需要使用像传递null,因为它是父的URLClassLoader,归功于这个回答我刚才的问题
但是,当前的问题来帮我解决这个问题:
我的代码+依赖jar正被加载到现有系统中,使用ClassLoader将System的ClassLoader设置为它的父级(URLClassLoader)
该系统使用的某些库与我需要的版本不兼容(例如,旧版本的Xerces,不允许我运行我的代码)
如果运行独立,我的代码运行完全正常,但如果从该ClassLoader运行则它会失败
Howerver我确实需要访问父ClassLoader中的许多其他类
因此,我想允许我使用自己的Override,父类加载器"jars":如果在子类加载器中找到我调用的类(例如,我提供了一个带有我自己的jar的更新版本的Xerces,而不是一个用户由加载我的代码和jar的ClassLoader.
这是加载我的代码+ Jars的系统代码(我无法更改此代码)
File addOnFolder = new File("/addOns");
URL url = addOnFolder.toURL();
URL[] urls = new URL[]{url};
ClassLoader parent = getClass().getClassLoader();
cl = URLClassLoader.newInstance(urls, parent);
这是"我的"代码(完全取自Flying Sauser"Hello World"代码演示):
package flyingsaucerpdf;
import java.io.*;
import com.lowagie.text.DocumentException;
import org.xhtmlrenderer.pdf.ITextRenderer;
public class FirstDoc {
public static void main(String[] args)
throws IOException, DocumentException {
String f = new File("sample.xhtml").getAbsolutePath();
System.out.println(f);
//if(true) return;
String inputFile = "sample.html";
String url = new File(inputFile).toURI().toURL().toString();
String outputFile = "firstdoc.pdf";
OutputStream os = new FileOutputStream(outputFile);
ITextRenderer renderer = new ITextRenderer();
renderer.setDocument(url);
renderer.layout();
renderer.createPDF(os);
os.close();
}
}
这可以独立运行(运行main)但在通过父CL加载时失败并出现此错误:
org.w3c.dom.DOMException:NAMESPACE_ERR:尝试以对名称空间不正确的方式创建或更改对象.
可能是因为父系统使用旧版本的Xerces,即使我在/ addOns文件夹中提供了正确的Xerces jar,因为它的类已经被父系统加载和使用,它不允许我自己的代码使用由于代表团的指示,我自己的罐子.我希望这会让我的问题更加清晰,我确信之前已经提出过这个问题.(也许我不问正确的问题)
kar*_*rts 30
今天是你的幸运日,因为我必须解决这个问题.我警告你,班级装载的内脏是一个可怕的地方.这样做让我觉得Java的设计者从未想过你可能想拥有一个父级最后一个类加载器.
要使用只提供包含类或jar的URL列表,以便在子类加载器中可用.
/**
* A parent-last classloader that will try the child classloader first and then the parent.
* This takes a fair bit of doing because java really prefers parent-first.
*
* For those not familiar with class loading trickery, be wary
*/
private static class ParentLastURLClassLoader extends ClassLoader
{
private ChildURLClassLoader childClassLoader;
/**
* This class allows me to call findClass on a classloader
*/
private static class FindClassClassLoader extends ClassLoader
{
public FindClassClassLoader(ClassLoader parent)
{
super(parent);
}
@Override
public Class<?> findClass(String name) throws ClassNotFoundException
{
return super.findClass(name);
}
}
/**
* This class delegates (child then parent) for the findClass method for a URLClassLoader.
* We need this because findClass is protected in URLClassLoader
*/
private static class ChildURLClassLoader extends URLClassLoader
{
private FindClassClassLoader realParent;
public ChildURLClassLoader( URL[] urls, FindClassClassLoader realParent )
{
super(urls, null);
this.realParent = realParent;
}
@Override
public Class<?> findClass(String name) throws ClassNotFoundException
{
try
{
// first try to use the URLClassLoader findClass
return super.findClass(name);
}
catch( ClassNotFoundException e )
{
// if that fails, we ask our real parent classloader to load the class (we give up)
return realParent.loadClass(name);
}
}
}
public ParentLastURLClassLoader(List<URL> classpath)
{
super(Thread.currentThread().getContextClassLoader());
URL[] urls = classpath.toArray(new URL[classpath.size()]);
childClassLoader = new ChildURLClassLoader( urls, new FindClassClassLoader(this.getParent()) );
}
@Override
protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
{
try
{
// first we try to find a class inside the child classloader
return childClassLoader.findClass(name);
}
catch( ClassNotFoundException e )
{
// didn't find it, try the parent
return super.loadClass(name, resolve);
}
}
}
编辑:Sergio和ɹoƃı已经指出,如果你.loadClass使用相同的类名调用,你将得到一个LinkageError.虽然这是真的,但这个类加载器的正常用例是将它设置为线程的类加载器Thread.currentThread().setContextClassLoader()或通过Class.forName(),并按原样工作.
但是,如果.loadClass()直接需要,可以在顶部的ChildURLClassLoader findClass方法中添加此代码.
Class<?> loaded = super.findLoadedClass(name);
if( loaded != null )
return loaded;
Yon*_*oni 18
我使用的是以下代码.它具有优于其他答案的优点,它不会破坏父链(您可以遵循getClassLoader().getParent()).
它还具有优于tomcat的WebappClassLoader的优势,它不重新发明轮子而不依赖于其他对象.它尽可能地重用URLClassLoader中的代码.
(它还没有兑现系统类加载器,但是当我得到修复时我会更新答案)
它尊重系统类加载器(对于java.*类,背书目录等).当安全性打开并且类加载器无法访问其父级时,它也可以工作(是的,这种情况很奇怪,但可能).
public class ChildFirstURLClassLoader extends URLClassLoader {
private ClassLoader system;
public ChildFirstURLClassLoader(URL[] classpath, ClassLoader parent) {
super(classpath, parent);
system = getSystemClassLoader();
}
@Override
protected synchronized Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
if (system != null) {
try {
// checking system: jvm classes, endorsed, cmd classpath, etc.
c = system.loadClass(name);
}
catch (ClassNotFoundException ignored) {
}
}
if (c == null) {
try {
// checking local
c = findClass(name);
} catch (ClassNotFoundException e) {
// checking parent
// This call to loadClass may eventually call findClass again, in case the parent doesn't find anything.
c = super.loadClass(name, resolve);
}
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
@Override
public URL getResource(String name) {
URL url = null;
if (system != null) {
url = system.getResource(name);
}
if (url == null) {
url = findResource(name);
if (url == null) {
// This call to getResource may eventually call findResource again, in case the parent doesn't find anything.
url = super.getResource(name);
}
}
return url;
}
@Override
public Enumeration<URL> getResources(String name) throws IOException {
/**
* Similar to super, but local resources are enumerated before parent resources
*/
Enumeration<URL> systemUrls = null;
if (system != null) {
systemUrls = system.getResources(name);
}
Enumeration<URL> localUrls = findResources(name);
Enumeration<URL> parentUrls = null;
if (getParent() != null) {
parentUrls = getParent().getResources(name);
}
final List<URL> urls = new ArrayList<URL>();
if (systemUrls != null) {
while(systemUrls.hasMoreElements()) {
urls.add(systemUrls.nextElement());
}
}
if (localUrls != null) {
while (localUrls.hasMoreElements()) {
urls.add(localUrls.nextElement());
}
}
if (parentUrls != null) {
while (parentUrls.hasMoreElements()) {
urls.add(parentUrls.nextElement());
}
}
return new Enumeration<URL>() {
Iterator<URL> iter = urls.iterator();
public boolean hasMoreElements() {
return iter.hasNext();
}
public URL nextElement() {
return iter.next();
}
};
}
@Override
public InputStream getResourceAsStream(String name) {
URL url = getResource(name);
try {
return url != null ? url.openStream() : null;
} catch (IOException e) {
}
return null;
}
}
bma*_*ies 13
通过读取Jetty或Tomcat的源代码,两者都提供了父类最后一个类加载器来实现webapp语义.
也就是说,通过覆盖findClass你ClassLoader班级中的方法.但是,当你可以偷走它时,为什么要重新发明轮子呢？
阅读各种更新,我发现您遇到了XML SPI系统的一些经典问题.
一般的问题是:如果你创建一个完全孤立的类加载器,那么很难使用它返回的对象.如果允许共享,则当父包含错误的版本时,您可能会遇到问题.
它是为了处理OSGi发明的所有这些疯狂,但这是一个吞下的大药丸.
即使在webapps中,类加载器也会在假设容器和webapp必须就它们之间的API达成一致的情况下从"本地优先"处理中免除一些包.