springboot PropertiesLoaderUtils使用

本是古典何须时尚 2022-09-12 12:47 52阅读 0赞

--------------------

## springboot PropertiesLoaderUtils使用 ##

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**相关类与接口**

**PropertiesLoaderUtils**

public abstract class PropertiesLoaderUtils {
        private static final String XML_FILE_EXTENSION = ".xml";
        private static final boolean shouldIgnoreXml = SpringProperties.getFlag("spring.xml.ignore");
    
        public PropertiesLoaderUtils() {
        }
    
        public static Properties loadProperties(EncodedResource resource) throws IOException {
            Properties props = new Properties();
            fillProperties(props, resource);
            return props;
        }
    
        public static void fillProperties(Properties props, EncodedResource resource) throws IOException {
            fillProperties(props, resource, ResourcePropertiesPersister.INSTANCE);
        }
    
        static void fillProperties(Properties props, EncodedResource resource, PropertiesPersister persister) throws IOException {
            InputStream stream = null;
            Reader reader = null;
    
            try {
                String filename = resource.getResource().getFilename();
                if (filename != null && filename.endsWith(".xml")) {
                    if (shouldIgnoreXml) {
                        throw new UnsupportedOperationException("XML support disabled");
                    }
    
                    stream = resource.getInputStream();
                    persister.loadFromXml(props, stream);
                } else if (resource.requiresReader()) {
                    reader = resource.getReader();
                    persister.load(props, reader);
                } else {
                    stream = resource.getInputStream();
                    persister.load(props, stream);
                }
            } finally {
                if (stream != null) {
                    stream.close();
                }
    
                if (reader != null) {
                    reader.close();
                }
    
            }
    
        }
    
        public static Properties loadProperties(Resource resource) throws IOException {
            Properties props = new Properties();
            fillProperties(props, resource);
            return props;
        }
    
        public static void fillProperties(Properties props, Resource resource) throws IOException {
            InputStream is = resource.getInputStream();
            Throwable var3 = null;
    
            try {
                String filename = resource.getFilename();
                if (filename != null && filename.endsWith(".xml")) {
                    if (shouldIgnoreXml) {
                        throw new UnsupportedOperationException("XML support disabled");
                    }
    
                    props.loadFromXML(is);
                } else {
                    props.load(is);
                }
            } catch (Throwable var12) {
                var3 = var12;
                throw var12;
            } finally {
                if (is != null) {
                    if (var3 != null) {
                        try {
                            is.close();
                        } catch (Throwable var11) {
                            var3.addSuppressed(var11);
                        }
                    } else {
                        is.close();
                    }
                }
    
            }
    
        }
    
        public static Properties loadAllProperties(String resourceName) throws IOException {
            return loadAllProperties(resourceName, (ClassLoader)null);
        }
    
        public static Properties loadAllProperties(String resourceName, @Nullable ClassLoader classLoader) throws IOException {
            Assert.notNull(resourceName, "Resource name must not be null");
            ClassLoader classLoaderToUse = classLoader;
            if (classLoader == null) {
                classLoaderToUse = ClassUtils.getDefaultClassLoader();
            }
    
            Enumeration<URL> urls = classLoaderToUse != null ? classLoaderToUse.getResources(resourceName) : ClassLoader.getSystemResources(resourceName);
            Properties props = new Properties();
    
            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                URLConnection con = url.openConnection();
                ResourceUtils.useCachesIfNecessary(con);
                InputStream is = con.getInputStream();
                Throwable var8 = null;
    
                try {
                    if (resourceName.endsWith(".xml")) {
                        if (shouldIgnoreXml) {
                            throw new UnsupportedOperationException("XML support disabled");
                        }
    
                        props.loadFromXML(is);
                    } else {
                        props.load(is);
                    }
                } catch (Throwable var17) {
                    var8 = var17;
                    throw var17;
                } finally {
                    if (is != null) {
                        if (var8 != null) {
                            try {
                                is.close();
                            } catch (Throwable var16) {
                                var8.addSuppressed(var16);
                            }
                        } else {
                            is.close();
                        }
                    }
    
                }
            }
    
            return props;
        }
    }

**Resource**

public interface Resource extends InputStreamSource {
        boolean exists();
    
        URL getURL() throws IOException;
        URI getURI() throws IOException;
    
        File getFile() throws IOException;
    
        long contentLength() throws IOException;
        long lastModified() throws IOException;
    
        Resource createRelative(String relativePath) throws IOException;
    
        @Nullable
        String getFilename();
        String getDescription();
    
        default boolean isReadable() {
            return this.exists();
        }
    
        default boolean isOpen() {
            return false;
        }
    
        default boolean isFile() {
            return false;
        }
    
        default ReadableByteChannel readableChannel() throws IOException {
            return Channels.newChannel(this.getInputStream());
        }
    }

**ClassPathResource**

public class ClassPathResource extends AbstractFileResolvingResource {
        private final String path;
        @Nullable
        private ClassLoader classLoader;
        @Nullable
        private Class<?> clazz;
    
        public ClassPathResource(String path) {
            this(path, (ClassLoader)null);
        }
    
        public ClassPathResource(String path, @Nullable ClassLoader classLoader) {
            Assert.notNull(path, "Path must not be null");
            String pathToUse = StringUtils.cleanPath(path);
            if (pathToUse.startsWith("/")) {
                pathToUse = pathToUse.substring(1);
            }
    
            this.path = pathToUse;
            this.classLoader = classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader();
        }
    
        public ClassPathResource(String path, @Nullable Class<?> clazz) {
            Assert.notNull(path, "Path must not be null");
            this.path = StringUtils.cleanPath(path);
            this.clazz = clazz;
        }

**FileSystemResource**

public class FileSystemResource extends AbstractResource implements WritableResource {
        private final String path;
        @Nullable
        private final File file;
        private final Path filePath;
    
        public FileSystemResource(String path) {
        public FileSystemResource(File file) {
        public FileSystemResource(Path filePath) {
        public FileSystemResource(FileSystem fileSystem, String path) {

**FileURLResource**

public class FileUrlResource extends UrlResource implements WritableResource {
        @Nullable
        private volatile File file;
    
        public FileUrlResource(URL url) {
            super(url);
        }
    
        public FileUrlResource(String location) throws MalformedURLException {
            super("file", location);
        }

**HttpResource**

public interface HttpResource extends Resource {
        HttpHeaders getResponseHeaders();
    }

**EncodedResource**

public class EncodedResourceResolver extends AbstractResourceResolver {
    
    ***********
    内部类：EncodedResource
    
        static final class EncodedResource extends AbstractResource implements HttpResource {
            private final Resource original;
            private final String coding;
            private final Resource encoded;
    
            EncodedResource(Resource original, String coding, String extension) throws IOException {
                this.original = original;
                this.coding = coding;
                this.encoded = original.createRelative(original.getFilename() + extension);
            }

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**示例**

**属性文件：application.properties**

person.name=gtlx
    person.age=20

**Test**

public class Test {
    
        public static void main(String[] args) throws Exception{
            FileSystemResource resource=new FileSystemResource("d:"+ File.separator+"application.properties");
            Properties properties= PropertiesLoaderUtils.loadProperties(resource);
            properties.forEach((key,value)->{
                System.out.println(key+" ==> "+value);
            });
        }
    }

**控制台输出**

person.age ==> 20
    person.name ==> gtlx