devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring加载资源文件冲突问题

作者：我家小花儿 | 2024-02-07 16:27:09

赞

踩

location pattern must not be null

title: Spring加载资源文件冲突问题 tags:

  • tomcat8
  • spring
  • mac
  • webjars
  • j2cache categories: spring date: 2017-11-14 16:42:08

背景

开发者在使用Spring做Properties文件载入时，这也是spring做placeholder的便捷之处。

classpath:和classpath*:想必也是大部分开发都会写到的文件schema。

百度一下classpath能检索到一大堆区别比如

classpath 和 classpath* 区别：

classpath：只会到你指定的class路径中查找文件;

classpath*：不仅包含class路径，还包括jar文件中(class路径)进行查找.

OK 本次说一些不同的

源码

spring在使用时如下会这样配置比如

  1.     <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  2.         <property name="locations">
  3.             <list>
  4.                 <value>classpath*:httpclient.properties</value>
  5.                 <value>classpath*:config.properties</value>
  6.                 <value>classpath*:uploadPath.properties</value>
  7.                 <value>classpath*:branches.properties</value>
  8.                 <value>classpath*:wechat.properties</value>
  9.                 <value>classpath*:email.properties</value>
  10.                 <value>classpath:j2cache.properties</value>
  11.                 <value>classpath:sso.properties</value>
  12.                 <value>classpath*:override.properties</value>
  13.             </list>
  14.         </property>
  15.     </bean>
  16. 复制代码

我们来看一下事实上该方法接受的参数是Resource[] 但是我们传递的是String Spring做了什么魔法呢？

我们简明概要的看一下关键的源码

spring在默认情况下帮我们做了一系列的Convert。我们

此处我们需要关心的是ResourceArray

  1.     /**
  2.      * Treat the given text as a location pattern and convert it to a Resource array.
  3.      */
  4.     @Override
  5.     public void setAsText(String text) {
  6.        String pattern = resolvePath(text).trim();
  7.        try {
  8.           setValue(this.resourcePatternResolver.getResources(pattern));
  9.        }
  10.        catch (IOException ex) {
  11.           throw new IllegalArgumentException(
  12.                 "Could not resolve resource location pattern [" + pattern + "]: " + ex.getMessage());
  13.        }
  14.     }
  15. 复制代码

看到了关键代码resourcePatternResolver.getResources

  1.     public Resource[] getResources(String locationPattern) throws IOException {
  2.        Assert.notNull(locationPattern, "Location pattern must not be null");
  3.        if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
  4.           // a class path resource (multiple resources for same name possible)
  5.           if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
  6.              // a class path resource pattern
  7.              return findPathMatchingResources(locationPattern);
  8.           }
  9.           else {
  10.              // all class path resources with the given name
  11.              return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
  12.           }
  13.        }
  14.        else {
  15.           // Only look for a pattern after a prefix here
  16.           // (to not get fooled by a pattern symbol in a strange prefix).
  17.           int prefixEnd = locationPattern.indexOf(":") + 1;
  18.           if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
  19.              // a file pattern
  20.              return findPathMatchingResources(locationPattern);
  21.           }
  22.           else {
  23.              // a single resource with the given name
  24.              return new Resource[] {getResourceLoader().getResource(locationPattern)};
  25.           }
  26.        }
  27.     }
  28. 复制代码

很明显可以看到对于classpath*做了特殊处理

那么对于classpath:打头的呢 事实上到最后都将走到DefaultResourceLoader中getResource方法

  1.     public Resource getResource(String location) {
  2.        Assert.notNull(location, "Location must not be null");
  3.        if (location.startsWith(CLASSPATH_URL_PREFIX)) {
  4.           return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
  5.        }
  6.        else {
  7.           try {
  8.              // Try to parse the location as a URL...
  9.              URL url = new URL(location);
  10.              return new UrlResource(url);
  11.           }
  12.           catch (MalformedURLException ex) {
  13.              // No URL -> resolve as resource path.
  14.              return getResourceByPath(location);
  15.           }
  16.        }
  17.     }
  18. 复制代码

对于classpath:打头的资源文件将返回classpathResource 否则返回UrlResource

