Java返回数据带有转义符号问题

数据库存的是 String 类型的一个 json 格式字符串，通过 Java 返回到前端的时候带有 / 转义符号，请问对于这个问题应该怎么处理

img

smallList 这是 返回的是 json字符串数据，字符串如果有 双引号 ，就是 需要转义的，这个是正常的，你取出来看就没有了

img

JSON.parse(str)

img

我只好贴图了~ 神一样的提醒，保存不了~

你存的string格式那就有这个转义符，你可以把它转一下转成jsonObject类

  • 这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7515457
  • 这篇博客你也可以参考下：将String类型的json字符串转为java对象
  • 除此之外, 这篇博客: 验证JSON格式（长度，字段类型，必填等等）中的 剩下的就是实际报文跟这个验证规则进行验证处理了，下面贴上java代码 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  • //返回错误信息list，string[]第一位是错误code，第二位是具体错误说明
public static List<String[]> checkDo(String params, String rules) {
            List<String[]> errors = new java.util.LinkedList<String[]>();
        try {
            if (StrKit.isBlank(rules)) {// 不需要验证
                return errors;
            }
            Map<String, Object> data = gson.fromJson(params, Map.class);
            Map<String, Map<String, Object>> checkMap = gson.fromJson(rules, Map.class);
            checkDo(data, checkMap, errors);
        } catch (Exception e) {
            e.printStackTrace();
            errors.add(new String[] {"7", e.getMessage()});
        }
        return errors;
    }

    public static void checkDo(Map<String, Object> data, Map<String, Map<String, Object>> checkMap, List<String[]> errors) {
        Set<String> keys = data.keySet();
        for(Map.Entry<String, Object> entry : data.entrySet()){
            String key = entry.getKey();
            Object val = entry.getValue();
            
            Map<String, Object> rc = checkMap.get(key);
            if (null == rc) {
                if (val instanceof String || val instanceof Number) {// 不需要的字段
                    errors.add(new String[] {"3", "字段找不到匹配内容：" + key});
                } else {// 不需要的节点
                    errors.add(new String[] {"3", "字段找不到匹配内容：" + key});
                }
                continue;
            }

            for(Entry<String, Map<String, Object>> entry2 : checkMap.entrySet()){
                String key2 = entry2.getKey();
                Map<String, Object> rcc = entry2.getValue();
                
                Integer required = getInt(rcc, "required");
                if (!keys.contains(key2) && null != required && required.intValue() == 1) {
                    errors.add(new String[] {"5", "字段不存在：" + key2});
                    continue;
                }
            }

            String v_type = getStr(rc, "type");
            switch (v_type) {
                case "field":// 字段,验证必填、长度
                    String field_type = getStr(rc, "field_type");
                    Integer required = getInt(rc, "required");
                    Integer field_length = getInt(rc, "field_length");

                    switch (field_type) {
                        case "string": // 字符串
                            if (!(null == val || val instanceof String || val instanceof Number)) {
                                // errors.add(key + "，应为一个字段，不是节点。");
                                errors.add(new String[] {"2", "字段类型不匹配：" + key});
                                continue;
                            }

                            if (null != required && required.intValue() == 1) {// 必填
                                if (null == val || "".equals(String.valueOf(val))) {
                                    // errors.add(key + "不能为空");
                                    errors.add(new String[] {"6", "字段内容不能为空：" + key});
                                    continue;
                                }
                            }
                            if (null != field_length) {
                                if (null != val && String.valueOf(val).length() > field_length) {
                                    // errors.add(key + "超长（最大" + field_length + "），" + val + "长" + String.valueOf(val).length() + "。");
                                    errors.add(new String[] {"1", "字段长度不合规：" + key + "，规定长度" + field_length});
                                    continue;
                                }
                            }
                            break;
                        case "int":// 数值
                            if (!(null == val || val instanceof String || val instanceof Number)) {
                                // errors.add(key + "，应为一个字段，不是节点。");
                                errors.add(new String[] {"2", "字段类型不匹配：" + key});
                                continue;
                            }

                            Integer v_int = null;
                            try {
                                if (null != val) {
                                    v_int = Double.valueOf(String.valueOf(val)).intValue();
                                }
                            } catch (Exception e) {
                                // errors.add(key + "，字段类型错误，应为‘int’");
                                errors.add(new String[] {"2", "字段类型不匹配：" + key});
                                continue;
                            }
                            if (null != required && required.intValue() == 1) {// 必填
                                if (null == v_int) {
                                    // errors.add(key + "不能为空");
                                    errors.add(new String[] {"6", "字段内容不能为空：" + key});
                                    continue;
                                }
                            }
                            if (null != field_length) {
                                if (null != v_int && v_int.toString().length() > field_length) {
                                    // errors.add(key + "超长（最大" + field_length + "），" + val + "长" + String.valueOf(val).length() + "。");
                                    errors.add(new String[] {"1", "字段长度不合规：" + key + "，规定长度" + field_length});
                                    continue;
                                }
                            }
                            break;
                        case "float":// float
                            if (!(null == val || val instanceof String || val instanceof Number)) {
                                // errors.add(key + "，应为一个字段，不是节点。");
                                errors.add(new String[] {"2", "字段类型不匹配：" + key});
                                continue;
                            }

                            Double v_float = null;
                            try {
                                if (null != val) {
                                    v_float = Double.valueOf(String.valueOf(val));
                                }
                            } catch (Exception e) {
                                // errors.add(key + "，字段类型错误，应为‘float’");
                                errors.add(new String[] {"2", "字段类型不匹配：" + key});
                                continue;
                            }
                            if (null != required && required.intValue() == 1) {// 必填
                                if (null == v_float) {
                                    // errors.add(key + "不能为空");
                                    errors.add(new String[] {"6", "字段内容不能为空：" + key});
                                    continue;
                                }
                            }
                            if (null != field_length) {
                                if (null != v_float && v_float.toString().length() > field_length) {
                                    // errors.add(key + "超长（最大" + field_length + "），" + val + "长" + String.valueOf(val).length() + "。");
                                    errors.add(new String[] {"1", "字段长度不合规：" + key + "，规定长度" + field_length});
                                    continue;
                                }
                            }
                            break;
                        case "timestamp":
                            if (!(null == val || val instanceof String || val instanceof Number)) {
                                // errors.add(key + "，应为一个字段，不是节点。");
                                errors.add(new String[] {"2", "字段类型不匹配：" + key});
                                continue;
                            }

                            Long v_long = null;
                            try {
                                if (null != val) {
                                    v_long = Double.valueOf(String.valueOf(val)).longValue();
                                }
                            } catch (Exception e) {
                                // errors.add(key + "，字段类型错误，应为‘timestamp’");
                                errors.add(new String[] {"2", "字段类型不匹配：" + key});
                                continue;
                            }
                            if (null != required && required.intValue() == 1) {// 必填
                                if (null == v_long) {
                                    // errors.add(key + "不能为空");
                                    errors.add(new String[] {"6", "字段内容不能为空：" + key});
                                    continue;
                                }
                            }
                            if (null != field_length) {
                                if (null != v_long && v_long.toString().length() > field_length) {
                                    // errors.add(key + "超长（最大" + field_length + "），" + val + "长" + String.valueOf(val).length() + "。");
                                    errors.add(new String[] {"1", "字段长度不合规：" + key + "，规定长度" + field_length});
                                    continue;
                                }
                            }
                            break;
                        default:
                            break;
                    }
                    break;
                case "array":// 数组
                    if (!(null == val || val instanceof Collection)) {
                        // errors.add(key + "，应为一个数组。");
                        errors.add(new String[] {"2", "字段类型不匹配：" + key});
                        continue;
                    }
                    if (null != rc.get("childFileds") && null != val) {
                        List<Map<String, Object>> ll = (List<Map<String, Object>>) val;
                        for (Map<String, Object> m : ll) {
                            checkDo(m, (Map<String, Map<String, Object>>) rc.get("childFileds"), errors);
                        }
                    }
                    break;
                case "map":// 对象
                    if (!(null == val || val instanceof Map)) {
                        // errors.add(key + "，应为一个对象。");
                        errors.add(new String[] {"2", "字段类型不匹配：" + key});
                        continue;
                    }
                    if (null != rc.get("childFileds") && null != val) {
                        checkDo((Map<String, Object>) val, (Map<String, Map<String, Object>>) rc.get("childFileds"), errors);
                    }
                    break;
                default:
                    break;
            }
        }
    }
}

 public static final Integer getInt(Map<?, ?> map, String key) {
        Object i = map.get(key);
        if (null != i && !StrKit.isBlank(String.valueOf(i))) {
            return Double.valueOf(String.valueOf(i)).intValue();
        }
        return null;
    }

    public static String getStr(Map<?, ?> map, String key) {
        Object i = map.get(key);
        if (null != i) {
            return String.valueOf(i);
        }
        return null;
    }
  • 以下回答由chatgpt基于相关博客总结生成:

    问题内容中提到从数据库返回的字符串是以JSON格式存储的，并且带有转义符号。为了处理这个问题，可以按照以下步骤进行处理：

    1. 首先，需要将返回的字符串解析为JSON对象。可以使用Java中的JSON库，如fastjson或者Jackson，来进行解析。以下是使用fastjson库的示例代码：
    import com.alibaba.fastjson.JSON;

