/**
 * 根據(jù)正則表達式獲取文本中的變量名列表
 * @param pattern
 * @param content
 * @return
 */
public static List<String> getParams(String pattern, String content) {
 Pattern p = Pattern.compile(pattern);
 Matcher m = p.matcher(content);
 
 List<String> result = new ArrayList<String>();
 while (m.find()) {
  result.add(m.group(1));
 }
 return result;
}
 
/**
 * 根據(jù)正則表達式將文本中的變量使用實際的數(shù)據(jù)替換成無變量的文本
 * @param pattern
 * @param content
 * @param data
 * @return
 */
public static String parse(String pattern, String content, Map<String, String> data) {
 Pattern p = Pattern.compile(pattern);
 Matcher m = p.matcher(content);
 
 StringBuffer sb = new StringBuffer();
 while (m.find()) {
  String key = m.group(1);
  String value = data.get(key);
  m.appendReplacement(sb, value == null ? "" : value);
 }
 m.appendTail(sb);
 return sb.toString();
}
 
public static void main(String[] args) {
 String content = "恭喜{{姓名}}報名成功，請憑報名編號{[code]}到現(xiàn)場參加活動";
 String reg = "\\{\\{(.+?)\\}\\}";
 List<String> params = getParams(reg, content);
 System.out.println(params);
 
 Map<String, String> data = new HashMap<String, String>();
 data.put("姓名", "張三豐");
 data.put("code", "930118");
 String text = parse(reg, content, data);
 System.out.println(text);
}

/**
 * 占位符解析器
 *
 * @author meilin.huang
 * @version 1.0
 * @date 2018-11-13 1:42 PM
 */
public class PlaceholderResolver {
 /**
  * 默認前綴占位符
  */
 public static final String DEFAULT_PLACEHOLDER_PREFIX = "${";

 /**
  * 默認后綴占位符
  */
 public static final String DEFAULT_PLACEHOLDER_SUFFIX = "}";

 /**
  * 默認單例解析器
  */
 private static PlaceholderResolver defaultResolver = new PlaceholderResolver();

 /**
  * 占位符前綴
  */
 private String placeholderPrefix = DEFAULT_PLACEHOLDER_PREFIX;

 /**
  * 占位符后綴
  */
 private String placeholderSuffix = DEFAULT_PLACEHOLDER_SUFFIX;


 private PlaceholderResolver(){}

 private PlaceholderResolver(String placeholderPrefix, String placeholderSuffix) {
  this.placeholderPrefix = placeholderPrefix;
  this.placeholderSuffix = placeholderSuffix;
 }

 /**
  * 獲取默認的占位符解析器，即占位符前綴為"${", 后綴為"}"
  * @return
  */
 public static PlaceholderResolver getDefaultResolver() {
  return defaultResolver;
 }

 public static PlaceholderResolver getResolver(String placeholderPrefix, String placeholderSuffix) {
  return new PlaceholderResolver(placeholderPrefix, placeholderSuffix);
 }

 /**
  * 解析帶有指定占位符的模板字符串，默認占位符為前綴：${ 后綴：}<br/><br/>
  * 如：template = category:${}:product:${}<br/>
  * values = {"1", "2"}<br/>
  * 返回 category:1:product:2<br/>
  *
  * @param content 要解析的帶有占位符的模板字符串
  * @param values 按照模板占位符索引位置設置對應的值
  * @return
  */
 public String resolve(String content, String... values) {
  int start = content.indexOf(this.placeholderPrefix);
  if (start == -1) {
   return content;
  }
  //值索引
  int valueIndex = 0;
  StringBuilder result = new StringBuilder(content);
  while (start != -1) {
   int end = result.indexOf(this.placeholderSuffix);
   String replaceContent = values[valueIndex++];
   result.replace(start, end + this.placeholderSuffix.length(), replaceContent);
   start = result.indexOf(this.placeholderPrefix, start + replaceContent.length());
  }
  return result.toString();
 }

 /**
  * 解析帶有指定占位符的模板字符串，默認占位符為前綴：${ 后綴：}<br/><br/>
  * 如：template = category:${}:product:${}<br/>
  * values = {"1", "2"}<br/>
  * 返回 category:1:product:2<br/>
  *
  * @param content 要解析的帶有占位符的模板字符串
  * @param values 按照模板占位符索引位置設置對應的值
  * @return
  */
 public String resolve(String content, Object[] values) {
  return resolve(content, Stream.of(values).map(String::valueOf).toArray(String[]::new));
 }

 /**
  * 根據(jù)替換規(guī)則來替換指定模板中的占位符值
  * @param content 要解析的字符串
  * @param rule 解析規(guī)則回調
  * @return
  */
 public String resolveByRule(String content, Function<String, String> rule) {
  int start = content.indexOf(this.placeholderPrefix);
  if (start == -1) {
   return content;
  }
  StringBuilder result = new StringBuilder(content);
  while (start != -1) {
   int end = result.indexOf(this.placeholderSuffix, start);
   //獲取占位符屬性值，如${id}, 即獲取id
   String placeholder = result.substring(start + this.placeholderPrefix.length(), end);
   //替換整個占位符內容，即將${id}值替換為替換規(guī)則回調中的內容
   String replaceContent = placeholder.trim().isEmpty() ? "" : rule.apply(placeholder);
   result.replace(start, end + this.placeholderSuffix.length(), replaceContent);
   start = result.indexOf(this.placeholderPrefix, start + replaceContent.length());
  }
  return result.toString();
 }

 /**
  * 替換模板中占位符內容，占位符的內容即為map key對應的值，key為占位符中的內容。<br/><br/>
  * 如：content = product:${id}:detail:${did}<br/>
  * valueMap = id -> 1; pid -> 2<br/>
  * 經(jīng)過解析返回 product:1:detail:2<br/>
  *
  * @param content 模板內容。
  * @param valueMap 值映射
  * @return 替換完成后的字符串。
  */
 public String resolveByMap(String content, final Map<String, Object> valueMap) {
  return resolveByRule(content, placeholderValue -> String.valueOf(valueMap.get(placeholderValue)));
 }

 /**
  * 根據(jù)properties文件替換占位符內容
  * @param content
  * @param properties
  * @return
  */
 public String resolveByProperties(String content, final Properties properties) {
  return resolveByRule(content, placeholderValue -> properties.getProperty(placeholderValue));
 }

 /**
  * 根據(jù)對象中字段路徑(即類似js訪問對象屬性值)替換模板中的占位符 <br/><br/>
  * 如 content = product:${id}:detail:${detail.id} <br/>
  * obj = Product.builder().id(1).detail(Detail.builder().id(2).build()).build(); <br/>
  * 經(jīng)過解析返回 product:1:detail:2 <br/>
  *
  * @param content 要解析的內容
  * @param obj 填充解析內容的對象(如果是基本類型，則所有占位符替換為相同的值)
  * @return
  */
 public String resolveByObject(String content, final Object obj) {
  if (obj instanceof Map) {
   return resolveByMap(content, (Map)obj);
  }
  return resolveByRule(content, placeholderValue -> String.valueOf(ReflectionUtils.getValueByFieldPath(obj, placeholderValue)));
 }
}