gt: 				if (entryPath.startsWith(rootEntryPath)) {
context: package com.lakeside.core.resource;
  
  import com.google.common.collect.Lists;
  import com.lakeside.core.utils.ResourceUtils;
  import com.lakeside.core.utils.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.JarURLConnection;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.net.URLConnection;
  import java.util.*;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  
  /**
   * A implementation that is able to resolve a
   * specified resource location path into one or more matching Resources.
   * The source path may be a simple path which has a one-to-one mapping to a
   * target {@Resource}, or alternatively
   * may contain the special "<code>classpath*:</code>" prefix and/or
   * internal Ant-style regular expressions (matched using Spring's
   * {@AntPathMatcher} utility).
   * Both of the latter are effectively wildcards.
   *
   * <p><b>No Wildcards:</b>
   *
   * <p>In the simple case, if the specified location path does not start with the
   * <code>"classpath*:</code>" prefix, and does not contain a PathMatcher pattern,
   * this resolver will simply return a single resource via a
   * <code>getResource()</code> call on the underlying <code>ResourceLoader</code>.
   * Examples are real URLs such as "<code>file:C:/context.xml</code>", pseudo-URLs
   * such as "<code>classpath:/context.xml</code>", and simple unprefixed paths
   * such as "<code>/WEB-INF/context.xml</code>". The latter will resolve in a
   * fashion specific to the underlying <code>ResourceLoader</code> (e.g.
   * <code>ServletContextResource</code> for a <code>WebApplicationContext</code>).
   */
  public class PathMatchingResourcePatternResolver{
  
      private static final String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
  
  	private static final Logger logger = LoggerFactory.getLogger(PathMatchingResourcePatternResolver.class);
  
  	private final ResourceLoader resourceLoader;
  
  	private AntPathMatcher pathMatcher = new AntPathMatcher();
  
  
  	/**
  	 * Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader.
  	 * <p>ClassLoader access will happen via the thread context class loader.
  	 */
  	public PathMatchingResourcePatternResolver() {
  		this.resourceLoader = new DefaultResourceLoader();
  	}
  
  	/**
  	 * Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader.
  	 * @param classLoader the ClassLoader to load classpath resources with,
  	 * or <code>null</code> for using the thread context class loader
  	 * at the time of actual resource access
  	 */
  	public PathMatchingResourcePatternResolver(ClassLoader classLoader) {
  		this.resourceLoader = new DefaultResourceLoader(classLoader);
  	}
  
  	/**
  	 * Return the ResourceLoader that this pattern resolver works with.
  	 */
  	public ResourceLoader getResourceLoader() {
  		return this.resourceLoader;
  	}
  
  	/**
  	 * Return the ClassLoader that this pattern resolver works with
  	 * (never <code>null</code>).
  	 */
  	public ClassLoader getClassLoader() {
  		return getResourceLoader().getClassLoader();
  	}
  
  
      public AntPathMatcher getPathMatcher() {
          return pathMatcher;
      }
  
  	public Resource getResource(String location) throws IOException {
  		return getResourceLoader().getResource(location);
  	}
  
  	public Resource[] getResources(String locationPatterns) throws IOException {
          if(locationPatterns == null){
              return new Resource[]{};
          }
          String[] locations = StringUtils.tokenizeToStringArray(locationPatterns, ",");
          List<Resource> results = Lists.newArrayList();
          for(String locationPattern:locations){
              if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
                  // a class path resource (multiple resources for same name possible)
                  if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
                      // a class path resource pattern
                      results.addAll(Arrays.asList(findPathMatchingResources(locationPattern)));
                  }
                  else {
                      // all class path resources with the given name
                      results.addAll(Arrays.asList(findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))));
                  }
              }
              else {
                  // Only look for a pattern after a prefix here
                  // (to not get fooled by a pattern symbol in a strange prefix).
                  int prefixEnd = locationPattern.indexOf(":") + 1;
                  if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
                      // a file pattern
                      results.addAll(Arrays.asList(findPathMatchingResources(locationPattern)));
                  }
                  else {
                      // a single resource with the given name
                      results.addAll(Arrays.asList( getResourceLoader().getResource(locationPattern)));
                  }
              }
          }
          return toArray(results);
      }
  
  	/**
  	 * Find all class location resources with the given location via the ClassLoader.
  	 * @param location the absolute path within the classpath
  	 * @return the result as Resource array
  	 * @throws java.io.IOException in case of I/O errors
  	 * @see ClassLoader#getResources
  	 * @see #convertClassLoaderURL
  	 */
  	protected Resource[] findAllClassPathResources(String location) throws IOException {
  		String path = location;
  		if (path.startsWith("/")) {
  			path = path.substring(1);
  		}
  		Enumeration<URL> resourceUrls = getClassLoader().getResources(path);
  		Set<Resource> result = new LinkedHashSet<Resource>(16);
  		while (resourceUrls.hasMoreElements()) {
  			URL url = resourceUrls.nextElement();
  			result.add(convertClassLoaderURL(url));
  		}
  		return result.toArray(new Resource[result.size()]);
  	}
  
  	/**
  	 * Convert the given URL as returned from the ClassLoader into a Resource object.
  	 * <p>The default implementation simply creates a UrlResource instance.
  	 * @param url a URL as returned from the ClassLoader
  	 * @return the corresponding Resource object
  	 * @see ClassLoader#getResources
  	 */
  	protected Resource convertClassLoaderURL(URL url) {
  		return new UrlResource(url);
  	}
  
  	/**
  	 * Find all resources that match the given location pattern via the
  	 * Ant-style PathMatcher. Supports resources in jar files and zip files
  	 * and in the file system.
  	 * @param locationPattern the location pattern to match
  	 * @return the result as Resource array
  	 * @throws java.io.IOException in case of I/O errors
  	 * @see #doFindPathMatchingJarResources
  	 * @see #doFindPathMatchingFileResources
  	 */
  	protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
  		String rootDirPath = determineRootDir(locationPattern);
  		String subPattern = locationPattern.substring(rootDirPath.length());
  		Resource[] rootDirResources = getResources(rootDirPath);
  		Set<Resource> result = new LinkedHashSet<Resource>(16);
  		for (Resource rootDirResource : rootDirResources) {
  			rootDirResource = resolveRootDirResource(rootDirResource);
  			if (isJarResource(rootDirResource)) {
  				result.addAll(doFindPathMatchingJarResources(rootDirResource, subPattern));
  			}
  			else {
  				result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
  			}
  		}
  		if (logger.isDebugEnabled()) {
  			logger.debug("Resolved location pattern [" + locationPattern + "] to resources " + result);
  		}
  		return result.toArray(new Resource[result.size()]);
  	}
  
  	/**
  	 * Determine the root directory for the given location.
  	 * <p>Used for determining the starting point for file matching,
  	 * resolving the root directory location to a <code>java.io.File</code>
  	 * and passing it into <code>retrieveMatchingFiles</code>, with the
  	 * remainder of the location as pattern.
  	 * <p>Will return "/WEB-INF/" for the pattern "/WEB-INF/*.xml",
  	 * for example.
  	 * @param location the location to check
  	 * @return the part of the location that denotes the root directory
  	 * @see #retrieveMatchingFiles
  	 */
  	protected String determineRootDir(String location) {
  		int prefixEnd = location.indexOf(":") + 1;
  		int rootDirEnd = location.length();
  		while (rootDirEnd > prefixEnd && getPathMatcher().isPattern(location.substring(prefixEnd, rootDirEnd))) {
  			rootDirEnd = location.lastIndexOf('/', rootDirEnd - 2) + 1;
  		}
  		if (rootDirEnd == 0) {
  			rootDirEnd = prefixEnd;
  		}
  		return location.substring(0, rootDirEnd);
  	}
  
  	/**
  	 * Resolve the specified resource for path matching.
  	 * <p>The default implementation detects an Equinox OSGi "bundleresource:"
  	 * / "bundleentry:" URL and resolves it into a standard jar file URL that
  	 * can be traversed using Spring's standard jar file traversal algorithm.
  	 * @param original the resource to resolve
  	 * @return the resolved resource (may be identical to the passed-in resource)
  	 * @throws java.io.IOException in case of resolution failure
  	 */
  	protected Resource resolveRootDirResource(Resource original) throws IOException {
  		return original;
  	}
  
  	/**
  	 * Return whether the given resource handle indicates a jar resource
  	 * that the <code>doFindPathMatchingJarResources</code> method can handle.
  	 * <p>The default implementation checks against the URL protocols
  	 * "jar", "zip" and "wsjar" (the latter are used by BEA WebLogic Server
  	 * and IBM WebSphere, respectively, but can be treated like jar files).
  	 * @param resource the resource handle to check
  	 * (usually the root directory to start path matching from)
  	 * @see #doFindPathMatchingJarResources
  	 */
  	protected boolean isJarResource(Resource resource) throws IOException {
  		return ResourceUtils.isJarURL(resource.getURL());
  	}
  
  	/**
  	 * Find all resources in jar files that match the given location pattern
  	 * via the Ant-style PathMatcher.
  	 * @param rootDirResource the root directory as Resource
  	 * @param subPattern the sub pattern to match (below the root directory)
  	 * @return the Set of matching Resource instances
  	 * @throws java.io.IOException in case of I/O errors
  	 * @see java.net.JarURLConnection
  	 */
  	protected Set<Resource> doFindPathMatchingJarResources(Resource rootDirResource, String subPattern)
  			throws IOException {
  
  		URLConnection con = rootDirResource.getURL().openConnection();
  		JarFile jarFile;
  		String jarFileUrl;
  		String rootEntryPath;
  		boolean newJarFile = false;
  
  		if (con instanceof JarURLConnection) {
  			// Should usually be the case for traditional JAR files.
  			JarURLConnection jarCon = (JarURLConnection) con;
  			jarFile = jarCon.getJarFile();
  			jarFileUrl = jarCon.getJarFileURL().toExternalForm();
  			JarEntry jarEntry = jarCon.getJarEntry();
  			rootEntryPath = (jarEntry != null ? jarEntry.getName() : "");
  		}
  		else {
  			// No JarURLConnection -> need to resort to URL file parsing.
  			// We'll assume URLs of the format "jar:path!/entry", with the protocol
  			// being arbitrary as long as following the entry format.
  			// We'll also handle paths with and without leading "file:" prefix.
  			String urlFile = rootDirResource.getURL().getFile();
  			int separatorIndex = urlFile.indexOf(ResourceUtils.JAR_URL_SEPARATOR);
  			if (separatorIndex != -1) {
  				jarFileUrl = urlFile.substring(0, separatorIndex);
  				rootEntryPath = urlFile.substring(separatorIndex + ResourceUtils.JAR_URL_SEPARATOR.length());
  				jarFile = getJarFile(jarFileUrl);
  			}
  			else {
  				jarFile = new JarFile(urlFile);
  				jarFileUrl = urlFile;
  				rootEntryPath = "";
  			}
  			newJarFile = true;
  		}
  
  		try {
  			if (logger.isDebugEnabled()) {
  				logger.debug("Looking for matching resources in jar file [" + jarFileUrl + "]");
  			}
  			if (!"".equals(rootEntryPath) && !rootEntryPath.endsWith("/")) {
  				// Root entry path must end with slash to allow for proper matching.
  				// The Sun JRE does not return a slash here, but BEA JRockit does.
  				rootEntryPath = rootEntryPath + "/";
  			}
  			Set<Resource> result = new LinkedHashSet<Resource>(8);
  			for (Enumeration<JarEntry> entries = jarFile.entries(); entries.hasMoreElements();) {
  				JarEntry entry = entries.nextElement();
  				String entryPath = entry.getName();
  