对于classpath*的文件会优先做一次匹配如下

  1.     /**
  2.      * Find all class location resources with the given location via the ClassLoader.
  3.      * @param location the absolute path within the classpath
  4.      * @return the result as Resource array
  5.      * @throws IOException in case of I/O errors
  6.      * @see java.lang.ClassLoader#getResources
  7.      * @see #convertClassLoaderURL
  8.      */
  9.     protected Resource[] findAllClassPathResources(String location) throws IOException {
  10.        String path = location;
  11.        if (path.startsWith("/")) {
  12.           path = path.substring(1);
  13.        }
  14.        Enumeration<URL> resourceUrls = getClassLoader().getResources(path);
  15.        Set<Resource> result = new LinkedHashSet<Resource>(16);
  16.        while (resourceUrls.hasMoreElements()) {
  17.           URL url = resourceUrls.nextElement();
  18.           result.add(convertClassLoaderURL(url));
  19.        }
  20.        return result.toArray(new Resource[result.size()]);
  21.     }
  22.      
  23.     /**
  24.      * Convert the given URL as returned from the ClassLoader into a Resource object.
  25.      * <p>The default implementation simply creates a UrlResource instance.
  26.      * @param url a URL as returned from the ClassLoader
  27.      * @return the corresponding Resource object
  28.      * @see java.lang.ClassLoader#getResources
  29.      * @see org.springframework.core.io.Resource
  30.      */
  31.     protected Resource convertClassLoaderURL(URL url) {
  32.        return new UrlResource(url);
  33.     }
  34. 复制代码

也就是返回UrlResource【从上述代码可以见到集合为LinkedHashSet】

回到classpath上来 一个classpathResource文件如何找到对应的资源呢？

一般来说都是调用classLoader的getReource方法

  1.     /**
  2.      * Finds the resource with the given name.  A resource is some data
  3.      * (images, audio, text, etc) that can be accessed by class code in a way
  4.      * that is independent of the location of the code.
  5.      *
  6.      * <p> The name of a resource is a '<tt>/</tt>'-separated path name that
  7.      * identifies the resource.
  8.      *
  9.      * <p> This method will first search the parent class loader for the
  10.      * resource; if the parent is <tt>null</tt> the path of the class loader
  11.      * built-in to the virtual machine is searched.  That failing, this method
  12.      * will invoke {@link #findResource(String)} to find the resource.  </p>
  13.      *
  14.      * @param  name
  15.      *         The resource name
  16.      *
  17.      * @return  A <tt>URL</tt> object for reading the resource, or
  18.      *          <tt>null</tt> if the resource could not be found or the invoker
  19.      *          doesn't have adequate  privileges to get the resource.
  20.      *
  21.      * @since  1.1
  22.      */
  23.     public URL getResource(String name) {
  24.         URL url;
  25.         if (parent != null) {
  26.             url = parent.getResource(name);
  27.         } else {
  28.             url = getBootstrapResource(name);
  29.         }
  30.         if (url == null) {
  31.             url = findResource(name);
  32.         }
  33.         return url;
  34.     }
  35. 复制代码

这是一个典型的委托模型的结构 从最下面的classLoader一直回溯到BootstrapLoader 逐渐寻找

我们可以认为在tomcat容器中一个配置文件通常需要由WebappClassLoader进行加载

而在tomcat7.0.70中代码如下【我们忽略需要向parent获取资源文件的过程】

当不同jar中包含同一个名称的资源文件时那么会做何种操作呢？

我们先看一下如何加载jar的顺序的。

在tomcat7.0.70中tomcat的classloader会作如下操作

  1.     NamingEnumeration<NameClassPair> enumeration = null;
  2.     try {
  3.         enumeration = libDir.list("");
  4.     } catch (NamingException e) {
  5.         IOException ioe = new IOException(sm.getString(
  6.                 "webappLoader.namingFailure", libPath));
  7.         ioe.initCause(e);
  8.         throw ioe;
  9.     }
  10. 复制代码

