objectMapper、ObjectNode、JsonNode调用接口时进行参数组装
objectMapper、ObjectNode、JsonNode用于调用接口时进行参数组装···
public String sendText( List< String > listUser, String content ) throws JsonProcessingException
{
if ( listUser.size() <= 0 )
{
return "用户ID为空！";
}
if ( content.length() <= 0 )
{
return "发送内容为空！";
}
final String url = WeComConstans.WE_COM_HOST + WeComConstans.WE_COM_SEND_TEXT;
final ObjectMapper objectMapper = new ObjectMapper();
final ObjectNode objectNode = objectMapper.createObjectNode();
//参数组装
JsonNode toUserJson = objectMapper.valueToTree( listUser );
objectNode.set( "toUser", toUserJson );
objectNode.put( "content", content );
//调用接口
final String resultString = WeComUtil.doPost( url, objectNode.toString() );
log.info( "############################# Parameter: " + objectNode );
log.info( "############################# Call: " + url + "返回结果:\n" + resultString );
final JsonNode jsonNode1 = objectMapper.readTree( resultString );
if ( jsonNode1.path( "code" ).asInt() == 200 )
{
System.out.println( "信息发送成功！" );
}
else
{
System.out.println( "信息发送失败！" );
}
return resultString;
}运行结果：
{"toUser":["s1825","s1824"],"content":"测试信息，请忽略！"}
-----------------------------------------------------------------
更加复杂的组装：
final Map< String, JsonNode > resultMap = new HashMap< String, JsonNode >();
final ObjectMapper objectMapper = new ObjectMapper();
final ObjectNode paramJson = objectMapper.createObjectNode();
List< Object > objectList = vendorDao.getSpendDataVendorVOsByCondition( vendorVO );
List< HashMap< String, String > > suppliers = new ArrayList<>();
for ( int i = 0; i < objectList.size(); i++ )
{
HashMap< String, String > map = new HashMap<>();
map.put( "third_id", tempVendorVO.getVendorId() );
suppliers.add( map );
// 组装请求参数
JsonNode jsonNode = objectMapper.valueToTree( suppliers );
paramJson.set( "suppliers", jsonNode );
if ( suppliers.size() >= 10 )
{
String result = HttpClientUtil.doPostJsonToken( SpendConstans.HOST_URL + SpendConstans.INT_ADD_PYMENT_CUSTOM_SUPPLIER_DELETE, paramJson.toString(), getToken() );
// 把集合清空
suppliers.clear();
explainCustomResult( result, resultMap );
}
}
if ( suppliers.size() > 0 )
{
String result = HttpClientUtil.doPostJsonToken( SpendConstans.HOST_URL + SpendConstans.INT_ADD_PYMENT_CUSTOM_SUPPLIER_DELETE, paramJson.toString(), getToken() );
explainCustomResult( result, resultMap );
}ObjectMapper
ObjectMapper 是 Jackson 库中的一个核心类，用于将 Java 对象序列化为 JSON 格式或将 JSON 数据反序列化为 Java 对象。Jackson 是一个流行的 Java JSON 处理库，广泛用于处理 JSON 数据。
以下是 ObjectMapper 的一些基本用法：
-
创建 ObjectMapper 实例：
javaCopy code ObjectMapper objectMapper = new ObjectMapper();
-
将 Java 对象序列化为 JSON：
// Java 对象
MyObject myObject = new MyObject("John", 25);
// 序列化为 JSON 字符串String jsonString = objectMapper.writeValueAsString(myObject);
将 JSON 反序列化为 Java 对象：
// JSON 字符串String jsonString = "{\"name\":\"John\",\"age\":25}";
// 反序列化为 Java 对象MyObject myObject = objectMapper.readValue(jsonString, MyObject.class);-
高级用法和配置：
ObjectMapper 支持许多配置选项，例如设置日期格式、忽略空值、自定义序列化器和反序列化器等。以下是一些示例：
// 设置日期格式 objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));
// 忽略空值 objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// 自定义序列化器和反序列化器SimpleModule module = new SimpleModule();
module.addSerializer(MyObject.class, new MyObjectSerializer());
module.addDeserializer(MyObject.class, new MyObjectDeserializer());
objectMapper.registerModule(module);-
处理复杂类型：
// 序列化 List<MyObject> 为 JSON 数组
List<MyObject> myList = Arrays.asList(new MyObject("John", 25), new MyObject("Alice", 30));
String jsonArray = objectMapper.writeValueAsString(myList);
// 反序列化 JSON 数组为
List<MyObject> List<MyObject> deserializedList = objectMapper.readValue(jsonArray, new TypeReference<List<MyObject>>(){});ObjectMapper 提供了强大的功能，适用于各种 JSON 处理场景。
ObjectNode
ObjectNode 是 Jackson 库中的一个类，属于 Jackson 提供的树模型（Tree Model）。树模型允许你以树的形式操作 JSON 数据，而不是直接映射到 Java 对象。ObjectNode 代表 JSON 对象，它是 JsonNode 的一个具体实现。
以下是 ObjectNode 的基本用法：
1. 创建 ObjectNode 实例：
ObjectMapper objectMapper = new ObjectMapper();
ObjectNode objectNode =objectMapper.createObjectNode();
2. 添加属性到 ObjectNode：
objectNode.put("name", "John");
objectNode.put("age", 25);
3. 添加子对象到 ObjectNode：
ObjectNode addressNode = objectMapper.createObjectNode(); addressNode.put("city", "New York");
addressNode.put("zipcode", "10001");
objectNode.set("address", addressNode);
4. 获取属性值：
String name = objectNode.get("name").asText();
int age = objectNode.get("age").asInt();5. 遍历 ObjectNode 的属性：
Iterator<Map.Entry<String, JsonNode>> fields = objectNode.fields();
while(fields.hasNext()) { Map.Entry<String, JsonNode> entry = fields.next();
String fieldName= entry.getKey();
JsonNode fieldValue = entry.getValue(); // 处理属性值 }6. 将 ObjectNode 转换为 JSON 字符串：
String jsonString = objectNode.toString();
7. 从 JSON 字符串解析为 ObjectNode：
String json = "{\"name\":\"John\",\"age\":25}";
ObjectNode parsedObjectNode =objectMapper.readValue(json, ObjectNode.class);
ObjectNode 提供了一种方便的方式来处理和操作 JSON 数据，特别适用于需要在运行时动态构建或操作 JSON 结构的场景。然而，如果你的 JSON 结构固定，并且可以映射到一个已知的 Java 类型，那么使用对象映射（Object Mapping）可能更为直观和方便。
JsonNode
JsonNode 是 Jackson 库中的一个抽象类，代表了 JSON 中的节点。JsonNode 是 Jackson 树模型的基础，它提供了一种在 Java 中以树的形式表示 JSON 结构的方式。JsonNode 的具体实现包括 ObjectNode、ArrayNode、TextNode 等。
以下是一些基本的用法：
1. 创建 JsonNode 实例：
ObjectMapper objectMapper = new ObjectMapper(); JsonNode jsonNode =objectMapper.readTree("{\"name\":\"John\",\"age\":25}");
2. 获取属性值：
String name = jsonNode.get("name").asText(); int age = jsonNode.get("age").asInt();
3. 处理数组节点：
JsonNode arrayNode = objectMapper.readTree("[1, 2, 3, 4, 5]"); // 遍历数组 for (JsonNode element : arrayNode) { int value = element.asInt(); // 处理数组元素 }
4. 处理对象节点：
JsonNode objectNode = objectMapper.readTree("{\"name\":\"John\",\"age\":25}"); // 遍历对象的属性 Iterator<Map.Entry<String, JsonNode>> fields = objectNode.fields(); while(fields.hasNext()) { Map.Entry<String, JsonNode> entry = fields.next(); String fieldName= entry.getKey(); JsonNode fieldValue = entry.getValue(); // 处理属性值 }
5. 判断节点类型：
if (jsonNode.isObject()) { // 处理对象节点 } else if (jsonNode.isArray()) { // 处理数组节点 } else if (jsonNode.isTextual()) { // 处理文本节点 } else { // 其他类型处理 }
6. 转换为字符串：
String jsonString = jsonNode.toString();
JsonNode 提供了一种灵活的方式来处理和操作 JSON 数据，尤其适用于需要在运行时动态处理或导航 JSON 结构的场景。但要注意，相比于对象映射（Object Mapping），树模型的操作可能相对繁琐，而且需要更多的手动处理。选择使用 JsonNode 还是对象映射取决于具体的使用场景和需求。