读 Yaml 配置文件工具类

2022-04-10

Yaml 配置文件在 Spring Boot 项目中非常常见，所以从 Yaml 文件中读取配置这一操作也很常用，这里简单地将其整理成一个工具类，供大家参考；代码中还用到了枚举类来实现单例模式。

实现单例模式的方法有很多种，在《Effective Java》一书中，作者称最佳的实现单例模式的方法就是单元素的枚举类型。利用枚举的特性，让 JVM 来帮助我们解决线程安全和单一实例的问题。除此以外，枚举单例模式的写法还特别简单，相比于传统的饿汉式和懒汉式写法，优势明显。

源代码

第一种写法：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class YamlReader {

    private static final Logger LOGGER = LoggerFactory.getLogger(YamlReader.class);

    private static Map<String, Object> properties;
    private static Yaml yaml;

    static {
        properties = new HashMap<>();
        yaml = new Yaml();
    }

    private YamlReader() {
    }

    public static YamlReader getInstance() {
        return EnumHolder.INSTANCE.getYamlReader();
    }

    public Map<String, Object> read(String filePath) {
        InputStream in = null;
        try {
            in = new FileInputStream(filePath);
            properties = yaml.loadAs(in, HashMap.class);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                LOGGER.error(e.getMessage());
            }
        }
        return properties;
    }

    public Map<String, Object> read(File file) {
        InputStream in = null;
        try {
            in = new FileInputStream(file);
            properties = yaml.loadAs(in, HashMap.class);
        } catch (FileNotFoundException e) {
            LOGGER.error(e.getMessage());
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                LOGGER.error(e.getMessage());
            }
        }
        return properties;
    }

    public Map<String, Object> read(Class clz, String fileName) {
        InputStream in = null;
        try {
            in = clz.getClassLoader().getResourceAsStream(fileName);
            properties = yaml.loadAs(in, HashMap.class);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                LOGGER.error(e.getMessage());
            }
        }
        return properties;
    }

    private enum EnumHolder {
        INSTANCE;
        private YamlReader instance;

        EnumHolder() {
            this.instance = new YamlReader();
        }

        private YamlReader getYamlReader() {
            return instance;
        }
    }
}

第二种写法：

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.Yaml;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public final class AppConfigReader {

    private static final Logger LOGGER = LoggerFactory.getLogger(AppConfigReader.class);

    private static Map<String, Map<String,Object>> properties;
    public static String PROFILES_ACTIVATED = "";

    private AppConfigReader() {

    }

    public static AppConfigReader getInstance() {
        return EnumHolder.INSTANCE.getAppConfigReader();
    }

    private enum EnumHolder {
        INSTANCE;
        private AppConfigReader instance;

        EnumHolder() {
            this.instance = new AppConfigReader();
        }

        private AppConfigReader getAppConfigReader() {
            return instance;
        }
    }

    public Object getValue(String root, String key) {
        setYml("application.yml");
        Map<String, Object> rootProperties = properties.get(root);
        Object obj = null,priorObj = null;
        if (rootProperties != null) {
            obj = rootProperties.getOrDefault(key, "");
        }
        if (activeFileIsDev()) {
            setYml("application-dev.yml");
        } else {
            setYml("application-prod.yml");
        }
        rootProperties = properties.get(root);
        if (rootProperties != null) {
            priorObj = rootProperties.getOrDefault(key, "");
        }
        return Optional.ofNullable(priorObj).orElse(obj);
    }

    public String optValueString(String root, String key) {
        setYml("application.yml");
        Map<String, Object> rootProperties = properties.get(root);
        String value = "";
        if (rootProperties != null) {
            value = (String) rootProperties.getOrDefault(key, "");
        }
        if (activeFileIsDev()) {
            setYml("application-dev.yml");
        } else {
            setYml("application-prod.yml");
        }
        rootProperties = properties.get(root);
        String priorValue = (String) rootProperties.getOrDefault(key, "");
        return Optional.ofNullable(priorValue).orElse(value);
    }

    public HashMap<String, Object> optValueHashMap(String root, String key) {
        setYml("application.yml");
        Map<String, Object> rootProperties = Optional.ofNullable(properties.get(root)).orElse(new HashMap<>());
        HashMap<String, Object> values = (HashMap<String, Object>) rootProperties.getOrDefault(key, new HashMap<>());
        if (activeFileIsDev()) {
            setYml("application-dev.yml");
        } else {
            setYml("application-prod.yml");
        }
        rootProperties = Optional.ofNullable(properties.get(root)).orElse(new HashMap<>());
        HashMap<String, Object> priorValues = (HashMap<String, Object>) rootProperties.getOrDefault(key, null);
        return Optional.ofNullable(priorValues).orElse(values);
    }

    private static void setYml(String ymlName) {
        InputStream in = null;
        properties = new HashMap<>();
        try {
            Yaml yaml = new Yaml();
            in = AppConfigReader.class.getClassLoader().getResourceAsStream(ymlName);
            properties = yaml.loadAs(in, HashMap.class);
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                LOGGER.error(e.getMessage());
            }
        }
    }

    public static boolean activeFileIsDev() {
        if (StringUtils.isBlank(AppConfigReader.PROFILES_ACTIVATED)) {
            AppConfigReader.PROFILES_ACTIVATED = (String) AppConfigReader.getInstance().optValueInApplication("spring",
                    "profiles").get("active");
        }
        return "dev".equals(AppConfigReader.PROFILES_ACTIVATED);
    }

    public HashMap<String, Object> optValueInApplication(String root, String key) {
        setYml("application.yml");
        Map<String, Object> rootProperties = properties.get(root);
        return (HashMap<String, Object>) rootProperties.getOrDefault(key, "");
    }
}