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

短命女 2022-11-26 08:55 279阅读 0赞

经常使用字符串替换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.
 *
 * An invocation of this method of the form
 * str{@code .replaceAll(}regex{@code ,} repl{@code )}
 * yields exactly the same result as the expression
 *
 * <blockquote>
 * <code>
 * {@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)
 * </code>
 * </blockquote>
 *
 *
 * 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 (<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.
 *
 * 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>.
 *
 * 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<String, Object> map : userMapList) {
 updateUserServiceData(tableName, map);
 }
 }catch (Exception e){
 log.error("JSON转换异常:{}",jsonStr);
 e.printStackTrace();
 }
 }