也就是以libDir的list的结果加入对应jar

  1.     /**
  2.      * Enumerates the names bound in the named context, along with the class
  3.      * names of objects bound to them.
  4.      *
  5.      * @param name the name of the context to list
  6.      * @return an enumeration of the names and class names of the bindings in
  7.      * this context. Each element of the enumeration is of type NameClassPair.
  8.      * @exception NamingException if a naming exception is encountered
  9.      */
  10.     @Override
  11.     public NamingEnumeration<NameClassPair> list(String name)
  12.         throws NamingException {
  13.      
  14.         if (!aliases.isEmpty()) {
  15.             AliasResult result = findAlias(name);
  16.             if (result.dirContext != null) {
  17.                 return result.dirContext.list(result.aliasName);
  18.             }
  19.         }
  20.      
  21.         // Next do a standard lookup
  22.         List<NamingEntry> bindings = doListBindings(name);
  23.      
  24.         // Check the alternate locations
  25.         List<NamingEntry> altBindings = null;
  26.      
  27.         String resourceName = "/META-INF/resources" + name;
  28.         for (DirContext altDirContext : altDirContexts) {
  29.             if (altDirContext instanceof BaseDirContext) {
  30.                 altBindings = ((BaseDirContext) altDirContext).doListBindings(resourceName);
  31.             }
  32.             if (altBindings != null) {
  33.                 if (bindings == null) {
  34.                     bindings = altBindings;
  35.                 } else {
  36.                     bindings.addAll(altBindings);
  37.                 }
  38.             }
  39.         }
  40.      
  41.         if (bindings != null) {
  42.             return new NamingContextEnumeration(bindings.iterator());
  43.         }
  44.      
  45.         // Really not found
  46.         throw new NameNotFoundException(
  47.                 sm.getString("resources.notFound", name));
  48.     }
  49. 复制代码

META-INF/resource多么熟悉的文件夹，这也是为啥出现了WebJar这类的jar的原因 通过META-INF/resource的映射可以在对应地方找到资源文件

这样我们也可以找到WebJar的代码

继续查看如下

  1.     /**
  2.      * Enumerates the names bound in the named context, along with the
  3.      * objects bound to them. The contents of any subcontexts are not
  4.      * included.
  5.      * <p>
  6.      * If a binding is added to or removed from this context, its effect on
  7.      * an enumeration previously returned is undefined.
  8.      *
  9.      * @param name the name of the context to list
  10.      * @return an enumeration of the bindings in this context.
  11.      * Each element of the enumeration is of type Binding.
  12.      * @exception NamingException if a naming exception is encountered
  13.      */
  14.     @Override
  15.     protected List<NamingEntry> doListBindings(String name)
  16.         throws NamingException {
  17.      
  18.         File file = file(name);
  19.      
  20.         if (file == null)
  21.             return null;
  22.          
  23.         return list(file);
  24.      
  25.     }
  26.     /**
  27.      * Return a File object representing the specified normalized
  28.      * context-relative path if it exists and is readable.  Otherwise,
  29.      * return <code>null</code>.
  30.      *
  31.      * @param name Normalized context-relative path (with leading '/')
  32.      */
  33.     protected File file(String name) {
  34.      
  35.         File file = new File(base, name);
  36.         if (file.exists() && file.canRead()) {
  37.      
  38.             if (allowLinking)
  39.                 return file;
  40.              
  41.             // Check that this file belongs to our root path
  42.             String canPath = null;
  43.             try {
  44.                 canPath = file.getCanonicalPath();
  45.             } catch (IOException e) {
  46.                 // Ignore
  47.             }
  48.             if (canPath == null)
  49.                 return null;
  50.      
  51.             // Check to see if going outside of the web application root
  52.             if (!canPath.startsWith(absoluteBase)) {
  53.                 return null;
  54.             }
  55.      
  56.             // Case sensitivity check - this is now always done
  57.             String fileAbsPath = file.getAbsolutePath();
  58.             if (fileAbsPath.endsWith("."))
  59.                 fileAbsPath = fileAbsPath + "/";
  60.             String absPath = normalize(fileAbsPath);
  61.             canPath = normalize(canPath);
  62.             if ((absoluteBase.length() < absPath.length())
  63.                 && (absoluteBase.length() < canPath.length())) {
  64.                 absPath = absPath.substring(absoluteBase.length() + 1);
  65.                 if (absPath.equals(""))
  66.                     absPath = "/";
  67.                 canPath = canPath.substring(absoluteBase.length() + 1);
  68.                 if (canPath.equals(""))
  69.                     canPath = "/";
  70.                 if (!canPath.equals(absPath))
  71.                     return null;
  72.             }
  73.      
  74.         } else {
  75.             return null;
  76.         }
  77.         return file;
  78.      
  79.     }
  80.     /**
  81.      * List the resources which are members of a collection.
  82.      *
  83.      * @param file Collection
  84.      * @return Vector containing NamingEntry objects
  85.      */
  86.     protected List<NamingEntry> list(File file) {
  87.      
  88.         List<NamingEntry> entries = new ArrayList<NamingEntry>();
  89.         if (!file.isDirectory())
  90.             return entries;
  91.         String[] names = file.list();
  92.         if (names==null) {
  93.             /* Some IO error occurred such as bad file permissions.
  94.                Prevent a NPE with Arrays.sort(names) */
  95.             log.warn(sm.getString("fileResources.listingNull",
  96.                                   file.getAbsolutePath()));
  97.             return entries;
  98.         }
  99.      
  100.         Arrays.sort(names);             // Sort alphabetically
  101.         NamingEntry entry = null;
  102.      
  103.         for (int i = 0; i < names.length; i++) {
  104.      
  105.             File currentFile = new File(file, names[i]);
  106.             Object object = null;
  107.             if (currentFile.isDirectory()) {
  108.                 FileDirContext tempContext = new FileDirContext(env);
  109.                 tempContext.setDocBase(currentFile.getPath());
  110.                 tempContext.setAllowLinking(getAllowLinking());
  111.                 object = tempContext;
  112.             } else {
  113.                 object = new FileResource(currentFile);
  114.             }
  115.             entry = new NamingEntry(names[i], object, NamingEntry.ENTRY);
  116.             entries.add(entry);
  117.      
  118.         }
  119.      
  120.         return entries;
  121.      
  122.     }
  123. 复制代码