String jsonString = "{\"id\":\"001\",\"category\":\"classroom\",\"capacity\":\"100\",\"name\":\"Room A\",\"area\":\"100 sqm\",\"seat\":\"fixed\",\"vcd\":\"yes\",\"warm\":\"no\"}";
JSONObject jsonObject = JSON.parseObject(jsonString);
    1. 解析完JSON对象后，可以通过使用get()方法获取相应的属性值。以下是获取属性值的示例代码：
    String id = jsonObject.getString("id");
String category = jsonObject.getString("category");
String capacity = jsonObject.getString("capacity");
String name = jsonObject.getString("name");
String area = jsonObject.getString("area");
String seat = jsonObject.getString("seat");
String vcd = jsonObject.getString("vcd");
String warm = jsonObject.getString("warm");
    1. 如果需要将处理结果返回给前端，可以将获取到的属性值封装为一个新的对象，然后将该对象序列化为JSON格式的字符串返回给前端。可以使用库中提供的方法来进行序列化，例如fastjson库的toJSONString()方法。以下是封装和序列化的示例代码：
    import com.alibaba.fastjson.JSON;

Classroom classroom = new Classroom(id, category, capacity, name, area, seat, vcd, warm);
String result = JSON.toJSONString(classroom);
return result;

    以上代码示例中，Classroom是一个自定义的类，用于封装教室的属性。在示例代码中，将获取到的属性值传入Classroom对象的构造方法中，然后使用fastjson的toJSONString()方法将Classroom对象序列化为JSON格式的字符串。

    1. 如果希望处理结果按照统一的返回规范进行封装，可以创建一个统一的API响应结果封装类，将处理结果封装到该类的属性中，然后再将该类序列化为JSON格式的字符串返回给前端。可以使用参考资料中提供的ResponseBody类进行封装和序列化。
    import com.alibaba.fastjson.JSON;

ResponseBody response = new ResponseBody(ResultCode.SUCCESS, result);
String responseJson = JSON.toJSONString(response);
return responseJson;

    以上代码示例中，ResponseBody类是一个用于封装API响应结果的类，其中包含了code、message和data三个属性，可以根据具体需求进行修改。在示例代码中，使用ResultCode.SUCCESS作为响应状态，将处理结果result作为data属性值传入ResponseBody对象的构造方法中，然后使用fastjson的toJSONString()方法将ResponseBody对象序列化为JSON格式的字符串。

    请注意，以上只是给出了处理这个问题的一种可能的方法，具体的实现方式可能根据你的实际需求和代码结构有所不同。如果以上方法不适用于你的情况，请提供更多的详情和代码，以便可以提供更准确的解决方案。