我可以在 EJB 3 容器内的类路径中动态发现 xml 文件吗？

Question

背景：

我们项目的组件之一使用 spring 运行。一些 SQL 代码是根据给定的 XML spring 配置动态生成的。

起初，将所有 XML 配置存储在类路径上的同一个包中（然后在调用服务时将其作为资源加载）是可以的，但随着时间的推移，我们最终会得到大量配置。是时候将配置分成不同的命名空间了。

目标

我想要的是，给定类路径上的起始包，递归地遍历目录结构并动态发现任何 spring XML 文件。 （这样当添加新的配置/包时，服务仍然可以找到这些文件）。

问题

当我在 EJB 容器外运行时，通过使用 Thread.getContextClassloader().getResource(myBasePackage) ，然后获取 File 对象并使用它在文件系统上遍历树。我知道，它很笨重，但它仍然是类路径相关的，而且它有效。

但是，您无法在 EJB 容器内执行此操作（您根本无法与文件系统交互），因此我不得不使用相当烦人的解决方法，其中我维护一个要搜索的硬编码包列表。

问题

是否有一种方法（在 EJB 容器内运行）动态遍历类路径（从给定的起始位置）搜索任意资源？

Answer 1

简短的回答：在遵守 EJB 规范的情况下不会。因为规范设想容器在各种非标准情况下运行，所以它并没有使这成为可能。

更长的答案：由于您不是动态创建这些资源，因此我会编写一个例程，在构建时为您提供所有资源的列表，并将它们放入您的 EJB 知道如何引用的动态生成的文件中。因此，您基本上创建了一个包和文件的目录列表，您可以在一个主文件中引用的 EJB 中加载这些包和文件。

Spring 答案：Spring 支持在类路径上查找资源，尽管我不知道这在 EJB 上下文中效果如何（并且我怀疑它是否符合 EJB，但我没有检查过）。一些细节在这里。

Answer 2

免责声明：正如已经指出的，不建议在类路径中创建资源，并且根据 EJB 容器明确禁止创建资源。这可能会给您带来很多问题，因为容器可能会将您的资源分解到另一个文件夹中，甚至在整个集群中复制资源（如果是这种情况）。为了动态创建资源，您必须创建一个自定义类加载器。所以，我永远不会这样做。直接访问文件系统比访问类路径更好。如果您使用远程文件系统+文件锁，它就不那么难看了，并且最终是集群安全的。

如果即使在我解释之后您仍然想使用类路径，您可以尝试执行以下操作：通过

ClassLoader cld = Thread.currentThread().getContextClassLoader();

从基础包开始枚举所有出现的

Enumeration<URL> basePackageUrls = cld.getResources(basePackagePath);

