yaml文件解析

r囧r小猫 2023-06-16 13:52 38阅读 0赞

## 代码实现 ##

package com.xxx.xxx.utils;
    
    import com.xxx.xxx.schedule.CronTaskDef;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.yaml.snakeyaml.Yaml;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.util.ArrayList;
    import java.util.LinkedHashMap;
    import java.util.regex.Pattern;
    
    /**
     * @description: 批量文件系统配置文件容器
     **/
    public class BatFileConfig { 
        public LinkedHashMap configLinkedHashMap;
        private static String pattern = "([a-zA-Z0-9]+)((\\.[a-zA-Z0-9]+)*)";
        public static volatile boolean inited;
    
        public static final String PASSFILE_NFSDIR="nfsDir";
    
        public static Logger logger = LoggerFactory.getLogger(BatFileConfig.class);
    
    
        /**
         * @param configPath 配置文件路径
         * @description: 初始化所有证书
         * @return:
         */
        /**
         * 操作对象.
         */
        private static BatFileConfig config = new BatFileConfig();
    
        public static BatFileConfig getConfig() { 
            return config;
        }
        
        /*
         * 初始化yaml数据进内存configLinkedHashMap
         */
        public void inti(String configPath) { 
            logger.debug("初始化；配置文件路径：" + configPath);
            FileInputStream configFileInputStream = null;
    
            try { 
                Yaml certsYaml = new Yaml();
                File certsYamlFile = new File(configPath);
                //加载公共证书，
                configFileInputStream = new FileInputStream(certsYamlFile);
                configLinkedHashMap = certsYaml.load(configFileInputStream);
                inited = true;
            } catch (Exception ex) { 
                logger.error("初始化证书容器失败");
                logger.error(ex.getMessage());
            } finally { 
                try { 
                    configFileInputStream.close();
                } catch (Exception e) { 
                    logger.error("关闭流失败: " + e.getMessage());
                }
            }
        }
        /*
         * 获取定时任务列表
         */
        public ArrayList<CronTaskDef> getCronList()
        { 
            ArrayList<CronTaskDef> CronTasks=new ArrayList<>();
            try
            { 
                ArrayList<LinkedHashMap> CronMaps=getList("scheduledTask");
                for(LinkedHashMap map:CronMaps)
                { 
                    CronTasks.add(new CronTaskDef(map.get("cronId")==null?"":map.get("cronId").toString(),
                            map.get("cronClassName")==null?"":map.get("cronClassName").toString(),
                            map.get("cronExpression")==null?"":map.get("cronExpression").toString(),
                            map.get("cronPara")==null?"":map.get("cronPara").toString(),
                            map.get("cronStatus")==null?"":map.get("cronStatus").toString()));
                }
                return CronTasks;
    
            }
            catch (Exception ex)
            { 
                logger.error(ex.getMessage());
            }
            return null;
        }
    
        /*
         * 根据指定key获取列表数据
         */
        public ArrayList<LinkedHashMap> getList(String key) throws IllegalArgumentException { 
            //正则验证
            if (!Pattern.matches(pattern, key)) { 
                throw new IllegalArgumentException(String.format("key:%s not match pattern :%s", key, pattern));
            }
            String[] keyArray = key.split("\\.");
            LinkedHashMap map = configLinkedHashMap;
            for (int i = 0; i < keyArray.length; i++) { 
                if (i < keyArray.length - 1) { 
                    if (!(map.get(keyArray[i]) instanceof LinkedHashMap)) { 
                        return null;
                    } else { 
                        map = (LinkedHashMap) map.get(keyArray[i]);
                    }
                } else { 
                    if (map.get(keyArray[i]) instanceof ArrayList<?>) { 
                        return (ArrayList<LinkedHashMap>)map.get(keyArray[i]);
                    } else return null;
                }
            }
            return null;
        }
    
    
        /**
         * 根据指定key获取值
         * @param key 格式：xxx.xxx.xxx
         * @description:a
         * @return:a
         */
        public String getStringValue(String key) throws IllegalArgumentException { 
            //正则验证
            if (!Pattern.matches(pattern, key)) { 
                throw new IllegalArgumentException(String.format("key:%s not match pattern :%s", key, pattern));
            }
            String[] keyArray = key.split("\\.");
            LinkedHashMap map = configLinkedHashMap;
            for (int i = 0; i < keyArray.length; i++) { 
                if (i < keyArray.length - 1) { 
                    if (!(map.get(keyArray[i]) instanceof LinkedHashMap)) { 
                        return "";
                    } else { 
                        map = (LinkedHashMap) map.get(keyArray[i]);
                    }
                } else { 
                    if (map.get(keyArray[i]) != null) { 
                        return map.get(keyArray[i]).toString();
                    } else return "";
                }
            }
            return "";
        }
    }

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！