接上篇, 我们获取了JSON数据怎么解析, 如果将来我们想发送JSON字符串怎么操作?
原来我们可以使用arduinoJson库完成这些工作


以我们上一篇收到的JSON为例
{
  "results": [
    {
      "location": {
        "id": "WW7MBNP039PE",
        "name": "泰安",
        "country": "CN",
        "path": "泰安,泰安,山东,中国",
        "timezone": "Asia/Shanghai",
        "timezone_offset": "+08:00"
      },
      "now": { "text": "晴", "code": "0", "temperature": "28" },
      "last_update": "2020-09-09T10:09:00+08:00"
    }
  ]
}

我们该如何解析这个JSON呢?其实解析过程很简单, 而且只用了强大的ArduinoJson库的一小部分功能
具体操作请参考本文第八节

下面是 ArduinoJSON库的核心内容:

一.V6版本函数库结构

可以看出，方法主要分为四大类：
JsonDocument相关，这是整个json库的入口，它负责高效管理内存以及调用json解析器；
JsonObject相关；
JsonArray相关；
解析、构造相关；
在此先介绍一个概念: JsonVariant —— json变体（存储可以放在json文件中的任意类型数据，包括int，float，数组，对象，可以认为它是一个抽象的对象概念，或者一个由JSON限定的var 或者dynamic ，理解即可）

二. 最重要的JsonDocument

JsonDocument作为整个V6版本ArduinoJson库的内存入口，负责处理整个json数据的内存管理，这是我们需要首先重点关注的内容。
1.两个实现类：
(1). DynamicJsonDocument
DynamicJsonDocument，内存分配在heap区，无固定大小，可以自动增长所需空间，方法调用完自动回收，建议内存大小大于1KB使用；
DynamicJsonDocument doc(2048); //创建一个DynamicJsonDocument类型的doc对象,大小2048byte
(2). StaticJsonDocument
StaticJsonDocument，内存分配在stack区，有固定大小，大小值由开发者定义，方法调用完自动回收，建议内存大小小于1KB使用；
StaticJsonDocument<256> doc;

2. 使用JsonDocument

创建一个JsonDocument之后，默认初始化为空，调用 JsonDocument::isNull()会返回true，这个时候既可以代表当做jsonObject，也可以当做jsonArray，这取决于你插入第一个value的类型。

例1: doc 作为JsonObject使用
DynamicJsonDocument doc(1024);
doc["answer"] = 42;
// the doc contains {"answer":42}

例2: doc 作为JsonArray使用

DynamicJsonDocument doc(1024);
doc.add(42);
// the doc contains [42]

3. as —— 获取顶节点，并把它转成T类型

DynamicJsonBuffer doc(1024);
deserializeJson(doc, "{\"key\":\"value\")");
 
// get the JsonObject in the JsonDocument
JsonObject root = doc.as<JsonObject>();
 
// get the value in the JsonObject
const char* value = root["key"];
此方法不会改变 JsonDocument的内容（JsonDocument::to()会改变）
此方法只会返回JsonDocument顶节点的引用。如果顶节点的类型和强转的T类型不匹配，此方法将会返回空引用

4. to —— jsondocument转成T类型

函数说明：
/**
 * jsondocument转成T类型,T为JsonArray、JsonObject、JsonVariant
 */
JsonArray   to<JsonArray>();
JsonObject  to<JsonObject>();
JsonVariant to<JsonVariant>();
此方法是释放jsondocument的内存空间，也就是说之前已经分配的引用无效，参考代码：

DynamicJsonBuffer doc(1024);
JsonObject root1 = doc.to<JsonObject>();
JsonObject root2 = doc.to<JsonObject>();
// Don't use root1 here, because it's dangling!

5. clear —— 清除JsonDocument并释放内存空间

清除JsonDocument并释放内存空间
doc.clear();

6. isNull —— 判断jsondocument是否为空

/**
 * 判断jsondocument是否为空
 */
bool isNull() const;

7. memoryUsage —— jsondocument已使用内存字节数

函数说明：
/**
 * jsondocument已使用内存字节数
 */
size_t memoryUsage() const;

8. remove —— 移除特定key和value

results.remove(0);
  root.remove("results");

三. 解析构造相关

1.deserializeJson —— 解析json

/**
 * 解析json
 * @param doc jsondocument对象
 * @param input 输入内容
 * @return DeserializationError 解析结果
 */
// writable input => zero-copy
DeserializationError deserializeJson(JsonDocument& doc, char* input);
DeserializationError deserializeJson(JsonDocument& doc, char* input, size_t inputSize);
 
// read-only input => duplication
DeserializationError deserializeJson(JsonDocument& doc, const char* input);
DeserializationError deserializeJson(JsonDocument& doc, const char* input, size_t inputSize);
DeserializationError deserializeJson(JsonDocument& doc, const __FlashStringHelper* input);
DeserializationError deserializeJson(JsonDocument& doc, const __FlashStringHelper* input, size_t inputSize);
DeserializationError deserializeJson(JsonDocument& doc, const String& input);
DeserializationError deserializeJson(JsonDocument& doc, const std::string& input);
DeserializationError deserializeJson(JsonDocument& doc, Stream& input);
DeserializationError deserializeJson(JsonDocument& doc, std::istream& input);

