Examples of PathMatchingResourcePatternResolver

org.grails.io.support.PathMatchingResourcePatternResolver
A ResourcePatternResolver 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 "classpath*:" prefix and/or internal Ant-style regular expressions (matched using AntPathMatcher). Both of the latter are effectively wildcards.
No Wildcards:
In the simple case, if the specified location path does not start with the "classpath*:" prefix, and does not contain a PathMatcher pattern, this resolver will simply return a single resource via a getResource() call on the underlying ResourceLoader. Examples are real URLs such as "file:C:/context.xml", pseudo-URLs such as "classpath:/context.xml", and simple unprefixed paths such as "/WEB-INF/context.xml". The latter will resolve in a fashion specific to the underlying ResourceLoader (e.g. ServletContextResource for a WebApplicationContext).
Ant-style Patterns:
When the path location contains an Ant-style pattern, e.g.:
```
 /WEB-INF/*-context.xml com/mycompany/**/applicationContext.xml file:C:/some/path/*-context.xml classpath:com/mycompany/**/applicationContext.xml
```
the resolver follows a more complex but defined procedure to try to resolve the wildcard. It produces a Resource for the path up to the last non-wildcard segment and obtains a URL from it. If this URL is not a "jar:" URL or container-specific variant (e.g. "zip:" in WebLogic, "wsjar" in WebSphere", etc.), then a java.io.File is obtained from it, and used to resolve the wildcard by walking the filesystem. In the case of a jar URL, the resolver either gets a java.net.JarURLConnection from it, or manually parses the jar URL, and then traverses the contents of the jar file, to resolve the wildcards.
Implications on portability:
If the specified path is already a file URL (either explicitly, or implicitly because the base ResourceLoader is a filesystem one, then wildcarding is guaranteed to work in a completely portable fashion.
If the specified path is a classpath location, then the resolver must obtain the last non-wildcard path segment URL via a Classloader.getResource() call. Since this is just a node of the path (not the file at the end) it is actually undefined (in the ClassLoader Javadocs) exactly what sort of a URL is returned in this case. In practice, it is usually a java.io.File representing the directory, where the classpath resource resolves to a filesystem location, or a jar URL of some sort, where the classpath resource resolves to a jar location. Still, there is a portability concern on this operation.
If a jar URL is obtained for the last non-wildcard segment, the resolver must be able to get a java.net.JarURLConnection from it, or manually parse the jar URL, to be able to walk the contents of the jar, and resolve the wildcard. This will work in most environments, but will fail in others, and it is strongly recommended that the wildcard resolution of resources coming from jars be thoroughly tested in your specific environment before you rely on it.
classpath*: Prefix:
There is special support for retrieving multiple class path resources with the same name, via the "classpath*:" prefix. For example, "classpath*:META-INF/beans.xml" will find all "beans.xml" files in the class path, be it in "classes" directories or in JAR files. This is particularly useful for autodetecting config files of the same name at the same location within each jar file. Internally, this happens via a ClassLoader.getResources() call, and is completely portable.
The "classpath*:" prefix can also be combined with a PathMatcher pattern in the rest of the location path, for example "classpath*:META-INF/*-beans.xml". In this case, the resolution strategy is fairly simple: a ClassLoader.getResources() call is used on the last non-wildcard path segment to get all the matching resources in the class loader hierarchy, and then off each resource the same PathMatcher resolution strategy described above is used for the wildcard subpath.
Other notes:
WARNING: Note that "classpath*:" when combined with Ant-style patterns will only work reliably with at least one root directory before the pattern starts, unless the actual target files reside in the file system. This means that a pattern like "classpath*:*.xml" will not retrieve files from the root of jar files but rather only from the root of expanded directories. This originates from a limitation in the JDK's ClassLoader.getResources() method which only returns file system locations for a passed-in empty String (indicating potential roots to search).
WARNING: Ant-style patterns with "classpath:" resources are not guaranteed to find matching resources if the root package to search is available in multiple class path locations. This is because a resource such as
```
 com/mycompany/package1/service-context.xml 
```
may be in only one location, but when a path such as
```
 classpath:com/mycompany/**/service-context.xml 
```
is used to try to resolve it, the resolver will work off the (first) URL returned by getResource("com/mycompany");. If this base package node exists in multiple classloader locations, the actual end resource may not be underneath. Therefore, preferably, use "classpath*:" with the same Ant-style pattern in such a case, which will search all class path locations that contain the root package. @author Juergen Hoeller @author Colin Sampaleanu @author Marius Bogoevici @author Costin Leau @since 1.0.2 @see java.lang.ClassLoader#getResources(String)



org.springframework.core.io.support.PathMatchingResourcePatternResolver

A {@link ResourcePatternResolver} implementation that is able to resolve aspecified 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 {@link org.springframework.core.io.Resource}, or alternatively may contain the special "classpath*:" prefix and/or internal Ant-style regular expressions (matched using Spring's {@link org.springframework.util.AntPathMatcher} utility).Both of the latter are effectively wildcards. No Wildcards: 
In the simple case, if the specified location path does not start with the "classpath*:" prefix, and does not contain a PathMatcher pattern, this resolver will simply return a single resource via a getResource() call on the underlying ResourceLoader. Examples are real URLs such as "file:C:/context.xml", pseudo-URLs such as "classpath:/context.xml", and simple unprefixed paths such as "/WEB-INF/context.xml". The latter will resolve in a fashion specific to the underlying ResourceLoader (e.g. ServletContextResource for a WebApplicationContext). 
Ant-style Patterns: 
When the path location contains an Ant-style pattern, e.g.: 
 /WEB-INF/*-context.xml com/mycompany/**/applicationContext.xml file:C:/some/path/*-context.xml classpath:com/mycompany/**/applicationContext.xml
 the resolver follows a more complex but defined procedure to try to resolve the wildcard. It produces a Resource for the path up to the last non-wildcard segment and obtains a URL from it. If this URL is not a "jar:" URL or container-specific variant (e.g. "zip:" in WebLogic, "wsjar" in WebSphere", etc.), then a java.io.File is obtained from it, and used to resolve the wildcard by walking the filesystem. In the case of a jar URL, the resolver either gets a java.net.JarURLConnection from it, or manually parse the jar URL, and then traverse the contents of the jar file, to resolve the wildcards. Implications on portability: 
If the specified path is already a file URL (either explicitly, or implicitly because the base ResourceLoader is a filesystem one, then wildcarding is guaranteed to work in a completely portable fashion. 
If the specified path is a classpath location, then the resolver must obtain the last non-wildcard path segment URL via a Classloader.getResource() call. Since this is just a node of the path (not the file at the end) it is actually undefined (in the ClassLoader Javadocs) exactly what sort of a URL is returned in this case. In practice, it is usually a java.io.File representing the directory, where the classpath resource resolves to a filesystem location, or a jar URL of some sort, where the classpath resource resolves to a jar location. Still, there is a portability concern on this operation. 
If a jar URL is obtained for the last non-wildcard segment, the resolver must be able to get a java.net.JarURLConnection from it, or manually parse the jar URL, to be able to walk the contents of the jar, and resolve the wildcard. This will work in most environments, but will fail in others, and it is strongly recommended that the wildcard resolution of resources coming from jars be thoroughly tested in your specific environment before you rely on it. 
classpath*: Prefix: 
There is special support for retrieving multiple class path resources with the same name, via the "classpath*:" prefix. For example, "classpath*:META-INF/beans.xml" will find all "beans.xml" files in the class path, be it in "classes" directories or in JAR files. This is particularly useful for autodetecting config files of the same name at the same location within each jar file. Internally, this happens via a ClassLoader.getResources() call, and is completely portable. 
The "classpath*:" prefix can also be combined with a PathMatcher pattern in the rest of the location path, for example "classpath*:META-INF/*-beans.xml". In this case, the resolution strategy is fairly simple: a ClassLoader.getResources() call is used on the last non-wildcard path segment to get all the matching resources in the class loader hierarchy, and then off each resource the same PathMatcher resolution strategy described above is used for the wildcard subpath. 
Other notes: 
WARNING: Note that "classpath*:" when combined with Ant-style patterns will only work reliably with at least one root directory before the pattern starts, unless the actual target files reside in the file system. This means that a pattern like "classpath*:*.xml" will not retrieve files from the root of jar files but rather only from the root of expanded directories. This originates from a limitation in the JDK's ClassLoader.getResources() method which only returns file system locations for a passed-in empty String (indicating potential roots to search). 
WARNING: Ant-style patterns with "classpath:" resources are not guaranteed to find matching resources if the root package to search is available in multiple class path locations. This is because a resource such as
 com/mycompany/package1/service-context.xml 
may be in only one location, but when a path such as classpath:com/mycompany/**/service-context.xml 
is used to try to resolve it, the resolver will work off the (first) URL returned by getResource("com/mycompany");. If this base package node exists in multiple classloader locations, the actual end resource may not be underneath. Therefore, preferably, use "classpath*:" with the same Ant-style pattern in such a case, which will search all class path locations that contain the root package.
@author Juergen Hoeller
@author Colin Sampaleanu
@since 1.0.2
@see #CLASSPATH_ALL_URL_PREFIX
@see org.springframework.util.AntPathMatcher
@see org.springframework.core.io.ResourceLoader#getResource(String)
@see java.lang.ClassLoader#getResources(String)




Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
302
303
304
305
306
307
308    *
   * @param resourcePattern
   * @throws IOException When the path cannot be matched
   */
  public void loadBeans(String resourcePattern) throws IOException {
    loadBeans(new PathMatchingResourcePatternResolver().getResources(resourcePattern));
  }
 

View Full Code Here



Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
236
237
238
239
240
241
242
243
244
245
246         // Import any ldif files
        Resource[] ldifs;


        if (ctxt == null) {
            // Not running within an app context
            ldifs = new PathMatchingResourcePatternResolver().getResources(ldifResources);
        } else {
            ldifs = ctxt.getResources(ldifResources);
        }


        // Note that we can't just import using the ServerContext returned

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
27
28
29
30
31
32
33
34
35
36
37 
        PythonInterpreter python = new PythonInterpreter();
        python.set("authentication", authentication);
        python.set("args", createArgumentMap(mi));
        python.set("method", mi.getMethod().getName());
        Resource scriptResource = new PathMatchingResourcePatternResolver().getResource(script);


        try {
            python.execfile(scriptResource.getInputStream());
        } catch (IOException e) {
            throw new IllegalArgumentException("Couldn't run python script, " + script, e);

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125   
        List<Resource> resources = new ArrayList<Resource>();
       
        if (includeDefaults) {
            try {
                PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(Thread
                    .currentThread().getContextClassLoader());
                
                Collections.addAll(resources, resolver.getResources(DEFAULT_CXF_CFG_FILE));


                Resource[] exts = resolver.getResources(DEFAULT_CXF_EXT_CFG_FILE);
                for (Resource r : exts) {
                    InputStream is = r.getInputStream();
                    BufferedReader rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                    String line = rd.readLine();
                    while (line != null) {
                        if (!"".equals(line)) {
                            resources.add(resolver.getResource(line));
                        }
                        line = rd.readLine();
                    }
                    is.close();
                }

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82 
    protected Map< Class< ? extends Annotation >, Collection< Class< ? > > > findClassesInternal(
        Collection< String > basePackages, List<Class< ? extends Annotation > > annotations) 
        throws IOException, ClassNotFoundException {
    
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        MetadataReaderFactory factory = new CachingMetadataReaderFactory(resolver);
        
        final Map< Class< ? extends Annotation >, Collection< Class< ? > > > classes = 
            new HashMap< Class< ? extends Annotation >, Collection< Class< ? > > >();
        final Map< Class< ? extends Annotation >, Collection< String > > matchingInterfaces = 
            new HashMap< Class< ? extends Annotation >, Collection< String > >();
        final Map<String, String[]> nonMatchingClasses = new HashMap<String, String[]>();
        
        for (Class< ? extends Annotation > annotation: annotations) {
            classes.put(annotation, new HashSet< Class < ? > >());
            matchingInterfaces.put(annotation, new HashSet< String >());
        }
        
        if (basePackages == null || basePackages.isEmpty()) {
            return classes;
        }
        
        for (final String basePackage: basePackages) {
            final boolean scanAllPackages = basePackage.equals(ALL_PACKAGES);
            
            final String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX 
                + (scanAllPackages ? "" : ClassUtils.convertClassNameToResourcePath(basePackage)) 
                + ALL_CLASS_FILES;
            
            final Resource[] resources = resolver.getResources(packageSearchPath);    
            
            
            for (final Resource resource: resources) {
                final MetadataReader reader = factory.getMetadataReader(resource);
                final AnnotationMetadata metadata = reader.getAnnotationMetadata();

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144         throws IOException {
        final List<URL> resourceURLs = new ArrayList<URL>();
        if (basePackages == null || basePackages.isEmpty()) {
            return resourceURLs;
        }
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        
        
        
        for (final String basePackage: basePackages) {
            final boolean scanAllPackages = basePackage.equals(ALL_PACKAGES);
            
            String theBasePackage = basePackage;
            if (theBasePackage.startsWith(CLASSPATH_URL_SCHEME)) {
                theBasePackage = theBasePackage.substring(CLASSPATH_URL_SCHEME.length());
            }
            
            final String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX 
                + (scanAllPackages ? "" : ClassUtils.convertClassNameToResourcePath(theBasePackage)) 
                + ALL_FILES + "." + extension;
            
            final Resource[] resources = resolver.getResources(packageSearchPath);                        
            for (final Resource resource: resources) {
                resourceURLs.add(resource.getURL());
            }                        
        }
        

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
57
58
59
60
61
62
63
64
65
66
67
68
69       throws IOException {
    String lastPart = StringUtils.hasText(fileName) ? fileName : "*";
    String pattern = "file:" + yarnCluster.getYarnWorkDir().getAbsolutePath()
        + "/*logDir*/" + applicationId.toString()
        + "/**/" + lastPart;
    PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    ArrayList<Resource> ret = new ArrayList<Resource>();
    for (Resource r : resolver.getResources(pattern)) {
      if (r.getFile().isFile()) {
        ret.add(r);
      }
    }
    return ret;
 

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
247
248
249
250
251
252
253   }


  public void setResourceLoader(ResourceLoader resourceLoader) {
    this.resourcePatternResolver = (resourceLoader != null ?
        ResourcePatternUtils.getResourcePatternResolver(resourceLoader) :
        new PathMatchingResourcePatternResolver());
  }

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
43
44
45
46
47
48
49
50
51
52
53  */
public class PersistenceXmlParsingTests extends TestCase {


  public void testExample1() throws Exception {
    PersistenceUnitReader reader = new PersistenceUnitReader(
        new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
    String resource = "/org/springframework/orm/jpa/persistence-example1.xml";
    PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);


    assertNotNull(info);
    assertEquals(1, info.length);
 

View Full Code Here

Examples of org.springframework.core.io.support.PathMatchingResourcePatternResolver
54
55
56
57
58
59
60
61
62
63
64     assertEquals("OrderManagement", info[0].getPersistenceUnitName());
  }


  public void testExample2() throws Exception {
    PersistenceUnitReader reader = new PersistenceUnitReader(
        new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
    String resource = "/org/springframework/orm/jpa/persistence-example2.xml";
    PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);


    assertNotNull(info);
    assertEquals(1, info.length);

View Full Code Here


0
1
2
3
4
5



TOP


Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.