Java 操作Fastjson JSON字符串转义正确处理方式

经常使用字符串替换replace或者replaceAll ，而replaceAll是基于正则表达式实现的。

本文重点关注的是批量替换replaceAll方法。

目录

替换源码

错误示例

正确示例

真实示例

---

替换源码

/**
     * Replaces each substring of this string that matches the given regular expression with the
     * given replacement.
     *
     * 
 An invocation of this method of the form
     * str{@code .replaceAll(}regex{@code ,} repl{@code )}
     * yields exactly the same result as the expression
     *
     * 

     * 
     * {@link java.util.regex.Pattern}.{@link
     * java.util.regex.Pattern#compile compile}(regex).{@link
     * java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(str).{@link
     * java.util.regex.Matcher#replaceAll replaceAll}(repl)
     * 
     * 
     *
     *

     * Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
     * replacement string may cause the results to be different than if it were
     * being treated as a literal replacement string; see
     * {@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}.
     * Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special
     * meaning of these characters, if desired.
     *
     * @param   regex
     *          the regular expression to which this string is to be matched
     * @param   replacement
     *          the string to be substituted for each match
     *
     * @return  The resulting {@code String}
     *
     * @throws  PatternSyntaxException
     *          if the regular expression's syntax is invalid
     *
     * @see java.util.regex.Pattern
     *
     * @since 1.4
     * @spec JSR-51
     */
    public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

 /**
     * Replaces every subsequence of the input sequence that matches the
     * pattern with the given replacement string.
     *
     * 
 This method first resets this matcher.  It then scans the input
     * sequence looking for matches of the pattern.  Characters that are not
     * part of any match are appended directly to the result string; each match
     * is replaced in the result by the replacement string.  The replacement
     * string may contain references to captured subsequences as in the {@link
     * #appendReplacement appendReplacement} method.
     *
     * 
 Note that backslashes (\) and dollar signs ($) in
     * the replacement string may cause the results to be different than if it
     * were being treated as a literal replacement string. Dollar signs may be
     * treated as references to captured subsequences as described above, and
     * backslashes are used to escape literal characters in the replacement
     * string.
     *
     * 
 Given the regular expression a*b, the input
     * "aabfooaabfooabfoob", and the replacement string
     * "-", an invocation of this method on a matcher for that
     * expression would yield the string "-foo-foo-foo-".
     *
     * 
 Invoking this method changes this matcher's state.  If the matcher
     * is to be used in further matching operations then it should first be
     * reset.  
     *
     * @param  replacement
     *         The replacement string
     *
     * @return  The string constructed by replacing each matching subsequence
     *          by the replacement string, substituting captured subsequences
     *          as needed
     */
    public String replaceAll(String replacement) {
        reset();
        boolean result = find();
        if (result) {
            StringBuffer sb = new StringBuffer();
            do {
                appendReplacement(sb, replacement);
                result = find();
            } while (result);
            appendTail(sb);
            return sb.toString();
        }
        return text.toString();
    }

错误示例

// 回车符
“string”.replaceAll("\r","");
// 换行符
“string”.replaceAll("\n","");
// 缩进
“string”.replaceAll("\t","");
// 反斜杠
“string”.replaceAll("\","");

// 回车符
“string”.replaceAll("\\r","");
// 换行符
“string”.replaceAll("\\n","");
// 缩进
“string”.replaceAll("\\t","");
// 反斜杠
“string”.replaceAll("\\","");

正确示例

// 回车符
“string”.replaceAll("\\\\r","");
// 换行符
“string”.replaceAll("\\\\n","");
// 缩进
“string”.replaceAll("\\\\t","");
// 反斜杠
“string”.replaceAll("\\\\","");

真实示例

            JSONObject jsonObject;
            for (String s : templateMap.keySet()) {
                String jsonStr = templateMap.get(s).toString();
                try{
                    // 去掉换行、回车、缩进、转义字符
                    jsonStr = jsonStr.replaceAll("\\\\n|\\\\r|\\\\t","");
                    jsonObject = JSONObject.parseObject(jsonStr);
                    String tableName = jsonObject.getString("TABLE_NAME");
                    for (Map map : userMapList) {
                        updateUserServiceData(tableName, map);
                    }
                }catch (Exception e){
                    log.error("JSON转换异常:{}",jsonStr);
                    e.printStackTrace();
                }
            }