如何将对象转化成json字符串

如何将对象转化成 JSON 字符串：从基础到实践的全面指南

在当今的软件开发中，JSON（JavaScript Object Notation）已成为数据交换的事实标准，无论是前后端数据交互、API 通信，还是配置文件存储，将编程语言中的对象转换为 JSON 字符串都是一项至关重要的技能，本文将详细介绍如何在不同主流编程语言中将对象转化为 JSON 字符串，涵盖基础方法、高级选项及常见问题解决方案。

为什么需要将对象转为 JSON 字符串？

在探讨如何实现之前,我们首先需要理解其必要性：

1. 数据交换：JSON 是一种轻量级、文本化的数据格式，易于阅读和编写，也易于机器解析和生成，大多数现代 API 都使用 JSON 作为请求和响应的数据格式。
2. 跨语言通信：JSON 是语言无关的，不同编程语言的对象都可以转换为 JSON 字符串进行传输,接收方再将其解析为自身语言的对象。
3. 数据持久化：将对象以 JSON 格式保存到文件或数据库中,方便后续读取和恢复。
4. 配置管理：许多应用程序使用 JSON 文件来存储配置信息,因其结构清晰且易于修改。

主流编程语言中对象转 JSON 的方法

不同编程语言提供了将对象序列化为 JSON 字符串的机制,通常内置或通过第三方库实现。

Python

Python 中最常用的库是 json。

• 基础方法：json.dumps() json.dumps() (dump string) 用于将 Python 对象转换为 JSON 格式的字符串。

  import json
  # 定义一个 Python 字典（对象）
  person = {
      "name": "张三",
      "age": 30,
      "is_student": False,
      "courses": ["数学", "英语"],
      "address": {
          "street": "人民路123号",
          "city": "北京"
      }
  }
  # 将字典转换为 JSON 字符串
  json_string = json.dumps(person)
  print(json_string)
  # 输出: {"name": "张三", "age": 30, "is_student": false, "courses": ["数学", "英语"], "address": {"street": "人民路123号", "city": "北京"}}

• 美化输出（格式化） 使用 indent 参数可以使 JSON 字符串更具可读性。

  pretty_json_string = json.dumps(person, indent=4, ensure_ascii=False)
  print(pretty_json_string)
  # 输出:
  # {
  #     "name": "张三",
  #     "age": 30,
  #     "is_student": false,
  #     "courses": [
  #         "数学",
  #         "英语"
  #     ],
  #     "address": {
  #         "street": "人民路123号",
  #         "city": "北京"
  #     }
  # }

  ensure_ascii=False 确保非 ASCII 字符（如中文）能正确显示,而不是被转义。

• 处理自定义对象 默认情况下，json.dumps() 无法直接处理自定义类的实例，需要通过 default 参数指定一个序列化函数，或实现 default() 方法（如果继承自 JSONEncoder）。

  class Person:
      def __init__(self, name, age):
          self.name = name
          self.age = age
  person_obj = Person("李四", 25)
  # 方法一：使用 default 参数
  def serialize_person(obj):
      if isinstance(obj, Person):
          return {"name": obj.name, "age": obj.age}
      raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")
  json_custom = json.dumps(person_obj, default=serialize_person)
  print(json_custom)  # 输出: {"name": "李四", "age": 25}
  # 方法二：继承 JSONEncoder
  class PersonEncoder(json.JSONEncoder):
      def default(self, obj):
          if isinstance(obj, Person):
              return {"name": obj.name, "age": obj.age}
          return super().default(obj)
  json_custom_encoder = json.dumps(person_obj, cls=PersonEncoder)
  print(json_custom_encoder)  # 输出: {"name": "李四", "age": 25}

JavaScript (Node.js & Browser)

JavaScript 中，JSON 是内置对象,转换非常直接。

• Node.js 环境或现代浏览器：JSON.stringify() JSON.stringify() 方法将 JavaScript 对象或值转换为 JSON 字符串。

  // 定义一个 JavaScript 对象
  const person = {
      name: "王五",
      age: 28,
      isStudent: false,
      courses: ["物理", "化学"],
      address: {
          street: "南京路456号",
          city: "上海"
      }
  };
  // 将对象转换为 JSON 字符串
  const jsonString = JSON.stringify(person);
  console.log(jsonString);
  // 输出: {"name":"王五","age":28,"isStudent":false,"courses":["物理","化学"],"address":{"street":"南京路456号","city":"上海"}}

• 美化输出（格式化） JSON.stringify() 也支持格式化，通过 space 参数。

  const prettyJsonString = JSON.stringify(person, null, 2); // 缩进2个空格
  console.log(prettyJsonString);
  // 输出:
  // {
  //   "name": "王五",
  //   "age": 28,
  //   "isStudent": false,
  //   "courses": [
  //     "物理",
  //     "化学"
  //   ],
  //   "address": {
  //     "street": "南京路456号",
  //     "city": "上海"
  //   }
  // }

• 处理循环引用和自定义序列化 JSON.stringify() 默认会忽略循环引用和不可枚举的属性，可以通过 replacer 函数进行更精细的控制。

  const circularObj = {};
  circularObj.a = circularObj;
  // 直接序列化会报错或返回 undefined
  // console.log(JSON.stringify(circularObj)); // TypeError: Converting circular structure to JSON...
  // 使用 replacer 处理（简单示例：跳过循环引用）
  function replacer(key, value) {
      if (key === "") return value; // 根对象
      if (value === this[key]) { // 检测是否是循环引用
          return "[Circular]";
      }
      return value;
  }
  // 注意：上面的 replacer 简单示例可能不够健壮，实际处理复杂循环引用需要更小心。
  // 更常见的是在构建对象时避免循环引用，或使用专门的库。

Java

Java 中没有内置的 JSON 处理能力（直到 Java EE 8 引入了 JSON-P 和 JSON-B，但更常用第三方库），最流行的库是 Gson (Google) 和 Jackson。

• 使用 Jackson 库 首先添加 Jackson 依赖 (Maven):

  <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.15.2</version> <!-- 使用最新版本 -->
  </dependency>

  然后使用 ObjectMapper：

  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.databind.ObjectMapper;
  // 定义一个 Java 类（POJO）
  class Person {
      private String name;
      private int age;
      private boolean isStudent;
      private String[] courses;
      private Address address;
      // getters, setters, 构造函数 省略...
      // 为了 Jackson 能正确序列化，需要无参构造函数和 getters/setters
  }
  class Address {
      private String street;
      private String city;
      // getters, setters, 构造函数 省略...
  }
  public class JsonExample {
      public static void main(String[] args) {
          ObjectMapper objectMapper = new ObjectMapper();
          Person person = new Person();
          person.setName("赵六");
          person.setAge(35);
          person.setStudent(false);
          person.setCourses(new String[]{"历史", "地理"});
          Address address = new Address();
          address.setStreet("解放路789号");
          address.setCity("广州");
          person.setAddress(address);
          try {
              // 将对象转换为 JSON 字符串
              String jsonString = objectMapper.writeValueAsString(person);
              System.out.println(jsonString);
              // 输出: {"name":"赵六","age":35,"isStudent":false,"courses":["历史","地理"],"address":{"street":"解放路789号","city":"广州"}}
              // 美化输出
              String prettyJsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(person);
              System.out.println(prettyJsonString);