一个Arrays.sort(names); 可以看出下面返回的结果将是按照字典序进行排列的。

那么对应的在tomcat中调用classLoader如下

  1.     /**
  2.      * Find the specified resource in our local repository, and return a
  3.      * <code>URL</code> referring to it, or <code>null</code> if this resource
  4.      * cannot be found.
  5.      *
  6.      * @param name Name of the resource to be found
  7.      */
  8.     @Override
  9.     public URL findResource(final String name) {
  10.      
  11.         if (log.isDebugEnabled())
  12.             log.debug("    findResource(" + name + ")");
  13.      
  14.         URL url = null;
  15.         String path = nameToPath(name);
  16.          
  17.         if (hasExternalRepositories && searchExternalFirst)
  18.             url = super.findResource(name);
  19.      
  20.         if (url == null) {
  21.             ResourceEntry entry = resourceEntries.get(path);
  22.             if (entry == null) {
  23.                 if (securityManager != null) {
  24.                     PrivilegedAction<ResourceEntry> dp =
  25.                         new PrivilegedFindResourceByName(name, path, false);
  26.                     entry = AccessController.doPrivileged(dp);
  27.                 } else {
  28.                     entry = findResourceInternal(name, path, false);
  29.                 }
  30.             }
  31.             if (entry != null) {
  32.                 url = entry.source;
  33.             }
  34.         }
  35.      
  36.         if ((url == null) && hasExternalRepositories && !searchExternalFirst)
  37.             url = super.findResource(name);
  38.      
  39.         if (log.isDebugEnabled()) {
  40.             if (url != null)
  41.                 log.debug("    --> Returning '" + url.toString() + "'");
  42.             else
  43.                 log.debug("    --> Resource not found, returning null");
  44.         }
  45.         return (url);
  46.      
  47.     }
  48. 复制代码

