---

问题补充：自定义的loader代码：
package cn.sforce.test.startup.classloader;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;

import cn.sforce.test.startup.TestOut;
import cn.sforce.test.startup.TestURLStreamHandler;
import cn.sforce.test.startup.Util;


public class UnitClassLoader extends ClassLoader
{
protected static TestOut log = TestOut.getLogger( UnitClassLoader.class.getName() );

/**
* 驱动程序列表
*/
private static String driverLibList[] = null;

/**
* WEB公共库
*/
private static String freezeLibList[] = null;

/**
* 应用的类路径
*/
protected String webPath = null;
protected String webClazzPath = null;

/**
* 父装载器
*/
private ClassLoader parent = null;

// 从库中加载的类
private HashMap<String, FreezeResource> clazzList = new HashMap<String, FreezeResource>();
private HashMap<String, FreezeResource> fileList = new HashMap<String, FreezeResource>();

// 工程类装载器
private ArrayList<ProjLoaderInfo> jarLoaderList = new ArrayList<ProjLoaderInfo>();

public UnitClassLoader( ClassLoader parent, String webPath, String... projPath ) throws Exception
{
super( parent );
this.parent = parent;
this.webPath = webPath;
this.webClazzPath = webPath + "/WEB-INF/classes/";

// 加载系统JAR文件
loadAllJar();

// 初始化类装载器
URL root = System.class.getResource( "/" );
String classPath = root.getPath().replace( '\\', '/' );
if( classPath != null ){
//linkProjSource( classPath );
}

// 关联类的装载器
if( projPath != null ){
for( String path : projPath ){
//linkProjSource( path );
}
}
}

/**
* 加载系统JAR文件
* @throws Exception
*/
private void loadAllJar() throws Exception
{
String driverPath = this.getClass().getResource("/").getFile();
if( driverPath.endsWith("/bin/") ){
driverPath = driverPath.substring( 0, driverPath.length()-4 );
}
else if( driverPath.endsWith("/classes/") ){
driverPath = driverPath.substring( 0, driverPath.length()-8 );
}

driverPath += "lib/";
log.info( "驱动程序库文件的目录 = " + driverPath );
driverLibList = Util.getFileList( driverPath, "jar" );
for( int ii=0; ii<driverLibList.length; ii++ ){
String fileName = driverPath + driverLibList[ii];
JarLoader.loadAllFile( clazzList, fileList, fileName );
}

// 不加载的库
String ex[] = {
"axiom-api-1.2.5.jar",
"axiom-dom-1.2.5.jar",
"axiom-impl-1.2.5.jar",
"axis2-adb-1.3.jar",
"axis2-kernel-1.3.jar",
"axis2-metadata-1.3.jar",
"axis2-xmlbeans-1.3.jar",
"neethi-2.0.2.jar",
"wsdl4j-1.6.2.jar",
"ws-policy-SNAPSHOT.jar",
"je-3.1.0.jar",
"jfreechart-1.0.12.jar",
"jcommon-1.0.10.jar",
"itext-2.1.7.jar",
"itext-rtf-2.1.7.jar",
"iTextAsian.jar",
"XmlSchema-1.4.2.jar",
"poi-3.6-20091214.jar",
"poi-contrib-3.6-20091214.jar",
"poi-scratchpad-3.6-20091214.jar",
"mail.jar",
"lucene-core-2.0.0.jar",
"ant.jar",
"antlr-2.7.5.jar",
"jasperreports-4.0.2.jar",
"annogen-0.1.0.jar",
"commons-digester-1.7.jar",
"commons-fileupload-1.2.1.jar",
"commons-httpclient-3.0.1.jar",
"sforce-commons-el-1.0.jar",
"org-netbeans-lib-cvsclient.jar",
"servlet-api.jar",
"velocity-1.5.jar",
"wstx-asl-3.2.5.jar",
"xalan-2.7.0.jar"
};

int x = 0;
String libPath = webPath + "/WEB-INF/lib/";
freezeLibList = Util.getFileList( libPath, "jar" );
for( int ii=0; ii<freezeLibList.length; ii++ ){
String fileName = freezeLibList[ii];
for( x=ex.length-1; x>=0; x-- ){
if( ex[x].compareTo(fileName) == 0 ){
break;
}
}

if( x < 0 ){
JarLoader.loadAllFile( clazzList, fileList, libPath + fileName );
}
}
}

/**
* @param clazzName
* @param resolve
* @return java.lang.Class
* @throws java.lang.ClassNotFoundException
*/
public Class<?> loadClass(String clazzName, boolean resolve)
throws LinkageError, ClassNotFoundException
{
Class<?> clazz = null;

// 加载关联项目的类
for( ProjLoaderInfo l : jarLoaderList ){
clazz = l.loadClass( clazzName, resolve );
if( clazz != null ){
return clazz;
}
}

// 如果不需要刷新，从缓存中装入
clazz = findLoadedClass(clazzName);
if( clazz != null ){
return clazz;
}

// 读类文件并装入
FreezeResource c = clazzList.get( clazzName );
if( c != null ){
byte data[] = c.getClazzData();
clazz = loadClass( clazzName, data );
if( clazz != null ){
if( resolve ){

System.out.println("unit加载类---------->"+clazz.getName());
    resolveClass(clazz);
    }

return clazz;
}
}

    try{
byte[] data = loadClazzData( clazzName );
if( data != null ){
clazz = loadClass( clazzName, data );
}
    }
    catch( LinkageError e ){
    throw e;
    }
catch( Throwable ex ){

}

// 如果上面没有成功，尝试用默认的ClassLoader装入它
    if (clazz == null){
try{
//clazz = findSystemClass(name);
clazz = this.getParent().loadClass(clazzName);
}
catch( ClassNotFoundException e ){
throw new ClassNotFoundException( "加载类[" + clazzName + "]时错误", e );
}
    }

    if( clazz == null ){
throw new ClassNotFoundException( "加载类[" + clazzName + "]时错误" );
    }
    else if( resolve ){
    resolveClass(clazz);
    }
   
    return clazz;   
}

/**
* @param className
* @return java.lang.Class
* @throws java.lang.ClassNotFoundException
*/
public Class<?> loadClass(String className) throws ClassNotFoundException
{
return loadClass( className, false );
}

/**
* @param className
* @return java.lang.Class
* @throws java.lang.ClassNotFoundException
*/
public Class<?> findClass(String className) throws ClassNotFoundException
{
// 先查找缓冲区
Class<?> clazz = findLoadedClass( className );
if( clazz == null ){
byte[] data = loadClazzData( className );
if( data != null ){
clazz = loadClass( className, data );
}
}

if( clazz == null ){
throw new ClassNotFoundException( "加载类[" + className + "]时错误" );
}

return clazz;
}

/**
* @param className
* @return java.lang.Class
* @throws java.lang.ClassNotFoundException
*/
protected Class<?> loadClass(String className, byte[] data) throws ClassNotFoundException
{
Class<?> clazz;
try{
clazz = defineClass(className, data, 0, data.length);
}
catch( ClassFormatError e ){
log.error( "类文件[" + className + "]格式错误" );
throw new ClassNotFoundException( "类文件[" + className + "]格式错误", e );
}

return clazz;
}

/**
* @param clazzName
* @return byte[]
* @throws java.lang.ClassNotFoundException
*/
protected byte[] loadClazzData( String clazzName )
{
InputStream is = null;

try {
// 从当前工程加载类
String fileName = webClazzPath + clazzName.replace('.', '/') + ".class";
File fp = new File( fileName );
if( !fp.exists() ){
throw new ClassNotFoundException( "类文件[" + clazzName + "]不存在" );
}

try {
is = new FileInputStream( fp );
}
catch( Throwable e ){
throw new ClassNotFoundException( "加载类[" + clazzName + "]时错误", e );
}

return Util.readFile( is );
}
catch( Throwable e ){
return null;
}
finally{
Util.closeInputStream( is );
}
}

/**
* 是否有效的类
* @param clazz
* @return
*/
protected boolean isLoadedClass( Class<?> clazz )
{
ClassLoader loader = clazz.getClassLoader();
if( loader == this ){
return true;
}

for( ProjLoaderInfo l : jarLoaderList ){
if( l.getLoader() == loader ){
return true;
}
}

return false;
}

/**
* 检查类是否已经更新
* @return
*/
public void chechClazzModify()
{
boolean flag = false;
for( ProjLoaderInfo l : jarLoaderList ){
// 不要检查junit的类
String path = l.getClassPath();
if( path.indexOf("junit-") < 0 && path.indexOf("freeze") < 0 ){
if( l.chechClazzModify() ){
flag = true;
break;
}
}
}

// 清空所有类装载器
if( flag ){
System.out.println( "清空所有已经装载的类" );

for( ProjLoaderInfo l : jarLoaderList ){
// 不要清空junit的类
String path = l.getClassPath();
if( path.indexOf("junit-") < 0 && path.indexOf("freeze") < 0 ){
l.clear();
}
}
}
}

public InputStream getResourceAsStream( String fileName )
{
int ptr = fileName.indexOf( ':' );
if( ptr > 0 ){
String f1 = fileName.substring( 0, ptr );
String f2 = fileName.substring( ptr+1 );
if( f1.endsWith("/test-unit") ){
FreezeResource t = fileList.get( f2 );
if( t != null ){
byte data[] = t.getClazzData();
return new ByteArrayInputStream( data );
}
}
}

InputStream is = this.getClass().getResourceAsStream( fileName );
if( is != null ){
return is;
}

FreezeResource t = fileList.get( fileName );
if( t != null ){
byte data[] = t.getClazzData();
return new ByteArrayInputStream( data );
}

is = super.getResourceAsStream( fileName );
if( is != null ){
return is;
}

return null;
}

public URL getResource( String path )
{
if( path == null ){
return null;
        }

        path = normalize(path);
        if (path == null){
            return null;
        }
       
        FreezeResource t = fileList.get( path );
        if( t != null ){
        try{
        TestURLStreamHandler u = new TestURLStreamHandler();
        u.setData( t.getClazzData() );
        return new URL( null, null, -1, path, u );
        }
        catch( Throwable e ){
       
        }
        }
       
URL url = super.getResource( path );
if( url != null ){
return url;
}

        if( path.charAt(0) != '/' ){
        path = "/WEB-INF/classes/" + path;
        }
       
        File file = new File( webPath + path );
        if(file.exists() == false){
            return null;
        }
       
        try{
        // log.info( path + " ==> " + file.toURL() );
        return file.toURL();
        }
        catch( Exception e ){
        return null;
        }
}

