Java Jar文件找不到文件夹位置

我有一个代码，它获取给定包名中的类文件列表。但是，代码返回给定包（com.testscript）中可用的类文件列表，但当我使用与包（src.com.testscript）相同的代码运行jar时，它不会返回文件夹和子文件夹中可用的类文件列表。我已经把这个jar文件放在包含jar文件和scr包的主文件夹下。下面是我用来获取类列表的代码

package com.generateUI.createXML;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.io.*;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.testng.IAnnotationTransformer;
import org.testng.annotations.ITestAnnotation;
import org.testng.internal.ClassHelper;
import org.testng.internal.annotations.AnnotationHelper;
import org.testng.internal.annotations.IAnnotationFinder;
import org.testng.internal.annotations.JDK15AnnotationFinder;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import com.setup.CreateMethodsList;

public class FindTestMethodsInTestClass {

    public boolean isMethodsListXMLReady() throws ClassNotFoundException, IOException, InterruptedException {
        FindTestMethodsInTestClass FTMITC = new FindTestMethodsInTestClass();
        boolean bool=false;
        boolean isXMLFileExist = false;
        Map<String,CreateMethodsList> aMap=new HashMap<String,CreateMethodsList>();
        Class[] classes=getClasses("com.testscript");
        IAnnotationFinder finder = new JDK15AnnotationFinder(new DummyTransformer());
        for(Class cls:classes){
            String temp=cls.toString();
            String[] className=temp.split("\\.");
            String[] classPaht=temp.split(" ");
            List<String> mNames=new ArrayList();
            Set<Method> allMethods = ClassHelper.getAvailableMethods(cls);
            if(!(allMethods==null)){
                for (Method eachMethod : allMethods) {
                    ITestAnnotation value = AnnotationHelper.findTest(finder, eachMethod);
                    if (value != null) {
                        mNames.add(eachMethod.getName());
                        bool=true;
                    }
                }
                if(bool){
                    int lastIndex=className.length-1;
                    aMap.put(className[lastIndex],new CreateMethodsList(mNames,classPaht[1]));
                }
            }
        }
        if(FTMITC.CreateXML(aMap)){
            isXMLFileExist=true;
        }
        return isXMLFileExist;
    }

    public static class DummyTransformer implements IAnnotationTransformer {

        @SuppressWarnings("rawtypes")
        @Override
        public void transform(ITestAnnotation annotation, Class testClass, Constructor testConstructor,
                Method testMethod) {
        }
    }

    /**
     * Scans all classes accessible from the context class loader which belong to the given package and subpackages.
     *
     * @param packageName The base package
     * @return The classes
     * @throws ClassNotFoundException
     * @throws IOException
     */
    private static Class[] getClasses(String packageName)  throws ClassNotFoundException, IOException {

        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        assert classLoader != null;
        String path = packageName.replace('.', '/');
        Enumeration<URL> resources = classLoader.getResources(path);
        List<File> dirs = new ArrayList<File>();
        System.out.println("<URL> resources: "+resources);
        while (resources.hasMoreElements()) {
            URL resource = new URL( resources.nextElement().toString().replace("%20", " "));
            System.out.println("URL Resource: "+resources);
            dirs.add(new File(resource.getFile()));
        }
        ArrayList<Class> classes = new ArrayList<Class>();
        for (File directory : dirs) {
            classes.addAll(findClasses(directory, packageName));
        }
        System.out.println("<Class> classes: "+resources);
        return classes.toArray(new Class[classes.size()]);
    }

    /**
     * Recursive method used to find all classes in a given directory and subdirs.
     *
     * @param directory   The base directory
     * @param packageName The package name for classes found inside the base directory
     * @return The classes
     * @throws ClassNotFoundException
     */
    private static List<Class> findClasses(File directory, String packageName) throws ClassNotFoundException {
        List<Class> classes = new ArrayList<Class>();
        if (!directory.exists()) {
            return classes;
        }
        File[] files = directory.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                assert !file.getName().contains(".");
                classes.addAll(findClasses(file, packageName + "." + file.getName()));
            } else if (file.getName().endsWith(".class")) {
                classes.add(Class.forName(packageName + '.' + file.getName().substring(0, file.getName().length() - 6)));
            }
        }
        return classes;
    }

    public boolean CreateXML(Map map) throws InterruptedException{
        boolean bool=false;
        try {
            File file = new File(".\\MethodsList.xml");
            if(file.exists()){
                file.delete();
                Thread.sleep(2000);
            }
            Set<String> keys=map.keySet();
            List<String>methodsName=new ArrayList();
            DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

            // root elements
            Document doc = docBuilder.newDocument();
            Element rootElement = doc.createElement("TestMethodsList");
            doc.appendChild(rootElement);
            for(String key:keys){
                //              System.out.println(key);
                // classname elements
                Element ClassName = doc.createElement(key);
                rootElement.appendChild(ClassName);
                methodsName=((CreateMethodsList) map.get(key)).getMehodsList();
                String path=((CreateMethodsList) map.get(key)).getClassPath();
                Element classPath = doc.createElement("classPath");
                classPath.appendChild(doc.createTextNode(path));
                ClassName.appendChild(classPath);
                for(String str:methodsName){
                    // methodName elements
                    Element methodName = doc.createElement("methodName");
                    methodName.appendChild(doc.createTextNode(str));
                    ClassName.appendChild(methodName);
                }
            }

            // write the content into xml file
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            String filePath=".\\MethodsList.xml";
            StreamResult result = new StreamResult(new File(filePath).toString().replace("%20", " "));
            //StreamResult result =  new StreamResult(System.out);
            transformer.transform(source, result);
            if(new File(".\\MethodsList.xml").exists()){
                bool=true;
            }
            // Output to console for testing
            // StreamResult result = new StreamResult(System.out);

        } catch (ParserConfigurationException pce) {
            bool=false;
            pce.printStackTrace();
        } catch (TransformerException tfe) {
            bool=false;
            tfe.printStackTrace();
        }
        return bool;
    }

    public static void main(String arg[]) throws ClassNotFoundException, IOException, InterruptedException{
        FindTestMethodsInTestClass FTMITC=new FindTestMethodsInTestClass();
        System.out.println(FTMITC.isMethodsListXMLReady());
    }
}