而在对应的findResourceInternal方法

  1.     /**
  2.      * Find specified resource in local repositories.
  3.      *
  4.      * @return the loaded resource, or null if the resource isn't found
  5.      */
  6.     protected ResourceEntry findResourceInternal(final String name, final String path,
  7.             final boolean manifestRequired) {
  8.      
  9.         if (!started) {
  10.             log.info(sm.getString("webappClassLoader.stopped", name));
  11.             return null;
  12.         }
  13.      
  14.         if ((name == null) || (path == null))
  15.             return null;
  16.      
  17.         JarEntry jarEntry = null;
  18.         // Need to skip the leading / to find resoucres in JARs
  19.         String jarEntryPath = path.substring(1);
  20.      
  21.         ResourceEntry entry = resourceEntries.get(path);
  22.         if (entry != null) {
  23.             if (manifestRequired && entry.manifest == MANIFEST_UNKNOWN) {
  24.                 // This resource was added to the cache when a request was made
  25.                 // for the resource that did not need the manifest. Now the
  26.                 // manifest is required, the cache entry needs to be updated.
  27.                 synchronized (jarFiles) {
  28.                     if (openJARs()) {
  29.                         for (int i = 0; i < jarFiles.length; i++) {
  30.      
  31.                             jarEntry = jarFiles[i].getJarEntry(jarEntryPath);
  32.      
  33.                             if (jarEntry != null) {
  34.                                 try {
  35.                                     entry.manifest = jarFiles[i].getManifest();
  36.                                 } catch (IOException ioe) {
  37.                                     // Ignore
  38.                                 }
  39.                                 break;
  40.                             }
  41.                          }
  42.                      }
  43.                 }
  44.             }
  45.             return entry;
  46.         }
  47.      
  48.         int contentLength = -1;
  49.         InputStream binaryStream = null;
  50.         boolean isClassResource = path.endsWith(CLASS_FILE_SUFFIX);
  51.         boolean isCacheable = isClassResource;
  52.         if (!isCacheable) {
  53.              isCacheable = path.startsWith(SERVICES_PREFIX);
  54.         }
  55.      
  56.         int jarFilesLength = jarFiles.length;
  57.         int repositoriesLength = repositories.length;
  58.      
  59.         int i;
  60.      
  61.         Resource resource = null;
  62.      
  63.         boolean fileNeedConvert = false;
  64.      
  65.         for (i = 0; (entry == null) && (i < repositoriesLength); i++) {
  66.             try {
  67.      
  68.                 String fullPath = repositories[i] + path;
  69.      
  70.                 Object lookupResult = resources.lookup(fullPath);
  71.                 if (lookupResult instanceof Resource) {
  72.                     resource = (Resource) lookupResult;
  73.                 }
  74.      
  75.                 // Note : Not getting an exception here means the resource was
  76.                 // found
  77.      
  78.                 ResourceAttributes attributes =
  79.                     (ResourceAttributes) resources.getAttributes(fullPath);
  80.                 contentLength = (int) attributes.getContentLength();
  81.                 String canonicalPath = attributes.getCanonicalPath();
  82.                 if (canonicalPath != null) {
  83.                     // we create the ResourceEntry based on the information returned
  84.                     // by the DirContext rather than just using the path to the
  85.                     // repository. This allows to have smart DirContext implementations
  86.                     // that "virtualize" the docbase (e.g. Eclipse WTP)
  87.                     entry = findResourceInternal(new File(canonicalPath), "");
  88.                 } else {
  89.                     // probably a resource not in the filesystem (e.g. in a
  90.                     // packaged war)
  91.                     entry = findResourceInternal(files[i], path);
  92.                 }
  93.                 entry.lastModified = attributes.getLastModified();
  94.      
  95.                 if (resource != null) {
  96.      
  97.      
  98.                     try {
  99.                         binaryStream = resource.streamContent();
  100.                     } catch (IOException e) {
  101.                         return null;
  102.                     }
  103.      
  104.                     if (needConvert) {
  105.                         if (path.endsWith(".properties")) {
  106.                             fileNeedConvert = true;
  107.                         }
  108.                     }
  109.      
  110.                     // Register the full path for modification checking
  111.                     // Note: Only syncing on a 'constant' object is needed
  112.                     synchronized (allPermission) {
  113.      
  114.                         int j;
  115.      
  116.                         long[] result2 =
  117.                             new long[lastModifiedDates.length + 1];
  118.                         for (j = 0; j < lastModifiedDates.length; j++) {
  119.                             result2[j] = lastModifiedDates[j];
  120.                         }
  121.                         result2[lastModifiedDates.length] = entry.lastModified;
  122.                         lastModifiedDates = result2;
  123.      
  124.                         String[] result = new String[paths.length + 1];
  125.                         for (j = 0; j < paths.length; j++) {
  126.                             result[j] = paths[j];
  127.                         }
  128.                         result[paths.length] = fullPath;
  129.                         paths = result;
  130.      
  131.                     }
  132.      
  133.                 }
  134.      
  135.             } catch (NamingException e) {
  136.                 // Ignore
  137.             }
  138.         }
  139.      
  140.         if ((entry == null) && (notFoundResources.containsKey(name)))
  141.             return null;
  142.      
  143.         synchronized (jarFiles) {
  144.      
  145.             try {
  146.                 if (!openJARs()) {
  147.                     return null;
  148.                 }
  149.                 for (i = 0; (entry == null) && (i < jarFilesLength); i++) {
  150.      
  151.                     jarEntry = jarFiles[i].getJarEntry(jarEntryPath);
  152.      
  153.                     if (jarEntry != null) {
  154.      
  155.                         entry = new ResourceEntry();
  156.                         try {
  157.                             entry.codeBase = getURI(jarRealFiles[i]);
  158.                             entry.source =
  159.                                     UriUtil.buildJarUrl(entry.codeBase.toString(), jarEntryPath);
  160.                             entry.lastModified = jarRealFiles[i].lastModified();
  161.                         } catch (MalformedURLException e) {
  162.                             return null;
  163.                         }
  164.                         contentLength = (int) jarEntry.getSize();
  165.                         try {
  166.                             if (manifestRequired) {
  167.                                 entry.manifest = jarFiles[i].getManifest();
  168.                             } else {
  169.                                 entry.manifest = MANIFEST_UNKNOWN;
  170.                             }
  171.                             binaryStream = jarFiles[i].getInputStream(jarEntry);
  172.                         } catch (IOException e) {
  173.                             return null;
  174.                         }
  175.      
  176.                         // Extract resources contained in JAR to the workdir
  177.                         if (antiJARLocking && !(path.endsWith(CLASS_FILE_SUFFIX))) {
  178.                             byte[] buf = new byte[1024];
  179.                             File resourceFile = new File(loaderDir, jarEntry.getName());
  180.                             if (!resourceFile.exists()) {
  181.                                 Enumeration<JarEntry> entries = jarFiles[i].entries();
  182.                                 while (entries.hasMoreElements()) {
  183.                                     JarEntry jarEntry2 =  entries.nextElement();
  184.                                     if (!(jarEntry2.isDirectory()) &&
  185.                                             (!jarEntry2.getName().endsWith(CLASS_FILE_SUFFIX))) {
  186.                                         resourceFile = new File(loaderDir, jarEntry2.getName());
  187.                                         try {
  188.                                             if (!resourceFile.getCanonicalPath().startsWith(
  189.                                                     canonicalLoaderDir)) {
  190.                                                 throw new IllegalArgumentException(
  191.                                                         sm.getString("webappClassLoader.illegalJarPath",
  192.                                                                 jarEntry2.getName()));
  193.                                             }
  194.                                         } catch (IOException ioe) {
  195.                                             throw new IllegalArgumentException(
  196.                                                     sm.getString("webappClassLoader.validationErrorJarPath",
  197.                                                             jarEntry2.getName()), ioe);
  198.                                         }
  199.                                         File parentFile = resourceFile.getParentFile();
  200.                                         if (!parentFile.mkdirs() && !parentFile.exists()) {
  201.                                             // Ignore the error (like the IOExceptions below)
  202.                                         }
  203.                                         FileOutputStream os = null;
  204.                                         InputStream is = null;
  205.                                         try {
  206.                                             is = jarFiles[i].getInputStream(jarEntry2);
  207.                                             os = new FileOutputStream(resourceFile);
  208.                                             while (true) {
  209.                                                 int n = is.read(buf);
  210.                                                 if (n <= 0) {
  211.                                                     break;
  212.                                                 }
  213.                                                 os.write(buf, 0, n);
  214.                                             }
  215.                                             resourceFile.setLastModified(jarEntry2.getTime());
  216.                                         } catch (IOException e) {
  217.                                             // Ignore
  218.                                         } finally {
  219.                                             try {
  220.                                                 if (is != null) {
  221.                                                     is.close();
  222.                                                 }
  223.                                             } catch (IOException e) {
  224.                                                 // Ignore
  225.                                             }
  226.                                             try {
  227.                                                 if (os != null) {
  228.                                                     os.close();
  229.                                                 }
  230.                                             } catch (IOException e) {
  231.                                                 // Ignore
  232.                                             }
  233.                                         }
  234.                                     }
  235.                                 }
  236.                             }
  237.                         }
  238.                     }
  239.                 }
  240.      
  241.                 if (entry == null) {
  242.                     synchronized (notFoundResources) {
  243.                         notFoundResources.put(name, name);
  244.                     }
  245.                     return null;
  246.                 }
  247.      
  248.                 /* Only cache the binary content if there is some content
  249.                  * available one of the following is true:
  250.                  * a) It is a class file since the binary content is only cached
  251.                  *    until the class has been loaded
  252.                  *    or
  253.                  * b) The file needs conversion to address encoding issues (see
  254.                  *    below)
  255.                  *    or
  256.                  * c) The resource is a service provider configuration file located
  257.                  *    under META=INF/services
  258.                  *
  259.                  * In all other cases do not cache the content to prevent
  260.                  * excessive memory usage if large resources are present (see
  261.                  * https://bz.apache.org/bugzilla/show_bug.cgi?id=53081).
  262.                  */
  263.                 if (binaryStream != null && (isCacheable || fileNeedConvert)) {
  264.      
  265.                     byte[] binaryContent = new byte[contentLength];
  266.      
  267.                     int pos = 0;
  268.                     try {
  269.                         while (true) {
  270.                             int n = binaryStream.read(binaryContent, pos,
  271.                                                       binaryContent.length - pos);
  272.                             if (n <= 0)
  273.                                 break;
  274.                             pos += n;
  275.                         }
  276.                     } catch (IOException e) {
  277.                         log.error(sm.getString("webappClassLoader.readError", name), e);
  278.                         return null;
  279.                     }
  280.                     if (fileNeedConvert) {
  281.                         // Workaround for certain files on platforms that use
  282.                         // EBCDIC encoding, when they are read through FileInputStream.
  283.                         // See commit message of rev.303915 for details
  284.                         // http://svn.apache.org/viewvc?view=revision&revision=303915
  285.                         String str = new String(binaryContent,0,pos);
  286.                         try {
  287.                             binaryContent = str.getBytes(CHARSET_UTF8);
  288.                         } catch (Exception e) {
  289.                             return null;
  290.                         }
  291.                     }
  292.                     entry.binaryContent = binaryContent;
  293.      
  294.                     // The certificates are only available after the JarEntry
  295.                     // associated input stream has been fully read
  296.                     if (jarEntry != null) {
  297.                         entry.certificates = jarEntry.getCertificates();
  298.                     }
  299.      
  300.                 }
  301.             } finally {
  302.                 if (binaryStream != null) {
  303.                     try {
  304.                         binaryStream.close();
  305.                     } catch (IOException e) { /* Ignore */}
  306.                 }
  307.             }
  308.         }
  309.      
  310.         if (isClassResource && entry.binaryContent != null &&
  311.                 this.transformers.size() > 0) {
  312.             // If the resource is a class just being loaded, decorate it
  313.             // with any attached transformers
  314.             String className = name.endsWith(CLASS_FILE_SUFFIX) ?
  315.                     name.substring(0, name.length() - CLASS_FILE_SUFFIX.length()) : name;
  316.             String internalName = className.replace(".", "/");
  317.      
  318.             for (ClassFileTransformer transformer : this.transformers) {
  319.                 try {
  320.                     byte[] transformed = transformer.transform(
  321.                             this, internalName, null, null, entry.binaryContent
  322.                     );
  323.                     if (transformed != null) {
  324.                         entry.binaryContent = transformed;
  325.                     }
  326.                 } catch (IllegalClassFormatException e) {
  327.                     log.error(sm.getString("webappClassLoader.transformError", name), e);
  328.                     return null;
  329.                 }
  330.             }
  331.         }
  332.      
  333.         // Add the entry in the local resource repository
  334.         synchronized (resourceEntries) {
  335.             // Ensures that all the threads which may be in a race to load
  336.             // a particular class all end up with the same ResourceEntry
  337.             // instance
  338.             ResourceEntry entry2 = resourceEntries.get(path);
  339.             if (entry2 == null) {
  340.                 resourceEntries.put(path, entry);
  341.             } else {
  342.                 entry = entry2;
  343.             }
  344.         }
  345.      
  346.         return entry;
  347.      
  348.     }
  349. 复制代码

