Refine search
private Resource[] findResources(String source) { ResourceLoader loader = (this.resourceLoader != null) ? this.resourceLoader : new PathMatchingResourcePatternResolver(); try { if (loader instanceof ResourcePatternResolver) { return ((ResourcePatternResolver) loader).getResources(source); } return new Resource[] { loader.getResource(source) }; } catch (IOException ex) { throw new IllegalStateException("Error reading source '" + source + "'"); } }
@Override public void afterPropertiesSet() throws Exception { ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(); BufferedReader br = new BufferedReader(new InputStreamReader(resolver.getResource("tags.txt").getInputStream())); String tag = br.readLine(); while (tag != null) { if (!put(tag)) { log.info("添加标签失败:" + tag); } tag = br.readLine(); } br.close(); }
String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + ClassUtils.convertClassNameToResourcePath(pkg) + RESOURCE_PATTERN; Resource[] resources = this.resourcePatternResolver.getResources(pattern); MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver); for (Resource resource : resources) { if (resource.isReadable()) { MetadataReader reader = readerFactory.getMetadataReader(resource); String className = reader.getClassMetadata().getClassName(); ClassLoader cl = this.resourcePatternResolver.getClassLoader(); for (String className : entityClassNames) { addAnnotatedClass(ClassUtils.forName(className, cl));
private Optional<Resource[]> retrieveResources() throws IOException { Optional<Resource[]> resources = Optional.empty(); Resource processExtensionsResource = resourceLoader.getResource(processExtensionsRoot); if (processExtensionsResource.exists()) { return Optional.ofNullable(resourceLoader.getResources(processExtensionsRoot + processExtensionsSuffix)); } return resources; }
private Package findPackage(CharSequence source) { Package pkg = Package.getPackage(source.toString()); if (pkg != null) { return pkg; } try { // Attempt to find a class in this package ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver( getClass().getClassLoader()); Resource[] resources = resolver.getResources( ClassUtils.convertClassNameToResourcePath(source.toString()) + "/*.class"); for (Resource resource : resources) { String className = StringUtils .stripFilenameExtension(resource.getFilename()); load(Class.forName(source.toString() + "." + className)); break; } } catch (Exception ex) { // swallow exception and continue } return Package.getPackage(source.toString()); }
private void appendPropertySource(CompositePropertySource propertySource, ResourceLoader resourceLoader) throws IOException { ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver(resourceLoader); Resource[] resources = resourcePatternResolver.getResources(RESOURCE_LOCATION_PATTERN); for (Resource resource : resources) { // Add if exists if (resource.exists()) { String internalName = String.valueOf(resource.getURL()); propertySource.addPropertySource(new ResourcePropertySource(internalName, new EncodedResource(resource, FILE_ENCODING))); } } }
/** * Parse the {@code jar-file} XML elements. */ protected void parseJarFiles(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) throws IOException { List<Element> jars = DomUtils.getChildElementsByTagName(persistenceUnit, JAR_FILE_URL); for (Element element : jars) { String value = DomUtils.getTextValue(element).trim(); if (StringUtils.hasText(value)) { Resource[] resources = this.resourcePatternResolver.getResources(value); boolean found = false; for (Resource resource : resources) { if (resource.exists()) { found = true; unitInfo.addJarFileUrl(resource.getURL()); } } if (!found) { // relative to the persistence unit root, according to the JPA spec URL rootUrl = unitInfo.getPersistenceUnitRootUrl(); if (rootUrl != null) { unitInfo.addJarFileUrl(new URL(rootUrl, value)); } else { logger.warn("Cannot resolve jar-file entry [" + value + "] in persistence unit '" + unitInfo.getPersistenceUnitName() + "' without root URL"); } } } } }
/** * Setter for file path. * * @param path * New path */ public void setPath(String path) { log.debug("Set path: {}", path); Resource rootFile = resources.getResource(path); try { log.debug("Absolute path: {}", resources.getResource("/").getFile().getAbsolutePath()); // check for existence if (!rootFile.exists()) { log.debug("Persistence directory does not exist"); // get context path String contextPath = getContextPath(rootFile); // int root dir initRootDir(rootFile, contextPath); } else { rootDir = rootFile.getFile().getAbsolutePath(); } log.debug("Root dir: {} path: {}", rootDir, path); // set the path this.path = path; } catch (IOException err) { log.error("I/O exception thrown when setting file path to {}", path, err); throw new RuntimeException(err); } }
ResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver(); Resource[] mappingLocations; try { mappingLocations = patternResolver.getResources("classpath*:org/hl7/fhir/instance/model/profile/" + "*.profile.xml"); } catch (IOException e) { throw new CommandFailureException(e.toString()); StructureDefinition next; try { next = ctx.newXmlParser().parseResource(StructureDefinition.class, IOUtils.toString(i.getInputStream(), "UTF-8")); } catch (Exception e) { throw new CommandFailureException(e.toString());
try { for (String location : persistenceXmlLocations) { Resource[] resources = this.resourcePatternResolver.getResources(location); for (Resource resource : resources) { resourceLocation = resource.toString(); InputStream stream = resource.getInputStream(); try { Document document = buildDocument(handler, stream);
ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver(); MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver); 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)) {
Resource data = resources.getResource(name); if (data == null || !data.exists()) { data = resources.getResource("file://" + rootDir + '/' + name); if (data == null || !data.exists()) { log.debug("Resource / data was not found (full path)"); return null; String filename; try { File fp = data.getFile(); if (fp.length() == 0) {
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(parserContext .getReaderContext().getResourceLoader()); int found = 0; Resource[] resources = resolver.getResources(scriptResourceName.replace('?', '*')); BeanDefinitionDefaults defaults = getBeanDefinitionDefaults(subElement, parserContext); ParsingModuleMatcher matcher = new ParsingModuleMatcher(scripts, scriptNamePattern, typeName, if (resource.isReadable()) { URI uri = resource.getURI();
@Override public boolean exists(String classpath) { ClassLoader cl = this.getClass().getClassLoader(); ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(cl); Resource resource = resolver.getResource("classpath:" + classpath); return resource.exists(); }
@Override protected Resource[] createInstance() throws Exception { List<Resource> scripts = new ArrayList<>(); for (String location : this.locations) { List<Resource> resources = new ArrayList<>( Arrays.asList(this.resourcePatternResolver.getResources(location))); resources.sort((r1, r2) -> { try { return r1.getURL().toString().compareTo(r2.getURL().toString()); } catch (IOException ex) { return 0; } }); scripts.addAll(resources); } return scripts.toArray(new Resource[0]); }
@Override public Resource[] getResources(String locationPattern) throws IOException { return this.resourcePatternResolver.getResources(locationPattern); }
@Override public Resource getResource(String location) { org.springframework.core.io.Resource springResource = resolver.getResource(CLASSPATH_URL_PREFIX + location); if (springResource != null && springResource.exists()) { return createResource(springResource); } else { return null; } }
/** * Determine JPA's default "META-INF/orm.xml" resource for use with Spring's default * persistence unit, if any. * <p>Checks whether a "META-INF/orm.xml" file exists in the classpath and uses it * if it is not co-located with a "META-INF/persistence.xml" file. */ @Nullable private Resource getOrmXmlForDefaultPersistenceUnit() { Resource ormXml = this.resourcePatternResolver.getResource( this.defaultPersistenceUnitRootLocation + DEFAULT_ORM_XML_RESOURCE); if (ormXml.exists()) { try { Resource persistenceXml = ormXml.createRelative(PERSISTENCE_XML_FILENAME); if (!persistenceXml.exists()) { return ormXml; } } catch (IOException ex) { // Cannot resolve relative persistence.xml file - let's assume it's not there. return ormXml; } } return null; }
protected void checkNameMatchesSelf() throws IOException { String expectedLocation = ModuleLocationUtils.getModuleLocation(baseDir, name); Resource self = resolver.getResource(expectedLocation); if (!self.exists()) { throw new IOException("Resource [" + location() + "] is expected to exist at [" + expectedLocation + "] please ensure the name property is correct"); } String moduleUrl = moduleProperties.getURL().toExternalForm(); String selfUrl = self.getURL().toExternalForm(); if (!moduleUrl.equals(selfUrl)) { throw new IOException("Resource [" + location() + "] and [" + self.getURL() + "] do not appear to be the same resource, " + "please ensure the name property is correct or that the " + "module is not defined twice"); } }
String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + ClassUtils.convertClassNameToResourcePath(pkg) + CLASS_RESOURCE_PATTERN; Resource[] resources = this.resourcePatternResolver.getResources(pattern); MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver); for (Resource resource : resources) { if (resource.isReadable()) { MetadataReader reader = readerFactory.getMetadataReader(resource); String className = reader.getClassMetadata().getClassName(); scannedUnit.addManagedClassName(className); if (scannedUnit.getPersistenceUnitRootUrl() == null) { URL url = resource.getURL(); if (ResourceUtils.isJarURL(url)) { scannedUnit.setPersistenceUnitRootUrl(ResourceUtils.extractJarFileURL(url));