import org.springframework.context.expression.MapAccessor;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.util.PropertyPlaceholderHelper;

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
/**
 * 內(nèi)容占位符 替換
 * <p>
 * 模板占位符格式{$name}
 */
public class ContentHolderUtil {

    /**
     * 占位符前綴
     */
    private static final String PLACE_HOLDER_PREFIX = "{$";

    /**
     * 占位符后綴
     */
    private static final String PLACE_HOLDER_SUFFIX = "}";

    private static final StandardEvaluationContext EVALUATION_CONTEXT;

    private static final PropertyPlaceholderHelper PROPERTY_PLACEHOLDER_HELPER = new PropertyPlaceholderHelper(
            PLACE_HOLDER_PREFIX, PLACE_HOLDER_SUFFIX);

    static {
        EVALUATION_CONTEXT = new StandardEvaluationContext();
        EVALUATION_CONTEXT.addPropertyAccessor(new MapAccessor());
    }

    public static String replacePlaceHolder(final String template, final Map<String, String> paramMap) {
        String replacedPushContent = PROPERTY_PLACEHOLDER_HELPER.replacePlaceholders(template,
                new CustomPlaceholderResolver(template, paramMap));
        return replacedPushContent;
    }

    private static class CustomPlaceholderResolver implements PropertyPlaceholderHelper.PlaceholderResolver {
        private final String template;
        private final Map<String, String> paramMap;

        public CustomPlaceholderResolver(String template, Map<String, String> paramMap) {
            super();
            this.template = template;
            this.paramMap = paramMap;
        }

        @Override
        public String resolvePlaceholder(String placeholderName) {
            String value = paramMap.get(placeholderName);
            if (null == value) {
                String errorStr = MessageFormat.format("template:{0} require param:{1},but not exist! paramMap:{2}",
                        template, placeholderName, paramMap.toString());
                throw new IllegalArgumentException(errorStr);
            }
            return value;
        }
    }

    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("name","張三");
        map.put("age","12");
        // 注意：{$}內(nèi)不能有空格
        final String s = replacePlaceHolder("我叫 {$name}， 我今年 {$age} 歲了。", map);
        System.out.println(s);
    }
}

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-text</artifactId>
    <version>1.10.0</version>
</dependency>

<!-- lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.text.StringSubstitutor;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
public class CommonTextUtil {
    // 占位符前綴
    private static final String prefix = "${";
    // 占位符后綴
    private static final String suffix = "}";

    /*
     * commons-text
     * */
    public static String replaceVar(Map<String, Object> vars, String template) {
        if (!StringUtils.hasLength(template)) {
            log.info(String.format("調(diào)用%s方法失敗,模板字符串替換失敗,模板字符串不能為空",
                    Thread.currentThread().getStackTrace()[1].getMethodName()));
            return null;
        }
        if (CollectionUtils.isEmpty(vars)) {
            log.info(String.format("調(diào)用%s方法失敗,模板字符串替換失敗,map不能為空",
                    Thread.currentThread().getStackTrace()[1].getMethodName()));
            return null;
        }
        List<String> tempStrs = vars.keySet().stream().map(s -> prefix + s + suffix).
                collect(Collectors.toList());
        tempStrs.forEach(t -> {
            if (!template.contains(t)) {
                throw new RuntimeException(String.format("調(diào)用%s方法失敗,模板字符串替換失敗,map的key必須存在于模板字符串中",
                        Thread.currentThread().getStackTrace()[1].getMethodName()));
            }
        });
        StringSubstitutor stringSubstitutor = new StringSubstitutor(vars);
        return stringSubstitutor.replace(template);
    }

    public static void main(String[] args) {
        /*
         * 錯(cuò)誤的場(chǎng)景：比如${變量}，{}內(nèi)不能含有空格等等
         * System.out.println(replaceVar(vals, "我叫${ name},今年${age }歲."));
         * System.out.println(replaceVar(new HashMap<>(), temp));
         * System.out.println(replaceVar(vals, "我叫張三"));
         * System.out.println(replaceVar(vals, "我叫${name},今年${age1}歲."));
         * */
        Map<String, Object> vals = new HashMap<>();
        vals.put("name", "張三");
        vals.put("age", "20");
        String temp = "我叫${name},今年${age}歲.";
        System.out.println(replaceVar(vals, temp));
    }
}