很明显其实按照之前的file的顺序来做的遍历 返回第一个即可。

在mac新版本系统【macos high-sierra】和tomcat8的组合中发生了资源文件加载覆盖的问题【目前tomcat7无问题】 初步怀疑tomcat8中classloader更换了实现

同时mac新版本在升级时也更换了实现导致出现聪明的资源文件时加载顺序不一致 出现部分资源定义无法加载的错误

tomcat8中未作排序

  1.     @Override
  2.     public String[] list(String path) {
  3.         checkPath(path);
  4.         String webAppMount = getWebAppMount();
  5.         if (path.startsWith(webAppMount)) {
  6.             File f = file(path.substring(webAppMount.length()), true);
  7.             if (f == null) {
  8.                 return EMPTY_STRING_ARRAY;
  9.             }
  10.             String[] result = f.list();
  11.             if (result == null) {
  12.                 return EMPTY_STRING_ARRAY;
  13.             } else {
  14.                 return result;
  15.             }
  16.         } else {
  17.             if (!path.endsWith("/")) {
  18.                 path = path + "/";
  19.             }
  20.             if (webAppMount.startsWith(path)) {
  21.                 int i = webAppMount.indexOf('/', path.length());
  22.                 if (i == -1) {
  23.                     return new String[] {webAppMount.substring(path.length())};
  24.                 } else {
  25.                     return new String[] {
  26.                             webAppMount.substring(path.length(), i)};
  27.                 }
  28.             }
  29.             return EMPTY_STRING_ARRAY;
  30.         }
  31.     }
  32. 复制代码

