JAVA--文件内容属性替换

说明：文件中执行内容是变量，随着环境不同会配置不同，在程序启动后，读取配置进行变量替换

1、测试类如下：

public class FileUtilsTest {

    //public static boolean fileAttributesReplace(String filePath,String propFilePath)

    @org.junit.Test

    public void testFileAttributesReplace() throws Exception {

        String filePath = FileUtils.getProjectAbsoluteRootPath() +"\\src\\main\\resources\\FileUtils\\test.yml";

        String propFilePath = FileUtils.getProjectAbsoluteRootPath() +"\\src\\main\\resources\\FileUtils\\prop.properties";

        System.out.println(FileUtils.fileAttributesReplace(filePath,propFilePath));

    }

}

2、替换前文件分别内容分别是：

替换前文件内容：

1）test.yml

---

name: init

init:

#create ~

  - type: ${key}

    operate: create

    tableName: {A}

    columnFamily:

    - name: cf

      blocksize:

      ttl:

      #compression: SNAPPY

    - name: cm

      blocksize:

      ttl:

      #compression: SNAPPY

    regionFilePath: {{ hdm_home_dir }}/init/traffic/conf/hbase/regions.txt

2）属性properties文件内容

prop.properties

key = testkey

A =sdklfkjslghjsjgslgfljsdgj

3）替换后文件内容：

test.yml

---

name: init

init:

#create ~

  - type: testkey

    operate: create

    tableName: sdklfkjslghjsjgslgfljsdgj

    columnFamily:

    - name: cf

      blocksize:

      ttl:

      #compression: SNAPPY

    - name: cm

      blocksize:

      ttl:

      #compression: SNAPPY

    regionFilePath: {{ hdm_home_dir }}/init/traffic/conf/hbase/regions.txt