例子:
const char* json = "{\"hello\":\"world\"}";
StaticJsonDocument<200> doc;
deserializeJson(doc, json);
const char* world = doc["hello"];

2. serializeJson —— 构造序列化json (串口打印json)

StaticJsonDocument<200> doc;
doc["hello"] = "world";
serializeJson(doc, Serial);

3. serializeJsonPretty —— 构造序列化json，格式化输出 (串口美化打印json)

/**
 * 构造序列化json，格式化输出
 * @param doc jsondocument对象
 * @param output 输出内容
 */
size_t serializeJsonPretty(const JsonDocument& doc, char* output, size_t outputSize);
size_t serializeJsonPretty(const JsonDocument& doc, char output[size]);
size_t serializeJsonPretty(const JsonDocument& doc, Print& output);
size_t serializeJsonPretty(const JsonDocument& doc, String& output);
size_t serializeJsonPretty(const JsonDocument& doc, std::string& output);

4. measureJson —— 计算构造序列化json的长度

/**
 * 计算构造序列化格式化json的长度
 * @param doc jsondocument对象
 * @Note 关联方法  serializeJsonPretty
 */
size_t measureJsonPretty(const JsonDocument& doc);
经测试: 本例中的json长度 263

5. measureJsonPretty —— 计算构造序列化格式化json的长度
/**
 * 计算构造序列化格式化json的长度
 * @param doc jsondocument对象
 * @Note 关联方法  serializeJsonPretty
 */
size_t measureJsonPretty(const JsonDocument& doc);
经测试: 美化后的长度: 428

四. JsonObject相关函数

在JsonDocument所构造出来的内存空间中，Json对象的入口就是JsonObject。
1. containsKey —— 判断对象是否包含某一个key
bool hasCity = root.containsKey("city"); // true

2. createNestedArray —— 在当前对象中添加子key，子value为json数组

StaticJsonDocument<256> doc;
JsonObject root = doc.to<JsonObject>();
root["status"] = "on";
JsonArray levels = root.createNestedArray("levels");
levels.add(10);
levels.add(30);
serializeJsonPretty(root, Serial);
结果:
{
  "status": "on",
  "levels": [
    10,
    20
  ]
}

3. createNestedObject —— 在当前对象中添加子key，子value为json对象

StaticJsonDocument<256> doc;
JsonObject root = doc.to<JsonObject>();
root["city"] = "Paris";
JsonObject weather = root.createNestedObject("weather");
weather["temp"] = 14.2;
weather["cond"] = "cloudy";
serializeJsonPretty(root, Serial);

4. getMember —— 获取key对应的value (仅限JsonObject类型)

/**
 * 获取key对应的value
 * @param key 对应的key
 * @param JsonVariant key对应的value，如果不匹配返回null
 */
JsonVariant getMember(const char* key);
JsonVariant getMember(String key);
JsonVariant getMember(std::string key);
JsonVariant getMember(const __FlashStringHelper* key);

5. getOrCreateMember —— 获取或者创建key对应的value(仅限JsonObject类型)

/**
 * 获取或者创建key对应的value
 * @param key 对应的key
 * @param JsonVariant key对应的value，如果不匹配返回null
 */
JsonVariant getOrCreateMember(const char* key);
JsonVariant getOrCreateMember(String key);
JsonVariant getOrCreateMember(std::string key);
JsonVariant getOrCreateMember(const __FlashStringHelper* key);
如果JsonDocument包含一个对象，那么getOrCreateMember方法会获取指定key的值，如果对象不存在该key，这个方法会往对象添加一个新的key-value键值对；
如果JsonDocument是空，那么getOrCreateMember方法将创建一个对象给到JsonDocument；
如果属于以上两种情况之外的，此方法无效；

五. JsonArray相关函数

1. add —— 往JsonArray中添加元素 (仅限JsonArray类型)
StaticJsonDocument<200> doc;
array.add("hello"); // null -> ["hello"]
array.add(3.14156); // ["hello"] -> ["hello",3.14156]
serializeJson(doc, Serial);
如果JsonDocument顶节点是一个JsonArray，add方法会追加一个value到数组；
如果JsonDocument顶节点是一个JsonObject，add无效；
如果JsonDocument是一个空对象，add方法会把JsonDocument变成一个包含一个元素的数组，这是一个创建数组的方式；

2. createNestedArray —— 添加json数组

StaticJsonDocument<200> doc;
JsonArray array = doc.to<JsonArray>();
array.add("hello");
JsonArray nested = array.createNestedArray();
nested.add("world");
serializeJson(array, Serial);
结果
["hello",["world"]]

3. createNestedObject —— 添加json对象

StaticJsonDocument<200> doc;
JsonArray array = doc.to<JsonArray>();
JsonObject nested = array.createNestedObject();
nested["hello"] = "world";
serializeJson(array, Serial);
结果
[{"hello":"world"}]