tomcat8直接调用f.list 并未作排序

  1.     /**
  2.      * Returns an array of strings naming the files and directories in the
  3.      * directory denoted by this abstract pathname.
  4.      *
  5.      * <p> If this abstract pathname does not denote a directory, then this
  6.      * method returns {@code null}.  Otherwise an array of strings is
  7.      * returned, one for each file or directory in the directory.  Names
  8.      * denoting the directory itself and the directory's parent directory are
  9.      * not included in the result.  Each string is a file name rather than a
  10.      * complete path.
  11.      *
  12.      * <p> There is no guarantee that the name strings in the resulting array
  13.      * will appear in any specific order; they are not, in particular,
  14.      * guaranteed to appear in alphabetical order.
  15.      *
  16.      * <p> Note that the {@link java.nio.file.Files} class defines the {@link
  17.      * java.nio.file.Files#newDirectoryStream(Path) newDirectoryStream} method to
  18.      * open a directory and iterate over the names of the files in the directory.
  19.      * This may use less resources when working with very large directories, and
  20.      * may be more responsive when working with remote directories.
  21.      *
  22.      * @return  An array of strings naming the files and directories in the
  23.      *          directory denoted by this abstract pathname.  The array will be
  24.      *          empty if the directory is empty.  Returns {@code null} if
  25.      *          this abstract pathname does not denote a directory, or if an
  26.      *          I/O error occurs.
  27.      *
  28.      * @throws  SecurityException
  29.      *          If a security manager exists and its {@link
  30.      *          SecurityManager#checkRead(String)} method denies read access to
  31.      *          the directory
  32.      */
  33.     public String[] list() {
  34.         SecurityManager security = System.getSecurityManager();
  35.         if (security != null) {
  36.             security.checkRead(path);
  37.         }
  38.         return fs.list(this);
  39.     }
  40. 复制代码

而list方法写的比较清楚这个顺序不受保证【通常意义是字典序但是不保证】

  1.     There is no guarantee that the name strings in the resulting array
  2.      will appear in any specific order; they are not, in particular,
  3.      guaranteed to appear in alphabetical order.
  4. 复制代码

因此部分小伙伴升级mac新系统使用tomcat8时出现了加载顺序不一致

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/66391
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号