    private String normalize(String path) {

        String normalized = path;
       
        if (normalized.indexOf('\\') >= 0){
            normalized = normalized.replace('\\', '/');
        }
       
        // Resolve occurrences of "/../" in the normalized path
        while (true) {
            int index = normalized.indexOf("/../");
            if (index < 0)
                break;
            if (index == 0)
                return (null);  // Trying to go outside our context
            int index2 = normalized.lastIndexOf('/', index - 1);
            normalized = normalized.substring(0, index2) +
                normalized.substring(index + 3);
        }
       
        // Return the normalized path that we have completed
        return (normalized);
    }
   
    /**
     * 初始化关联的Project
     */
    public void linkProjSource( String output )
    {
    if( output.indexOf("freeze-unit") >= 0 ){
    return;
    }
   
if( output.endsWith("/") == false ){
output = output + "/";
}

    // 检查是否已经存在
    for( ProjLoaderInfo j : jarLoaderList ){
    String path = j.getClassPath();
    if( path.compareTo(output) == 0 ){
    return;
    }
    }
   
try{
ProjLoaderInfo l = new ProjLoaderInfo( parent, this, webPath, output );
jarLoaderList.add( l );
}
catch( Throwable e ){

}
    }

public String getWebPath()
{
return webPath;
}

public String getWebClazzPath()
{
return webClazzPath;
}
   
}