相关程序代码：

    /**

     * 获取工程的根目录绝对路径，“D:\workdir\HWF”

     *

     * @return

     */

    public static String getProjectAbsoluteRootPath() {

        return System.getProperty("user.dir");

    }

 /**

     * filePath文件中的属性用propFilePath文件中具有相同key的value值替换

     * @param filePath 为需要替换属性的文件路径

     * @param propFilePath properties文件路径

     * @return 是否wan全部替换成功

     */

    public static boolean fileAttributesReplace(String filePath,String propFilePath){

        if(org.apache.commons.lang.StringUtils.isEmpty(filePath) || org.apache.commons.lang.StringUtils.isEmpty(propFilePath) ){

            LOG.error("filePath = {} or propFilePath = {} is empty",filePath,propFilePath);

            return false;

        }

        if(!new File(filePath).exists() || !new File(propFilePath).exists()){

            LOG.error("filePath = {} or propFilePath = {} 不存在",filePath,propFilePath);

            return false;

        }

        //把文件内容全部读取到List中，然后做属性替换，替换完成后，重新写文件

        List<String> list = readFileToList(filePath);

        Map<String,String> map = readPropFileToMap(propFilePath);

        List<String> result = attributesReplace(list,map);

        return writeListToFile(result,filePath);

    }

    /**

     * 属性替换

     * @param list

     * @param map

     * @return

     */

    public static List<String> attributesReplace(List<String> list, Map<String,String> map){

        if(list.size() <  || map.size() < ){

            return list;

        }

        List<String> result = new ArrayList<>();

        //生成匹配模式的正则表达式

        String patternString = "\\$\\{(" + org.apache.commons.lang.StringUtils.join(map.keySet(), "|") + ")\\}";

        Pattern pattern = Pattern.compile(patternString);

        for (String template : list) {

            Matcher matcher = pattern.matcher(template);

            //两个方法：appendReplacement, appendTail

            StringBuffer sb = new StringBuffer();

            while(matcher.find()) {

                matcher.appendReplacement(sb, map.get(matcher.group()));

            }

            matcher.appendTail(sb);

            result.add(sb.toString());

        }

        return result;

    }

    /**

     * 把list内容写入到文件中

     * @param list

     * @param filePath

     * @return

     */

    public static boolean writeListToFile(List<String> list,String filePath){

        BufferedWriter writer = null;

        try {

            if(new File(filePath).exists()){

                if(!new File(filePath).delete()){

                    LOG.error("删除文件：{}失败", filePath);

                }

            }

            writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath, true), UTF8_CHARSET));

            for (String temp : list) {

                writer.write(temp + "\n");

            }

            writer.flush();

            return true;

        } catch (IOException e) {

            LOG.error("写文件:{} 出现IO异常,异常信息:{}",filePath,e.getMessage());

            return false;

        }finally {

            if(null != writer){

                try {

                    writer.close();

                } catch (IOException e) {

                    LOG.error("文件：{}，关闭文件流时发生异常：{}", filePath, e.getMessage());

                }

            }

        }

    }

    /**

     * 读取文件内容放到List

     * @param filePath

     * @return

     */

    public static List<String> readFileToList(String filePath){

        if(org.apache.commons.lang.StringUtils.isEmpty(filePath)){

            LOG.error("filePath = {} is empty",filePath);

            return new ArrayList<>();

        }

        if(!new File(filePath).exists() ){

            LOG.error("filePath = {} 不存在",filePath);

            return new ArrayList<>();

        }

        BufferedReader reader = null;

        try {

            reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File(filePath)), UTF8_CHARSET));

            String tempString;

            List<String> list = new ArrayList<>();

            while ((tempString = reader.readLine()) != null) {

                list.add(tempString);

            }

            return list;

        } catch (FileNotFoundException e){

            LOG.error("filePath = {} 不存在",filePath);

            return new ArrayList<>();

        }catch (IOException e){

            LOG.error("读取filePath = {} 文件发生异常，异常信息:{}",filePath,e.getMessage());

            return new ArrayList<>();

        }finally{

            if ( null != reader ) {

                try {

                    reader.close();

                } catch (IOException e) {

                    LOG.error("文件：{}，关闭文件流时发生异常：{}", filePath, e.getMessage());

                }

            }

        }

    }

    /**

     * 拷贝src文件成dst文件

     * @param src

     * @param dst

     * @return

     */

    public static boolean copy(String src,String dst){

        BufferedReader reader = null;

        BufferedWriter writer = null;

        try {

            reader = new BufferedReader(new InputStreamReader(new FileInputStream(src), UTF8_CHARSET));

            String temp;

            writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(dst, true), UTF8_CHARSET));

            while ((temp = reader.readLine()) != null) {

                writer.write(temp + "\n");

            }

            writer.flush();

            LOG.info("复制文件从src ={} 到dst = {} 成功", src, dst);

            return true;

        } catch (IOException e) {

            LOG.error("复制文件从src ={} 到dst = {} 出现IO异常,error:{}",src,dst,StringUtils.getMsgFromException(e));

            return false;

        }finally {

            if(null != reader){

                try {

                    reader.close();

                } catch (IOException e) {

                    LOG.error("文件：{}，关闭文件流时发生异常：{}", src, e.getMessage());

                }

            }

            if(null != writer){

                try {

                    writer.close();

                } catch (IOException e) {

                    LOG.error("文件：{}，关闭文件流时发生异常：{}", dst, e.getMessage());

                }

            }

        }

    }

    /**

     * 读取properties文件内容转成map

     * @param propFilePath properties文件路径

     * @return map

     */

    public static Map<String,String> readPropFileToMap(String propFilePath){

        Map<String, String> map = new HashMap<>();

        if(org.apache.commons.lang.StringUtils.isEmpty(propFilePath)){

            LOG.error("propFilePath = {} is empty",propFilePath);

            return map;

        }

        File propFile = new File(propFilePath);

        if(!propFile.exists()){

            LOG.error("propFilePath = {} 不存在",propFilePath);

            return map;

        }

        Properties prop = new Properties();

        try {

            prop.load(new BufferedReader(new InputStreamReader(new FileInputStream(propFile), Charset.forName(Constants.UTF8))));

        } catch (FileNotFoundException e){

            LOG.error("propFilePath = {} 不存在",propFilePath);

            return map;

        } catch(IOException e) {

           LOG.error("加载propFilePath = {} 文件出现异常，异常信息：{}" ,propFilePath,e.getMessage());

            return map;

        }

        for (Map.Entry<Object, Object> entry : prop.entrySet()) {

            map.put(((String)entry.getKey()).trim(),((String)entry.getValue()).trim());

        }

        return map;

    }

巴特西

JAVA--文件内容属性替换

最新文章

热门文章