4. getElement —— 获取index位置的元素(仅限JsonArray类型)

/**
 * 获取index位置/key的元素
 * @param index 索引位置
 * @return JsonVariant 如果找不到匹配的返回null
 */
JsonVariant getElement(size_t index);

5. getOrAddElement —— 获取或者创建index对应的value(仅限JsonArray类型)

同上

六. 关于操作符

对象都可以用经典的get/set方式操作,也可以用函数操作

//get   以下两行代码效果等同
JsonVariant value = object["key"];
JsonVariant value = object.getMember("key");
 
//set  以下两行代码效果等同
object["key"] = "value";
object.getOrCreateMember("key").set("value");
 
StaticJsonDocument<256> doc;
JsonObject object = doc.to<JsonObject>();
object["hello"] = "world";
const char* world = object["hello"];

七. 编码JSON字符串示例:

#include <ArduinoJson.h>
 
void setup() {
  Serial.begin(115200);
  // 200 是大小 如果这个Json对象更加复杂，那么就需要根据需要去增加这个值.
  StaticJsonDocument<200> doc;
 
  // StaticJsonDocument 在栈区分配内存   它也可以被 DynamicJsonDocument（内存在堆区分配） 代替
  // DynamicJsonDocument  doc(200);
 
  //添加键值对
  doc["sensor"] = "gps";
  doc["time"] = 1351824120;
 
  // 添加数组.
  JsonArray data = doc.createNestedArray("data");
  data.add(48.756080);
  data.add(2.302038);
 
//串口打印结果
  serializeJson(doc, Serial);
}
 
void loop() {
}

八. 解码Json字符串示例:

#include <Arduino.h>
#include "ArduinoJson.h"
 
String jsonStr = "{\"results\":[{\"location\":{\"id\":\"WW7MBNP039PE\",\"name\":\"泰安\",\"country\":\"CN\",\"path\":\"泰安,泰安,山东,中国\",\"timezone\":\"Asia/Shanghai\",\"timezone_offset\":\"+08:00\"},\"now\":{\"text\":\"晴\",\"code\":\"0\",\"temperature\":\"28\"},\"last_update\":\"2020-09-09T10:09:00+08:00\"}]}";
DynamicJsonDocument doc(512);
 
void setup()
{
  Serial.begin(115200);
  delay(3000);
}
void loop()
{
  //解析JSON字符串
  Serial.println("从jsonStr解码成的DynamicJsonDocument对象doc:");
  deserializeJson(doc, jsonStr);
  serializeJson(doc, Serial);
  Serial.println("从doc对象转换成的JsonObject类型对象root:");
  JsonObject root = doc.as<JsonObject>();
  serializeJson(root, Serial);
  Serial.println();
  Serial.println(doc.memoryUsage());
  Serial.println(measureJson(doc));
  Serial.println(measureJsonPretty(doc));
  Serial.println("root里有一个子JsonArray对象 results:");
  JsonArray results = root["results"];
  serializeJson(results, Serial);
  Serial.println();
  //JsonArray类型的数组results里面只有一个元素: JsonObject对象results[0],
  //该元素有三个子对象 location, now, last_update
  //location
  Serial.println("JsonObject对象 results[0]中的子JsonObject对象location:");
  JsonObject location = results[0]["location"];
  serializeJson(location, Serial);
  Serial.println();
  Serial.println("从JsonObject对象location中取出id");
  const char *id = location["id"];
  Serial.println(id);
  Serial.println("从JsonObject对象location中取出name");
  const char *name = location["name"];
  Serial.println(name);
  Serial.println("从JsonObject对象location中取出country");
  const char *country = location["country"];
  Serial.println(country);
  Serial.println("从JsonObject对象location中取出path");
  const char *path = location["path"];
  Serial.println(path);
  Serial.println("从JsonObject对象location中取出timezone");
  const char *timezone = location["timezone"];
  Serial.println(timezone);
  Serial.println("从JsonObject对象location中取出timezone_offset");
  const char *timezone_offset = location["timezone_offset"];
  Serial.println(timezone_offset);
  //now
  Serial.println("JsonObject对象 results[0]中的子JsonObject对象now(为了避免和timer中的now重名,把它叫做now1):");
  JsonObject now1 = results[0]["now"];
  serializeJson(now1, Serial);
  Serial.println("从JsonObject对象now1中取出text");
  const char *text = now1["text"];
  Serial.println(text);
  Serial.println("从JsonObject对象now1中取出code");
  const char *code = now1["code"];
  Serial.println(code);
  Serial.println("从JsonObject对象now1中取出temperature");
  const char *temperature = now1["temperature"];
  Serial.println(temperature);
  //last_update
  const char *last_update = results[0].getMember("last_update");
  Serial.println("last_update:");
  Serial.println(last_update);
  Serial.println();
  delay(10000);
}

————————————————
链接：https://blog.csdn.net/finedayforu/article/details/108547040