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

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

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

替换源码


/**
     * Replaces each substring of this string that matches the given <a
     * href="../util/regex/Pattern.html#sum">regular expression</a> with the
     * given replacement.
     *
     * <p> An invocation of this method of the form
     * <i>str</i>{@code .replaceAll(}<i>regex</i>{@code ,} <i>repl</i>{@code )}
     * yields exactly the same result as the expression
     *
     * <blockquote>
     * <code>
     * {@link java.util.regex.Pattern}.{@link
     * java.util.regex.Pattern#compile compile}(<i>regex</i>).{@link
     * java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(<i>str</i>).{@link
     * java.util.regex.Matcher#replaceAll replaceAll}(<i>repl</i>)
     * </code>
     * </blockquote>
     *
     *<p>
     * 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.
     *
     * <p> 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.
     *
     * <p> Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) 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.
     *
     * <p> Given the regular expression <tt>a*b</tt>, the input
     * <tt>"aabfooaabfooabfoob"</tt>, and the replacement string
     * <tt>"-"</tt>, an invocation of this method on a matcher for that
     * expression would yield the string <tt>"-foo-foo-foo-"</tt>.
     *
     * <p> 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.  </p>
     *
     * @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<String, Object> map : userMapList) {
                        updateUserServiceData(tableName, map);
                    }
                }catch (Exception e){
                    log.error("JSON转换异常:{}",jsonStr);
                    e.printStackTrace();
                }
            }