Java Code Examples for org.springframework.core.io.support.ResourcePatternResolver#getResources()

public static List<Class> searchAnnotatedClasses(String basePackage, Class<?> annotation)
    throws IOException, ClassNotFoundException {
  ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
  MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(
      resourcePatternResolver);

  List<Class> candidates = new ArrayList<>();
  String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
      resolveBasePackage(basePackage) + "/" + "**/*.class";
  Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
  for (Resource resource : resources) {
    if (resource.isReadable()) {
      MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
      if (isCandidate(metadataReader, annotation)) {
        candidates.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
      }
    }
  }
  return candidates;
}
 

/**
 * Finds all the classes which have a BeanTag or BeanTags annotation
 *
 * @param basePackage the package to start in
 * @return classes which have BeanTag or BeanTags annotation
 * @throws IOException
 * @throws ClassNotFoundException
 */
protected static List<Class<?>> findTagClasses(String basePackage) throws IOException, ClassNotFoundException {
    ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver);

    List<Class<?>> classes = new ArrayList<Class<?>>();

    String resolvedBasePackage = ClassUtils.convertClassNameToResourcePath(SystemPropertyUtils.resolvePlaceholders(
            basePackage));
    String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolvedBasePackage + "/" + "**/*.class";

    Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
    for (Resource resource : resources) {
        if (resource.isReadable()) {
            MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
            if (metadataReader != null && isBeanTag(metadataReader)) {
                classes.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
            }
        }
    }

    return classes;
}
 

public List<Resource> discoverProcessDefinitionResources(ResourcePatternResolver applicationContext, String prefix, List<String> suffixes, boolean checkPDs) throws IOException {
  if (checkPDs) {

  	List<Resource> result = new ArrayList<Resource>();
  	for (String suffix : suffixes) {
  		String path = prefix + suffix;
  		Resource[] resources = applicationContext.getResources(path);
  		if (resources != null && resources.length > 0) {
  			for (Resource resource : resources) {
  				result.add(resource);
  			}
  		}
  	}
  	
  	if (result.isEmpty()) {
    	logger.info(String.format("No process definitions were found for autodeployment"));
  	}
  	
    return result;
  }
  return new ArrayList<Resource>();
}
 

public static void main(String[] args) throws IOException {
    Map<String, String> env = System.getenv();
    for (String envName : env.keySet()) {
        System.out.format("%s=%s%n", envName, env.get(envName));
    }
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    Resource[] resources = resolver.getResources("resources/*");
    for (Resource resource : resources) {
        File resourceFile = new File(resource.getFilename());
        try (FileOutputStream fos = new FileOutputStream(resourceFile)) {
            IOUtils.copyLarge(resource.getInputStream(), fos);
        }
        resourceFile.setExecutable(true);
        resourceFile.setReadable(true);
        resourceFile.setWritable(true);
    }
    SpringApplication.run(Application.class, args);
}
 

@Test
void testLoadingClasspathFile() throws Exception {
	AmazonS3 amazonS3 = mock(AmazonS3.class);
	ResourcePatternResolver resourceLoader = getResourceLoader(amazonS3);

	Resource[] resources = resourceLoader.getResources(
			"classpath*:org/springframework/cloud/aws/core/io/s3/PathMatchingSimpleStorageResourcePatternResolverTest.class");
	assertThat(resources.length).isEqualTo(1);
	assertThat(resources[0].exists()).as("load without wildcards").isTrue();

	Resource[] resourcesWithFileNameWildcard = resourceLoader.getResources(
			"classpath*:org/**/PathMatchingSimpleStorageResourcePatternResolverTes?.class");
	assertThat(resourcesWithFileNameWildcard.length).isEqualTo(1);
	assertThat(resourcesWithFileNameWildcard[0].exists()).as("load with wildcards")
			.isTrue();
}
 

