ruoyi的spring cloud项目详解（六）_若依 dynamic-datasource-CSDN博客
我们接着看
com/ruoyi/common/json/JSON.java
package com.ruoyi.common.json;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
/**
* JSON解析处理
*
* @author ruoyi
*/
public class JSON
{
public static final String DEFAULT_FAIL = "\"Parse failed\"";
private static final ObjectMapper objectMapper = new ObjectMapper();
private static final ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
public static void marshal(File file, Object value) throws Exception
{
try
{
objectWriter.writeValue(file, value);
}
catch (JsonGenerationException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
public static void marshal(OutputStream os, Object value) throws Exception
{
try
{
objectWriter.writeValue(os, value);
}
catch (JsonGenerationException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
public static String marshal(Object value) throws Exception
{
try
{
return objectWriter.writeValueAsString(value);
}
catch (JsonGenerationException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
public static byte[] marshalBytes(Object value) throws Exception
{
try
{
return objectWriter.writeValueAsBytes(value);
}
catch (JsonGenerationException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
public static <T> T unmarshal(File file, Class<T> valueType) throws Exception
{
try
{
return objectMapper.readValue(file, valueType);
}
catch (JsonParseException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
public static <T> T unmarshal(InputStream is, Class<T> valueType) throws Exception
{
try
{
return objectMapper.readValue(is, valueType);
}
catch (JsonParseException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
public static <T> T unmarshal(String str, Class<T> valueType) throws Exception
{
try
{
return objectMapper.readValue(str, valueType);
}
catch (JsonParseException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
public static <T> T unmarshal(byte[] bytes, Class<T> valueType) throws Exception
{
try
{
if (bytes == null)
{
bytes = new byte[0];
}
return objectMapper.readValue(bytes, 0, bytes.length, valueType);
}
catch (JsonParseException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}
}
以下是对这段 Java 代码的分析：
**一、代码功能**
这段代码定义了一个名为`JSON`的工具类，用于处理 JSON 数据的序列化和反序列化操作。它基于 Jackson 库提供了将 Java 对象转换为 JSON 字符串（以及字节数组、写入文件或输出流）和从 JSON 字符串（以及字节数组、输入流、文件）反序列化为 Java 对象的方法。
**二、主要方法**
1. `marshal(File file, Object value)`：将一个 Java 对象写入指定的文件中，以 JSON 格式存储。如果在写入过程中发生错误，会抛出异常。
2. `marshal(OutputStream os, Object value)`：将一个 Java 对象写入指定的输出流中，以 JSON 格式存储。同样，如果发生错误会抛出异常。
3. `marshal(Object value)`：将一个 Java 对象转换为 JSON 字符串。如果转换过程中出现问题，会抛出异常。
4. `marshalBytes(Object value)`：将一个 Java 对象转换为 JSON 格式的字节数组。如果转换失败会抛出异常。
5. `unmarshal(File file, Class<T> valueType)`：从指定的文件中读取 JSON 数据，并将其反序列化为指定类型的 Java 对象。如果解析过程中出现错误，会抛出异常。
6. `unmarshal(InputStream is, Class<T> valueType)`：从输入流中读取 JSON 数据并反序列化为指定类型的 Java 对象。
7. `unmarshal(String str, Class<T> valueType)`：从 JSON 字符串中反序列化为指定类型的 Java 对象。
8. `unmarshal(byte[] bytes, Class<T> valueType)`：从字节数组中反序列化为指定类型的 Java 对象。如果字节数组为`null`，会创建一个长度为 0 的字节数组进行处理。
**三、使用 Jackson 的好处**
Jackson 是一个流行的 Java 库，用于处理 JSON 数据。它具有以下优点：
- 高性能：能够快速地进行 JSON 的序列化和反序列化操作。
- 灵活性：支持多种数据类型的转换，并且可以通过配置进行定制化。
- 易于使用：提供了简洁的 API，使得开发者可以方便地进行 JSON 数据处理。
**四、代码的应用场景**
在 Java 应用程序中，当需要进行以下操作时可以使用这个工具类：
- 将 Java 对象存储为 JSON 文件，或者从 JSON 文件中读取数据并转换为 Java 对象。
- 在网络通信中，将 Java 对象序列化为 JSON 字符串并通过输出流发送，或者从输入流中接收 JSON 数据并反序列化为 Java 对象。
- 在数据存储和读取场景中，如将数据存储为 JSON 格式的文件或从文件中读取 JSON 数据并转换为 Java 对象进行处理。
一下我们分开解析
public static final String DEFAULT_FAIL = "\"Parse failed\"";
private static final ObjectMapper objectMapper = new ObjectMapper();
private static final ObjectWriter objectWriter =
objectMapper.writerWithDefaultPrettyPrinter(); public static final String DEFAULT_FAIL = "\"Parse failed\"";
定义了一个公共静态常量DEFAULT_FAIL，其值为字符串"Parse failed"。这个常量通常在解析出现错误时作为默认的错误消息返回，提供了一种统一的方式来表示解析失败的情况。
private static final ObjectMapper objectMapper = new ObjectMapper();
创建了一个私有的静态最终变量objectMapper，类型为ObjectMapper。ObjectMapper是 Jackson 库中的核心类，用于将 Java 对象序列化为 JSON 字符串以及将 JSON 字符串反序列化为 Java 对象。
通过创建这个对象，可以在整个类中复用它来进行 JSON 数据的处理，避免重复创建ObjectMapper实例，提高性能。
private static final ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
使用前面创建的objectMapper创建了一个ObjectWriter实例objectWriter。ObjectWriter是用于将 Java 对象转换为 JSON 字符串的工具类。
writerWithDefaultPrettyPrinter()方法为ObjectWriter配置了默认的漂亮打印（缩进和格式化）功能，使得生成的 JSON 字符串更具可读性。这个ObjectWriter也可以在整个类中被复用，方便地将 Java 对象转换为格式化的 JSON 字符串。
public static void marshal(File file, Object value) throws Exception
{
try
{
objectWriter.writeValue(file, value);
}
catch (JsonGenerationException e)
{
throw new Exception(e);
}
catch (JsonMappingException e)
{
throw new Exception(e);
}
catch (IOException e)
{
throw new Exception(e);
}
}**一、方法功能**
这个名为`marshal`的静态方法用于将一个 Java 对象序列化为 JSON 格式并写入到一个文件中。
**二、实现步骤**
1. `objectWriter.writeValue(file, value)`：
- 使用之前创建的`ObjectWriter`实例尝试将传入的`value`（Java 对象）写入到指定的`file`（文件）中。`ObjectWriter`会将 Java 对象转换为 JSON 格式的字符串，并将其写入文件。
2. `catch`块处理异常：
- 如果在序列化过程中出现以下异常，会将这些异常包装为一个新的`Exception`并重新抛出：
- `JsonGenerationException`：在生成 JSON 内容时发生错误，例如无法将特定的 Java 对象转换为 JSON。
- `JsonMappingException`：在将 Java 对象映射到 JSON 结构时出现问题。
- `IOException`：在写入文件过程中发生的输入/输出错误。
**三、使用场景**
在需要将 Java 对象持久化到文件中以 JSON 格式存储时，可以调用这个方法。例如，在数据备份、配置文件生成或者需要将应用程序中的数据保存到文件以便后续读取和处理的场景中非常有用。
需要注意的是，由于这个方法会抛出`Exception`，调用者需要在适当的地方处理这些异常，以确保程序的稳定性和可靠性。
com/ruoyi/common/json/JSONObject.java
package com.ruoyi.common.json;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.common.utils.StringUtils;
/**
* 通用消息对象，基于Map实现的可嵌套数据结构。 支持JSON数据结构。
*
* @author ruoyi
*/
public class JSONObject extends LinkedHashMap<String, Object>
{
private static final long serialVersionUID = 1L;
private static final Pattern arrayNamePattern = Pattern.compile("(\\w+)((\\[\\d+\\])+)");
private static final ObjectMapper objectMapper = new ObjectMapper();
/**
* 数组结构。
*/
public static class JSONArray extends ArrayList<Object>
{
private static final long serialVersionUID = 1L;
public JSONArray()
{
super();
}
public JSONArray(int size)
{
super(size);
}
@Override
public String toString()
{
try
{
return JSON.marshal(this);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
@Override
public Object set(int index, Object element)
{
return super.set(index, transfer(element));
}
@Override
public boolean add(Object element)
{
return super.add(transfer(element));
}
@Override
public void add(int index, Object element)
{
super.add(index, transfer(element));
}
}
public JSONObject()
{
super();
}
public JSONObject(final JSONObject other)
{
super(other);
}
@Override
public String toString()
{
try
{
return JSON.marshal(this);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
/**
* 转换为紧凑格式的字符串。
*
* @return 返回本对象紧凑格式字符串。
*/
public String toCompactString()
{
try
{
return objectMapper.writeValueAsString(this);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
/**
* 获取指定字段的整数值。如果字段不存在，或者无法转换为整数，返回null。
*
* @param name 字段名，支持多级。
* @return 返回指定的整数值，或者null。
*/
public Integer intValue(final String name)
{
return valueAsInt(value(name));
}
/**
* 获取指定字段的整数值。如果字段不存在，或者无法转换为整数，返回defaultValue。
*
* @param name 字段名，支持多级。
* @param defaultValue 查询失败时，返回的值。
* @return 返回指定的整数值，或者defaultValue。
*/
public Integer intValue(final String name, final Integer defaultValue)
{
return StringUtils.nvl(intValue(name), defaultValue);
}
/**
* 获取指定字段的长整数值。如果字段不存在，或者无法转换为长整数，返回null。
*
* @param name 字段名，支持多级。
* @return 返回指定的长整数值，或者null。
*/
public Long longValue(final String name)
{
return valueAsLong(value(name));
}
/**
* 获取指定字段的长整数值。如果字段不存在，或者无法转换为长整数，返回defaultValue。
*
* @param name 字段名，支持多级。
* @param defaultValue 查询失败时，返回的值。
* @return 返回指定的长整数值，或者defaultValue。
*/
public Long longValue(final String name, final Long defaultValue)
{
return StringUtils.nvl(longValue(name), defaultValue);
}
/**
* 获取指定字段的布尔值。如果字段不存在，或者无法转换为布尔型，返回null。
*
* @param name 字段名，支持多级。
* @return 返回指定的布尔值，或者null。
*/
public Boolean boolValue(final String name)
{
return valueAsBool(value(name));
}
/**
* 获取指定字段的布尔值。如果字段不存在，或者无法转换为布尔型，返回defaultValue。
*
* @param name 字段名，支持多级。
* @param defaultValue 查询失败时，返回的值。
* @return 返回指定的布尔值，或者defaultValue。
*/
public Boolean boolValue(final String name, final Boolean defaultValue)
{
return StringUtils.nvl(boolValue(name), defaultValue);
}
/**
* 获取指定字段的字符串值。如果字段不存在，返回null。
*
* @param name 字段名，支持多级。
* @return 返回指定的字符串值，或者null。
*/
public String strValue(final String name)
{
return valueAsStr(value(name));
}
/**
* 获取指定字段的字符串值。如果字段不存在，返回defaultValue。
*
* @param name 字段名，支持多级。
* @param defaultValue 查询失败时，返回的值。
* @return 返回指定的字符串值，或者defaultValue。
*/
public String strValue(final String name, final String defaultValue)
{
return StringUtils.nvl(strValue(name), defaultValue);
}
/**
* 获取指定字段的值。
*
* @param name 字段名，支持多级，支持数组下标。
* @return 返回指定字段的值。
*/
public Object value(final String name)
{
final int indexDot = name.indexOf('.');
if (indexDot >= 0)
{
return obj(name.substring(0, indexDot)).value(name.substring(indexDot + 1));
}
else
{
final Matcher matcher = arrayNamePattern.matcher(name);
if (matcher.find())
{
return endArray(matcher.group(1), matcher.group(2), new EndArrayCallback<Object>()
{
@Override
public Object callback(JSONArray arr, int index)
{
return elementAt(arr, index);
}
});
}
else
{
return get(name);
}
}
}
/**
* 设置指定字段的值。
*
* @param name 字段名，支持多级，支持数组下标。
* @param value 字段值。
* @return 返回本对象。
*/
public JSONObject value(final String name, final Object value)
{
final int indexDot = name.indexOf('.');
if (indexDot >= 0)
{
obj(name.substring(0, indexDot)).value(name.substring(indexDot + 1), value);
}
else
{
final Matcher matcher = arrayNamePattern.matcher(name);
if (matcher.find())
{
endArray(matcher.group(1), matcher.group(2), new EndArrayCallback<Void>()
{
@Override
public Void callback(JSONArray arr, int index)
{
elementAt(arr, index, value);
return null;
}
});
}
else
{
set(name, value);
}
}
return this;
}
/**
* 获取对象（非标量类型）字段。返回的数据是一个结构体。当不存在指定对象时，则为指定的名字创建一个空的MessageObject对象。
*
* @param name 字段名。不支持多级名字，支持数组下标。
* @return 返回指定的对象。如果对象不存在，则为指定的名字创建一个空的MessageObject对象。
*/
public JSONObject obj(final String name)
{
final Matcher matcher = arrayNamePattern.matcher(name);
if (matcher.find())
{
return endArray(matcher.group(1), matcher.group(2), new EndArrayCallback<JSONObject>()
{
@Override
public JSONObject callback(JSONArray arr, int index)
{
return objAt(arr, index);
}
});
}
else
{
JSONObject obj = getObj(name);
if (obj == null)
{
obj = new JSONObject();
put(name, obj);
}
return obj;
}
}
/**
* 获取数组字段。将名字对应的对象以数组对象返回，当指定的字段不存在时，创建一个空的数组。
*
* @param name 字段名。不支持多级名字，不支持下标。
* @return 返回一个数组（List）。
*/
public JSONArray arr(final String name)
{
JSONArray arr = getArr(name);
if (arr == null)
{
arr = new JSONArray();
put(name, arr);
}
return arr;
}
/**
* 获取对象（非标量类型）字段。返回的数据是一个结构体。
*
* @param name 字段名。
* @return 返回指定的对象字段。
*/
public JSONObject getObj(final String name)
{
return (JSONObject) get(name);
}
/**
* 获取数组类型字段。
*
* @param name 字段名。
* @return 返回数组类型字段。
*/
public JSONArray getArr(final String name)
{
return (JSONArray) get(name);
}
/**
* 返回字段整数值。如果不存在，返回null。
*
* @param name 字段名。
* @return 返回指定字段整数值。
*/
public Integer getInt(final String name)
{
return valueAsInt(get(name));
}
/**
* 返回字段整数值。如果不存在，返回defaultValue。
*
* @param name 字段名。
* @param defaultValue 字段不存在时，返回的值。
* @return 返回指定字段整数值。
*/
public Integer getInt(final String name, Integer defaultValue)
{
return StringUtils.nvl(getInt(name), defaultValue);
}
/**
* 返回字段长整数值。如果不存在，返回null。
*
* @param name 字段名。
* @return 返回指定字段长整数值。
*/
public Long getLong(final String name)
{
return valueAsLong(get(name));
}
/**
* 返回字段长整数值。如果不存在，返回defaultValue。
*
* @param name 字段名。
* @param defaultValue 字段不存在时，返回的值。
* @return 返回指定字段长整数值。
*/
public Long getLong(final String name, Long defaultValue)
{
return StringUtils.nvl(getLong(name), defaultValue);
}
/**
* 返回字段字符串值。如果不存在，返回null。
*
* @param name 字段名。
* @return 返回指定字段字符串值。
*/
public String getStr(final String name)
{
return valueAsStr(get(name));
}
/**
* 返回字段字符串值。如果不存在，返回defaultValue。
*
* @param name 字段名。
* @param defaultValue 字段不存在时，返回的值。
* @return 返回指定字段字符串值。
*/
public String getStr(final String name, final String defaultValue)
{
return StringUtils.nvl(getStr(name), defaultValue);
}
/**
* 字段值按照布尔类型返回。如果不存在，返回null。
*
* @param name 字段名。
* @return 字段值。
*/
public Boolean getBool(final String name)
{
return valueAsBool(get(name));
}
/**
* 字段值按照布尔类型返回。如果不存在，返回defaultValue。
*
* @param name 字段名。
* @param defaultValue 字段不存在时，返回的值。
* @return 字段值。
*/
public Boolean getBool(final String name, final Boolean defaultValue)
{
return StringUtils.nvl(getBool(name), defaultValue);
}
/**
* 设置字段值
*
* @param name 字段名
* @param value 字段值（标量：数字、字符串、布尔型；结构体：MessageObject）。 如果是Map类型同时非MessageObject类型，则自动转换为MessageObject类型再存入
* （此时，再修改Map中的数据，将不会体现到本对象中）。
* @return 返回本对象
*/
public JSONObject set(final String name, final Object value)
{
put(name, value);
return this;
}
/**
* 将本对象转换为Java Bean。
*
* @param beanClass Java Bean的类对象。
* @return 返回转换后的Java Bean。
*/
public <T> T asBean(Class<T> beanClass)
{
try
{
return JSON.unmarshal(JSON.marshal(this), beanClass);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
/**
* 重载基类的方法。如果 value 是 Map 类型，但不是 MessageObject 类型，则创建一个包含内容等同于原 Map 的 MessageObject 作为 value（注意：此后再更改 Map 的内容，将不会反映到
* MessageObject 中）。 重载此方法的目的是为了使JSON能够正确地解析为MessageObject对象。不建议直接调用此方法，请使用 set(name, value)方法设置字段值。
*/
@Override
public Object put(String key, Object value)
{
return super.put(key, transfer(value));
}
public static Integer valueAsInt(Object value)
{
if (value instanceof Integer)
{
return (Integer) value;
}
else if (value instanceof Number)
{
return ((Number) value).intValue();
}
else if (value instanceof String)
{
return Integer.valueOf((String) value);
}
else if (value instanceof Boolean)
{
return ((Boolean) value) ? 1 : 0;
}
else
{
return null;
}
}
public static Long valueAsLong(Object value)
{
if (value instanceof Long)
{
return (Long) value;
}
else if (value instanceof Number)
{
return ((Number) value).longValue();
}
else if (value instanceof String)
{
return Long.valueOf((String) value);
}
else if (value instanceof Boolean)
{
return ((Boolean) value) ? 1L : 0L;
}
else
{
return null;
}
}
public static String valueAsStr(Object value)
{
if (value instanceof String)
{
return (String) value;
}
else if (value != null)
{
return value.toString();
}
else
{
return null;
}
}
public static Boolean valueAsBool(Object value)
{
if (value instanceof Boolean)
{
return (Boolean) value;
}
else if (value instanceof Number)
{
return ((Number) value).doubleValue() != 0.0;
}
else if (value instanceof String)
{
return Boolean.valueOf((String) value);
}
else
{
return null;
}
}
/**
* 将所有层次中凡是Map类型同时又不是MessageObject的类型，转换为MessageObject类型。
*
* @param value 值。
* @return 返回转换后的值。
*/
@SuppressWarnings("unchecked")
private static Object transfer(final Object value)
{
if (!(value instanceof JSONObject) && value instanceof Map)
{
return toObj((Map<String, Object>) value);
}
else if (!(value instanceof JSONArray) && value instanceof Collection)
{
return toArr((Collection<Object>) value);
}
else
{
return value;
}
}
private static JSONArray toArr(final Collection<Object> list)
{
final JSONArray arr = new JSONArray(list.size());
for (final Object element : list)
{
arr.add(element);
}
return arr;
}
private static JSONObject toObj(final Map<String, Object> map)
{
final JSONObject obj = new JSONObject();
for (final Map.Entry<String, Object> ent : map.entrySet())
{
obj.put(ent.getKey(), transfer(ent.getValue()));
}
return obj;
}
/**
* 将指定下标元素作为数组返回，如果不存在，则在该位置创建一个空的数组。
*
* @param arr 当前数组。
* @param index 下标。
* @return 返回当前数组指定下标的元素，该元素应该是一个数组。
*/
private static JSONArray arrayAt(JSONArray arr, int index)
{
expand(arr, index);
if (arr.get(index) == null)
{
arr.set(index, new JSONArray());
}
return (JSONArray) arr.get(index);
}
/**
* 将指定下标元素作为结构体返回，如果不存在，则在该位置创建一个空的结构体。
*
* @param arr 当前数组。
* @param index 下标。
* @return 返回当前数组指定下标元素，该元素是一个结构体。
*/
private static JSONObject objAt(final JSONArray arr, int index)
{
expand(arr, index);
if (arr.get(index) == null)
{
arr.set(index, new JSONObject());
}
return (JSONObject) arr.get(index);
}
/**
* 设置数组指定下标位置的值。
*
* @param arr 数组。
* @param index 下标。
* @param value 值。
*/
private static void elementAt(final JSONArray arr, final int index, final Object value)
{
expand(arr, index).set(index, value);
}
/**
* 获取数组指定下标元素的值。
*
* @param arr 数组。
* @param index 下标。
* @return 值。
*/
private static Object elementAt(final JSONArray arr, final int index)
{
return expand(arr, index).get(index);
}
/**
* 扩展数组到指定下标，以防止访问时下标越界。
*
* @param arr 数组
* @param index 下标
* @return 返回传入的数组
*/
private static JSONArray expand(final JSONArray arr, final int index)
{
while (arr.size() <= index)
{
arr.add(null);
}
return arr;
}
/**
* 最后数组回调。
*
* @author Mike
*
* @param <T> 回调返回数据类型。
*/
private interface EndArrayCallback<T>
{
/**
* 当定位到最后一级数组，将调用本方法。
*
* @param arr 最后一级数组对象。
* @param index 最后一级索引。
* @return 返回回调的返回值。
*/
T callback(JSONArray arr, int index);
}
/**
* 处理多维数组的工具函数（包括一维数组）。多维数组的名字如：arrary[1][2][3]， 则name=array，indexStr=[1][2][3]，在callback中，endArr将是
* array[1][2]指定的对象，indexe=3。
*
* @param name 不带下标的名字，不支持多级名字。
* @param indexesStr 索引部分的字符串，如：[1][2][3]
* @param callback 回调函数。
* @return 返回回调函数的返回值。
*/
private <T> T endArray(final String name, final String indexesStr, final EndArrayCallback<T> callback)
{
JSONArray endArr = arr(name);
final int[] indexes = parseIndexes(indexesStr);
int i = 0;
while (i < indexes.length - 1)
{
endArr = arrayAt(endArr, indexes[i++]);
}
return callback.callback(endArr, indexes[i]);
}
private static int[] parseIndexes(final String s)
{
int[] indexes = null;
List<Integer> list = new ArrayList<Integer>();
final StringTokenizer st = new StringTokenizer(s, "[]");
while (st.hasMoreTokens())
{
final int index = Integer.valueOf(st.nextToken());
if (index < 0)
{
throw new RuntimeException(String.format("Illegal index %1$d in \"%2$s\"", index, s));
}
list.add(index);
}
indexes = new int[list.size()];
int i = 0;
for (Integer tmp : list.toArray(new Integer[list.size()]))
{
indexes[i++] = tmp;
}
return indexes;
}
}
以下是对这段 Java 代码的分析：
**一、代码功能**
这段代码定义了一个名为`JSONObject`的类，它继承自`LinkedHashMap<String, Object>`，用于表示一个通用的消息对象，支持 JSON 数据结构和可嵌套的数据结构。该类提供了一系列方法来方便地获取、设置和操作对象中的数据，包括支持多级字段名、数组下标访问等功能。
**二、主要方法和功能点**
1. **构造函数**：
- `JSONObject()`：创建一个空的`JSONObject`对象。
- `JSONObject(final JSONObject other)`：创建一个新的`JSONObject`对象，复制另一个`JSONObject`的内容。
2. **toString 方法**：
- `toString()`：将当前对象转换为 JSON 格式的字符串，使用`JSON.marshal(this)`方法进行序列化，如果出现异常则抛出运行时异常。
- `toCompactString()`：将当前对象转换为紧凑格式的 JSON 字符串，使用`objectMapper.writeValueAsString(this)`方法进行序列化，如果出现异常则抛出运行时异常。
3. **值获取方法**：
- `intValue(final String name)`和`intValue(final String name, final Integer defaultValue)`：获取指定字段的整数值，如果字段不存在或无法转换为整数，则返回`null`或指定的默认值。
- `longValue(final String name)`和`longValue(final String name, final Long defaultValue)`：获取指定字段的长整数值，类似整数方法的功能。
- `boolValue(final String name)`和`boolValue(final String name, final Boolean defaultValue)`：获取指定字段的布尔值。
- `strValue(final String name)`和`strValue(final String name, final String defaultValue)`：获取指定字段的字符串值。
- `value(final String name)`：获取指定字段的值，可以支持多级字段名和数组下标访问。
4. **值设置方法**：
- `value(final String name, final Object value)`：设置指定字段的值，可以支持多级字段名和数组下标访问。
5. **对象和数组获取方法**：
- `obj(final String name)`：获取指定字段的对象，如果不存在则创建一个新的空`JSONObject`对象并返回。
- `arr(final String name)`：获取指定字段的数组，如果不存在则创建一个新的空`JSONArray`对象并返回。
- `getObj(final String name)`：获取指定字段的对象，如果不存在则返回`null`。
- `getArr(final String name)`：获取指定字段的数组，如果不存在则返回`null`。
6. **其他方法**：
- `asBean(Class<T> beanClass)`：将当前对象转换为指定的 Java Bean 对象。
- `set(final String name, final Object value)`：设置指定字段的值，类似于`put`方法。
- `put(String key, Object value)`：重载了父类的`put`方法，在存入值时，如果值是`Map`类型但不是`JSONObject`类型，则将其转换为`JSONObject`类型再存入。
7. **静态辅助方法**：
- `valueAsInt(Object value)`、`valueAsLong(Object value)`、`valueAsStr(Object value)`、`valueAsBool(Object value)`：分别用于将给定的值转换为整数、长整数、字符串和布尔值，如果无法转换则返回`null`。
- `transfer(final Object value)`：将值进行转换，如果值是`Map`类型且不是`JSONObject`类型，则转换为`JSONObject`类型；如果值是`Collection`类型且不是`JSONArray`类型，则转换为`JSONArray`类型。
- `toArr(final Collection<Object> list)`：将`Collection`类型转换为`JSONArray`类型。
- `toObj(final Map<String, Object> map)`：将`Map`类型转换为`JSONObject`类型。
- `arrayAt(JSONArray arr, int index)`、`objAt(final JSONArray arr, int index)`、`elementAt(final JSONArray arr, final int index, final Object value)`、`elementAt(final JSONArray arr, final int index)`、`expand(final JSONArray arr, final int index)`：用于处理数组的操作，包括获取、设置和扩展数组元素。
- `endArray(final String name, final String indexesStr, final EndArrayCallback<T> callback)`：处理多维数组的工具方法，根据给定的名字和索引字符串，定位到最后一级数组并执行回调函数。
- `parseIndexes(final String s)`：解析索引字符串，将其转换为整数数组。
**三、应用场景**
这个类可以在以下场景中使用：
1. 处理 JSON 数据：可以方便地创建、修改和读取 JSON 格式的数据结构，支持嵌套的对象和数组。
2. 数据传输和存储：在网络通信或数据存储中，将数据表示为`JSONObject`对象，便于序列化和反序列化。
3. 与其他系统集成：作为一种通用的数据结构，与不同的系统进行数据交互，方便地转换为其他格式或对象。
4. 配置文件处理：读取和解析配置文件中的 JSON 数据，使用`JSONObject`来表示配置信息。
617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