情况来获取类加载器每个 URL 通常是文件链接 (file:///home /scott/.../MyResource.properties）或 jar 链接（file:///lib.jar!/com/domain/MyResource.properties）。您必须检查 URL 中的模式。使用它，使用普通的 java API 枚举文件夹的内容并找到子包。继续操作，直到扫描完所有包裹。

请参阅下面的课程（很快将与我的开源项目一起发布）。它实现了一个类路径扫描器，您可以在选择器中传递该扫描器。它的工作方式就像一个访客。这是我为你做的工作，如果没有，请从中获取想法。请参阅最后的示例注释选择器。

public class ClasspathScanner
{

    private static final Log log = LogFactory.getLog(ClasspathScanner.class);
    private static final String JAR_FILE_PATTERN = ".jar!";

    private ClassSelector selector;
    private Set<Class<?>> classes;

    // PUBLIC METHODS ------------------------------------------------------------------------------

    public synchronized Set<Class<?>> scanPackage(String basePackage, ClassSelector selector)
        throws Exception
    {
        if (selector == null)
        {
            throw new NullPointerException("Selector cannot be NULL");
        }
        this.selector = selector;
        this.classes = new HashSet<Class<?>>();
        Set<Class<?>> aux;
        try
        {
            scanClasses0(basePackage);
            aux = this.classes;
        }
        finally
        {
            this.selector = null;
            this.classes = null;
        }

        return aux;
    }

    // HELPER CLASSES ------------------------------------------------------------------------------

    private void scanClasses0(String basePackage)
        throws IOException, ClassNotFoundException, FileNotFoundException
    {
        File packageDirectory = null;
        ClassLoader cld = getLoader();
        String basePackagePath = basePackage.replace('.', '/');
        Enumeration<URL> basePackageUrls = cld.getResources(basePackagePath);
        if (basePackageUrls == null || !basePackageUrls.hasMoreElements())
        {
            throw new ClassNotFoundException("Base package path not found: [" + basePackagePath
                + "]");
        }
        while (basePackageUrls.hasMoreElements())
        {
            String packagePath = basePackageUrls.nextElement().getFile();
            if (packagePath.contains(JAR_FILE_PATTERN))
            {
                scanJarFile(basePackagePath, packagePath);
            }
            else
            {
                packageDirectory = new File(packagePath);
                scanDirectory(basePackage, packageDirectory);
            }
        }
    }

    private void scanDirectory(String packageName, File packagePath)
        throws ClassNotFoundException, FileNotFoundException
    {
        if (packagePath.exists())
        {
            File[] packageFiles = packagePath.listFiles();
            for (File file : packageFiles)
            {
                if (file.isFile() && file.getName().endsWith(".class"))
                {
                    String fullFileName = packageName + '.' + file.getName();
                    checkClass(fullFileName);
                }
                else if (file.isDirectory())
                {
                    scanDirectory(packageName + "." + file.getName(), file);
                }
            }
        }
        else
        {
            throw new FileNotFoundException(packagePath.getPath());
        }
    }

    private void scanJarFile(String basePackagePath, String jarFileUrl)
        throws IOException, ClassNotFoundException
    {
        String jarFilePath = jarFileUrl.substring("file:".length(), jarFileUrl
            .indexOf(JAR_FILE_PATTERN)
            + JAR_FILE_PATTERN.length() - 1);
        log.debug("URL JAR file path: [" + jarFilePath + "]");
        jarFilePath = URLDecoder.decode(jarFilePath, "UTF-8");
        log.debug("Decoded JAR file path: [" + jarFilePath + "]");
        JarFile jar = new JarFile(new File(jarFilePath));
        for (Enumeration<JarEntry> jarFiles = jar.entries(); jarFiles.hasMoreElements();)
        {
            JarEntry file = jarFiles.nextElement();
            String fileName = file.getName();
            if (!file.isDirectory() && fileName.endsWith(".class")
                && fileName.startsWith(basePackagePath))
            {
                String className = fileName.replace('/', '.');
                checkClass(className);
            }
        }
    }

    private void checkClass(String fullFilePath) throws ClassNotFoundException
    {
        String className = fullFilePath.substring(0, fullFilePath.length() - 6);
        Class<?> c = getLoader().loadClass(className);
        if (selector.select(c))
        {
            classes.add(c);
        }
    }

    private ClassLoader getLoader()
    {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        if (loader == null)
        {
            loader = getClass().getClassLoader();
        }
        return loader;
    }

    // INNER CLASSES -------------------------------------------------------------------------------

    public interface ClassSelector
    {
        boolean select(Class<?> clazz);
    }

    public static class AnnotatedClassSelector implements ClassSelector
    {
        private final Class<? extends Annotation>[] annotations;

        public AnnotatedClassSelector(Class<? extends Annotation>... annotations)
        {
            this.annotations = annotations;
        }

        public boolean select(Class<?> clazz)
        {
            for (Class<? extends Annotation> ac : annotations)
            {
                if (clazz.isAnnotationPresent(ac))
                {
                    return true;
                }
            }
            return false;
        }
    }
}