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

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;

}