@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSourceProxy dataSourceProxy,
                                                   MybatisProperties mybatisProperties) {
    SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
    bean.setDataSource(dataSourceProxy);

    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    try {
        Resource[] mapperLocaltions = resolver.getResources(mybatisProperties.getMapperLocations()[0]);
        bean.setMapperLocations(mapperLocaltions);

        if (StringUtils.isNotBlank(mybatisProperties.getConfigLocation())) {
            Resource[] resources = resolver.getResources(mybatisProperties.getConfigLocation());
            bean.setConfigLocation(resources[0]);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return bean;
}
 

private void loadData() {
    try {
        final ResourcePatternResolver resolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
        final Resource[] resources = resolver.getResources("classpath:/META-INF/syndesis/connector/*.json");
        ReadApiClientData reader = new ReadApiClientData(encryptionComponent);

        for (Resource resource: resources) {
            try (InputStream is = resource.getInputStream()) {
                // Replace placeholders
                final String text = reader.findAndReplaceTokens(
                    StreamUtils.copyToString(is, StandardCharsets.UTF_8),
                    System.getenv()
                );

                Connector connector = JsonUtils.reader().forType(Connector.class).readValue(text);

                if (connector != null) {
                    LOGGER.info("Load connector: {} from resource: {}", connector.getId().orElse(""), resource.getURI());
                    final String id = connector.getId().get();
                    final Connector existing = fetch(Connector.class, id);
                    if (existing != null) {
                        // the only mutable part of the Connector
                        final Map<String, String> existingConfiguredProperties = existing.getConfiguredProperties();
                        final Map<String, String> mergedConfiguredProperties = merge(existingConfiguredProperties, connector.getConfiguredProperties());
                        connector = connector.builder().configuredProperties(mergedConfiguredProperties).build();
                    }
                    store(connector, Connector.class);
                }
            }
        }
    } catch (FileNotFoundException ignored) {
        // ignore
    } catch (IOException e) {
        throw new IllegalStateException("Cannot load connector from resources due to: " + e.getMessage(), e);
    }
}
 

@Override
public List<Pipeline> findAll () {
  try {
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    Resource[] resources = resolver.getResources(locationPattern);
    return Arrays.asList(resources)
                 .stream()
                 .map(r -> read(r))
                 .collect(Collectors.toList());
  }
  catch(IOException e) {
    throw Throwables.propagate(e);
  }
}
 

private Resource getSchema(String schemaName) throws IOException {
  if (schemaName.contains("/")) {
    schemaName = schemaName.substring(schemaName.lastIndexOf('/'));
  }

  ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
  String searchPattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "/**/" + schemaName;
  Resource[] resources = resourcePatternResolver.getResources(searchPattern);

  if (resources.length == 0) {
    throw new RuntimeException("Could not find schema [" + schemaName + "]");
  }

  return resources[0];
}
 

protected Map<String, ModuleDefinition> discoverModules(final String baseDir, final ResourcePatternResolver resolver) throws IOException {
    final Map<String, ModuleDefinition> result = new HashMap<>();

    for (final Resource r : resolver.getResources(ModuleLocationUtils.getModulesLocation(baseDir))) {
        final DefaultModuleDefinition def = new DefaultModuleDefinition(baseDir, r, resolver);
        def.init();

        if (def.isValid()) {
            result.put(def.getName(), def);
        }
    }

    return result;
}
 

public static void main(String[] args) throws IOException {
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

    //////
    // 加载所有xml后缀的资源
    //////

    Resource resources[] = resolver.getResources("classpath*:*.xml");
    for (Resource resource:resources) {
        System.out.println("资源为：" + resource.getDescription());
    }
}
 

private static String[] modelDirNames(String base_dir, ExecuteWith executeWith, String modelFileName) throws IOException {
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(new ClassPathResource(base_dir).getClassLoader());
    Resource[] resources = resolver.getResources("classpath*:" + base_dir + "/**/" + modelFileName );
    String[] exampleNames = new String[resources.length];
    for (int i = 0; i < resources.length; i++) {
        String nestedName = resources[i].getURL().toString().split(base_dir + "/")[1];
        exampleNames[i] = nestedName.replaceAll(Pattern.quote(base_dir), "").replaceAll("/" + modelFileName, "");
    }
    return exampleNames;
}
 

public Resource[] resolveMapperLocations() {
  ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
  List<Resource> resources = new ArrayList<Resource>();
  if (this.mapperLocations != null) {
    for (String mapperLocation : this.mapperLocations) {
      try {
        Resource[] mappers = resourceResolver.getResources(mapperLocation);
        resources.addAll(Arrays.asList(mappers));
      } catch (IOException e) {
        // ignore
      }
    }
  }
  return resources.toArray(new Resource[resources.size()]);
}
 

protected static Map<String, INDArray> readVars(String modelName, String base_dir, String pattern) throws IOException {
    Map<String, INDArray> varMap = new HashMap<>();
    String modelDir = base_dir + "/" + modelName;
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(new ClassPathResource(modelDir).getClassLoader());
    Resource[] resources = resolver.getResources("classpath*:" + modelDir + "/" + pattern + ".shape");
    val dtype = Nd4j.dataType();
    for (int i = 0; i < resources.length; i++) {
        String fileName = resources[i].getFilename();
        String varPath = modelDir + "/" + fileName;
        String[] varNameArr = fileName.split("\\.");
        String varName = String.join(".", Arrays.copyOfRange(varNameArr, 0, varNameArr.length - 2));
        int[] varShape = Nd4j.readNumpy(new ClassPathResource(varPath).getInputStream(), ",").data().asInt();
        try {
            float[] varContents = Nd4j.readNumpy(new ClassPathResource(varPath.replace(".shape", ".csv")).getInputStream(), ",").data().asFloat();
            INDArray varValue;
            if (varShape.length == 1) {
                if (varShape[0] == 0) {
                    varValue = Nd4j.trueScalar(varContents[0]);
                } else {
                    varValue = Nd4j.trueVector(varContents);
                }
            } else {
                varValue = Nd4j.create(varContents, varShape);
            }
            //varValue = Nd4j.readNumpy(new ClassPathResource(varPath.replace(".shape", ".csv")).getInputStream(), ",").reshape(varShape);
            if (varName.contains("____")) {
                //these are intermediate node outputs
                varMap.put(varName.replaceAll("____", "/"), varValue);
            } else {
                varMap.put(varName, varValue);
            }
        } catch (NumberFormatException e) {
            // FIXME: we can't parse boolean arrays right now :(
            continue;
        }
    }
    return varMap;
}
 

SpringBootResourceLoader(ClassLoader cl, String packagePath) {
    String locationPattern = CLASSPATH_ALL_URL_PREFIX + "**/" + packagePath + "/**/*.feature";
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(cl);
    try {
        resources = resolver.getResources(locationPattern);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

private static List<Resource> collectResourcesRecursively(ResourcePatternResolver resourcePatternResolver,
        String resourcePath) throws IOException
{
    List<Resource> propertyResources = new LinkedList<>();
    StringBuilder path = new StringBuilder(ROOT_LOCATION);
    String[] locationParts = resourcePath.isEmpty() ? new String[] { resourcePath }
            : StringUtils.split(resourcePath, DELIMITER);
    for (int i = 0; i < locationParts.length; i++)
    {
        boolean deepestLevel = i + 1 == locationParts.length;
        String locationPart = locationParts[i];
        path.append(locationPart);
        if (!locationPart.isEmpty())
        {
            path.append(DELIMITER);
        }
        String resourceLocation = path.toString() + "*.properties";
        Resource[] resources = resourcePatternResolver.getResources(resourceLocation);
        if (deepestLevel && resources.length == 0)
        {
            throw new IllegalStateException(
                    "No files with properties were found at location with pattern: " + resourceLocation);
        }
        propertyResources.addAll(Stream.of(resources).filter(Resource::exists).collect(Collectors.toList()));
    }
    return propertyResources;
}
 

public static List<Theme> getThemes() {
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    List<Theme> themes = null;
    try {
        Resource[] resources = resolver.getResources("templates/*/about.json");
        themes = loadDirectory(resources);
        String location = System.getProperty("site.location");
        if (null != location) {
            themes.addAll(loadDirectory(Paths.get(location, "storage", "templates")));
        }
    } catch (Exception e) {
        log.error("load themes error {}", e.getMessage(), e);
    }
    return themes;
}
 

private Resource[] getRuleFiles() throws IOException {
    ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");
}
 

@Bean
public StubManager newStubManager() {
    System.out.println("Initializing StubManager...");

    StubManager stubManager = new StubManager();

    ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    try {
        Resource[] resources =
                resourcePatternResolver.getResources(
                        ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                                + ClassUtils.convertClassNameToResourcePath("com.webank")
                                + "/**/*.class");
        logger.debug("Total {} resources", resources.length);

        MetadataReaderFactory metadataReaderFabtFactory = new SimpleMetadataReaderFactory();
        for (Resource resource : resources) {
            logger.debug("Scan stub plugin: {}", resource.getURI().toString());
            MetadataReader metadataReader =
                    metadataReaderFabtFactory.getMetadataReader(resource);
            if (metadataReader.getAnnotationMetadata().hasAnnotation(Stub.class.getName())) {
                Map<String, Object> attributes =
                        metadataReader
                                .getAnnotationMetadata()
                                .getAnnotationAttributes(Stub.class.getName());
                String name = (String) attributes.get("value");

                if (stubManager.hasDriver(name)) {
                    throw new Exception(
                            "Duplicate stub plugin["
                                    + name
                                    + "]: "
                                    + resource.getURI().toString());
                }

                Class<?> claz = Class.forName(metadataReader.getClassMetadata().getClassName());
                StubFactory stubFactory =
                        (StubFactory) claz.getDeclaredConstructor().newInstance();

                stubManager.addStubFactory(name, stubFactory);

                logger.info("Load stub plugin[" + name + "]: " + resource.getURI().toString());
            }
        }
    } catch (Exception e) {
        String errorMsg = "Loading stub error: " + e;
        logger.error(errorMsg);
        System.exit(-1);
    }

    return stubManager;
}
 

private Resource[] getRuleFiles() throws IOException {
    ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");
}