package com.generateUI.createXML；
导入java.io.IOException；
导入java.lang.reflect.Constructor；
导入java.io.*；
导入java.lang.reflect.Method；
导入java.net.URL；
导入java.util.ArrayList；
导入java.util.Enumeration；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.Set；
导入javax.xml.parsers.DocumentBuilder；
导入javax.xml.parsers.DocumentBuilderFactory；
导入javax.xml.parsers.parserConfiguration异常；
导入javax.xml.transform.Transformer；
导入javax.xml.transform.TransformerException；
导入javax.xml.transform.TransformerFactory；
导入javax.xml.transform.dom.DOMSource；
导入javax.xml.transform.stream.StreamResult；
导入org.testng.IAnnotationTransformer；
导入org.testng.annotations.ITestAnnotation；
导入org.testng.internal.ClassHelper；
导入org.testng.internal.annotations.AnnotationHelper；
导入org.testng.internal.annotations.IANotationFinder；
导入org.testng.internal.annotations.JDK15AnnotationFinder；
导入org.w3c.dom.Document；
导入org.w3c.dom.Element；
导入com.setup.CreateMethodsList；
公共类FindTestMethodsInTestClass{
公共布尔值IsMethodListXMLReady（）抛出ClassNotFoundException、IOException、InterruptedException{
FindTestMethodsInTestClass FTMITC=新的FindTestMethodsInTestClass（）；
布尔布尔布尔=假；
布尔值isXMLFileExist=false；
Map aMap=newhashmap（）；
Class[]classes=getClasses（“com.testscript”）；
IANotationFinder=新的JDK15AnnotationFinder（新的DummyTransformer（））；
对于（类别cls：类别）{
字符串温度=cls.toString（）；
字符串[]className=temp.split（“\\”）；
字符串[]classPaht=temp.split（“”）；
List mNames=new ArrayList（）；
设置allMethods=ClassHelper.getAvailableMethods（cls）；
如果（！（allMethods==null））{
对于（每个方法：所有方法）{
ITestAnnotation值=AnnotationHelper.findTest（finder，eachMethod）；
if（值！=null）{
mNames.add（eachMethod.getName（））；
布尔=真；
}
}
如果（bool）{
int lastIndex=className.length-1；
aMap.put（className[lastIndex]，newcreateMethodsList（mNames，classPaht[1]）；
}
}
}
if（FTMITC.CreateXML（aMap））{
isXMLFileExist=true；
}
返回isXMLFileExist；
}
公共静态类DummyTransformer实现了一个NotationTransformer{
@抑制警告（“原始类型”）
@凌驾
公共void转换（ITestAnnotation注释、类testClass、构造函数testConstructor、，
方法（测试方法）{
}
}
/**
*扫描可从上下文类加载器访问的属于给定包和子包的所有类。
*
*@param packageName基本包
*@还课
*@ClassNotFoundException
*@抛出异常
*/
私有静态类[]getClasses（String packageName）抛出ClassNotFoundException、IOException{
ClassLoader ClassLoader=Thread.currentThread（）.getContextClassLoader（）；
断言类加载器！=null；
字符串路径=packageName.replace（'.'，'/'）；
枚举资源=classLoader.getResources（路径）；
List dirs=new ArrayList（）；
System.out.println（“资源：+resources”）；
while（resources.hasMoreElements（））{
URL资源=新的URL（resources.nextElement（）.toString（）.replace（“%20”和“）；
System.out.println（“URL资源：+资源”）；
添加（新文件（resource.getFile（））；
}
ArrayList类=新的ArrayList（）；
for（文件目录：dirs）{
addAll（findClasses（目录，packageName））；
}
System.out.println（“类：”+资源）；
返回classes.toArray（新类[classes.size（）]）；
}
/**
*递归方法，用于查找给定目录和子目录中的所有类。
*
*@param directory基本目录
*@param packageName在基目录中找到的类的包名
*@还课
*@ClassNotFoundException
*/
私有静态列表FindClass（文件目录、字符串packageName）引发ClassNotFoundException{
列表类=新的ArrayList（）；
如果（！directory.exists（））{
返回类；
}
File[]files=目录.listFiles（）；
用于（文件：文件）{
if（file.isDirectory（））{
assert！file.getName（）包含（“.”）；
addAll（findClasses（文件，packageName+““+file.getName（））；
}else if（file.getName（）.endsWith（“.class”））{
Class.add（Class.forName（packageName+'.+file.getName（）.substring（0，file.getName（）.length（）-6））；
}
}
返回类；
}
公共布尔CreateXML（映射）抛出InterruptedException{
布尔布尔布尔=假；
试一试{
File File=新文件（“.\\MethodsList.xml”）；
if（file.exists（））{
delete（）；
《睡眠》（2000年）；
}
Set keys=map.keySet（）；
ListmethodsName=new ArrayList（）；
DocumentBuilderFactory docFactory=DocumentBuil