解析代码大全

目前只写了解析普通文本文件、解析 JSON 文件和复杂 JSON 的例子，其他的后续再补充。

1 解析普通文本文件

在静态资源文件目录 resources 下，有一个版本文件 version.txt，它的内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
-----------------------------------------分割线--------------------------------------------
    更新日期：2021-11-19 ~ 2021-11-30
    当前版本：v2.2.0
    后端版本：v1.0.12
    前端版本：v1.1.23
    更新作者：小名
    更新内容：（2）增加新版本
             （1）优化代码

-----------------------------------------分割线--------------------------------------------
    更新日期：2020-12-09
    当前版本：v1.0.1
    后端版本：v1.0.1
    前端版本：v1.0.1
    更新作者：小至
    更新内容：（1）初次确定版本迭代版本

为获取文件中的最新版本号，刚开始想用 NIO 去逐行提取文本中的内容：

1
2
3
4
5
6
7
8
9
10
String fileName = "version.txt";
try {
    List<String> lines = Files.readAllLines(Paths.get(fileName),
            Charset.defaultCharset());
    for (String line : lines) {
        LOGGER.info(line);
    }
} catch (IOException e) {
    LOGGER.error("Occurs ex: {}", e.getMessage(), e);
}

随后发现这种写法会有读静态资源文件路径的问题，在研究了 Files.readAllLines() 的源码之后，改写成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/** 按行读取文本文件，文件在 resources 目录下 */
public static String getLatestVersion(String versionFilePath) {
    // 比如 versionFilePath 为: "static/version/version.txt"
    ClassPathResource classPathResource = new ClassPathResource(versionFilePath);
    String currentVersion = null;
    if (classPathResource.exists()) {
        try {
            InputStream inputStream = classPathResource.getInputStream();
            Reader reader = new InputStreamReader(inputStream, Charset.defaultCharset().newDecoder());
            BufferedReader bufferedReader = new BufferedReader(reader);
            List<String> result = new ArrayList<>();
            for (;;) {
                String line = bufferedReader.readLine();
                if (line == null) {
                    break;
                }
                // 从上到下，版本的变化是从新到旧，因此只需要读第一次出现的当前版本即可
                if (line.contains("当前版本")) {
                    int index = line.indexOf("v");
                    line = line.substring(index, line.length());
                    currentVersion = line;
                    break;
                }
                result.add(line);
            }
            for (String line : result) {
                LOGGER.info(line);
            }
            LOGGER.info("Get currentVersion: " + currentVersion);
        } catch (IOException e) {
            LOGGER.error("Occurs ex: {}", e.getMessage(), e);
        }
    }
    return currentVersion;
}

执行结果：

1
2
3
-----------------------------------------分割线--------------------------------------------
    更新日期：2021-11-19 ~ 2021-11-30
Get currentVersion: v2.2.0

2 解析 JSON 文件

有了解析普通文本文件的经验后，现在来解析 JSON 文件，JSON 文件内容为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
{
  "description": [
    "注意事项：每次版本发布，版本更新记录进行从下到上即倒序编写",
    "版本号说明：",
    "举例：1.3.10",
    "小数点为分隔符，从左到右依次为：",
    "1: 代表后端大版本号",
    "3: 代表后端小版本号",
    "10: 10 代表与外部的版本号"
  ],
  "content": [
    {
      "updateVersion": "1.3.10",
      "updateDate": "2021-12-16",
      "content": [
        "(2)优化代码",
        "(1)增加新版本"
      ]
    },
    {
      "updateVersion": "1.0.10",
      "updateDate": "2021-11-25",
      "content": [
        "(1)初次确定版本迭代版本"
      ]
    }
  ]
}

创建一个与 content 对应的 VersionInfo 实体类：

1
2
3
4
5
6
7
8
@Data
public class VersionInfo {

    private String updateDate;
    private String versionNumber;
    private List<String> content;

}

解析代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.test.entity.dto.VersionInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;

import java.io.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

public class VersionUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(VersionUtils.class);
    public static final String JSON_KEY_CONTENT = "content";
    public static final String JSON_KEY_VERSION = "updateVersion";
    public static final String JSON_KEY_DATE = "updateDate";

    /** 根据静态资源文件路径解析文件 */
    public static List<VersionInfo> getListVersionDetail(String resourceFilePath) {
        // 比如 resourceFilePath 为: "static/version/back_version.json"
        if (null == resourceFilePath) { return null; }
        String result = getVersionJsonStr(resourceFilePath);
        if (null == result) {
            return null;
        }
        return jsonStr2List(result);
    }

    public static String getVersionJsonStr(String resourceFilePath) {
        if (null == resourceFilePath) { return null; }
        ClassPathResource classPathResource = new ClassPathResource(resourceFilePath);
        if (classPathResource.exists()) {
            try {
                InputStream inputStream = classPathResource.getInputStream();
                Reader reader = new InputStreamReader(inputStream, StandardCharsets.UTF_8.newDecoder());
                int ch = 0;
                StringBuffer sb = new StringBuffer();
                while ((ch = reader.read()) != -1) {
                    sb.append((char) ch);
                }
                reader.close();
                inputStream.close();
                return sb.toString();
            } catch (IOException e) {
                LOGGER.error("Occurs ex: {}", e.getMessage(), e);
                return null;
            }
        }
        return null;
    }

    /** 根据文件对象解析文件 */
    public static List<VersionInfo> getListVersionDetail(File file) {
        if (null == file) { return null; }
        String result = getVersionJsonStr(file);
        if (null == result) {
            return null;
        }
        return jsonStr2List(result);
    }

    public static String getVersionJsonStr(File file) {
        if (null == file) { return null; }
        try {
            FileReader fileReader = new FileReader(file);
            Reader reader = new InputStreamReader(new FileInputStream(file), "UTF-8");
            int ch = 0;
            StringBuffer buf = new StringBuffer();
            while ((ch = reader.read()) != -1) {
                buf.append((char) ch);
            }
            reader.close();
            fileReader.close();
            return buf.toString();
        } catch (Exception e) {
            LOGGER.error("Occurs ex: {}", e.getMessage(), e);
            return null;
        }
    }

    /** Json字符串转对象 */
    public static List<VersionInfo> jsonStr2List(String jsonStr) {
        if (StringUtils.isBlank(jsonStr)) { return null; }
        List<VersionInfo> listVersion = new ArrayList<>();
        JSONObject jsonObject = JSON.parseObject(jsonStr);
        JSONArray details = jsonObject.getJSONArray(JSON_KEY_CONTENT);
        for (int i = 0; i < details.size(); i++) {
            VersionInfo versionInfo = new VersionInfo();
            JSONObject element = (JSONObject) details.get(i);
            versionInfo.setVersionNumber((String) element.get(JSON_KEY_VERSION));
            versionInfo.setUpdateDate((String) element.get(JSON_KEY_DATE));
            JSONArray subDetails = element.getJSONArray(JSON_KEY_CONTENT);
            List<String> listSub = new ArrayList<>();
            for (int j = 0; j < subDetails.size(); j++) {
                listSub.add(subDetails.get(j).toString());
            }
            versionInfo.setContent(listSub);
            listVersion.add(versionInfo);
        }
        return listVersion;
    }
}

3 解析嵌套的 JSON 数组字符串

请将下面这个嵌套的 JSON 数组字符串转换为 Java 对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
[
    {
        "DeviceType": "BASE",
        "Name": "BASE",
        "PATH": "/BASE",
        "SOC": "Linux",
        "SN": "8654.2316.55511",
        "IP": "192.168.22.33",
        "Port": "8089",
        "Stat": "0",
        "children": [
            {
                "DeviceType": "PNC",
                "Name": "PNC1",
                "PATH": "/BASE/PNC1",
                "SOC": "Linux",
                "SN": "7164.2314.44442",
                "IP": "192.168.21.14",
                "Port": "8080",
                "Stat": "0",
                "children": [
                    {
                        "DeviceType": "KT13",
                        "Name": "KT131",
                        "PATH": "/BASE/PNC1/KT131",
                        "SOC": "FreeOS",
                        "SN": "5683.5332.3333",
                        "IP": "192.168.20.34",
                        "Port": "8080",
                        "Stat": "0",
                        "children": []
                    },
                    {
                        "DeviceType": "KT13",
                        "Name": "KT132",
                        "PATH": "/BASE/PNC1/KT132",
                        "SOC": "FreeOS",
                        "SN": "5553.5642.3344",
                        "IP": "192.168.22.30",
                        "Port": "8080",
                        "Stat": "0",
                        "children": []
                    }
                ]
            }
        ]
    },
    {
        "DeviceType": "HAND",
        "Name": "Handlerxx",
        "PATH": "/Handlerxx",
        "SOC": "PLC",
        "SN": "11211.1245.11115",
        "IP": "192.168.21.88",
        "Port": "51764",
        "Stat": "0",
        "children": [
            {
                "DeviceType": "HTR",
                "Name": "Heaterxx",
                "PATH": "/Handlerxx/Heaterxx",
                "SOC": "FreeOS",
                "SN": "11211.1145.23256",
                "IP": "192.168.66.12",
                "Port": "59764",
                "Stat": "0",
                "children": []
            }
        ]
    }
]

首先根据数据结构创建一个对应的 Java 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.io.Serial;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

@Data
@Schema(description = "Device JSON 转换对象")
public class DeviceJsonDTO implements Serializable {

	@Serial
	private static final long serialVersionUID = 1L;

	@JsonProperty("DeviceType")
	private String deviceType;

	@JsonProperty("Name")
	private String name;

	@JsonProperty("PATH")
	private String path;

	@JsonProperty("SOC")
	private String soc;

	@JsonProperty("SN")
	private String sn;

	@JsonProperty("IP")
	private String ip;

	@JsonProperty("Port")
	private String port;

	@JsonProperty("Stat")
	private String stat;

    // 若 JSON 字段名与属性名一样，也建议注解上
	@JsonProperty("children")
	private List<DeviceJsonDTO> children;

}

然后编写转换方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.pig4cloud.pig.system.api.dto.DeviceJsonDTO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

public class JsonParser {

	private static final Logger logger = LoggerFactory.getLogger(JsonParser.class);
	private static final ObjectMapper objectMapper = new ObjectMapper();

	public static List<DeviceJsonDTO> parseNestedJson(String jsonArrayStr) {
		List<DeviceJsonDTO> result = new ArrayList<>();
		try {
			List<DeviceJsonDTO> nodes = objectMapper.readValue(jsonArrayStr,
					new TypeReference<List<DeviceJsonDTO>>() {}
			);
			for (DeviceJsonDTO node : nodes) {
				processChildren(node);
				result.add(node);
			}
			return result;
		} catch (Exception e) {
			logger.error("Parse nested json exception: {}", e.getMessage(), e);
			return new ArrayList<>();
		}
	}

	private static void processChildren(DeviceJsonDTO node) {
		if (node.getChildren() != null && !node.getChildren().isEmpty()) {
			for (DeviceJsonDTO child : node.getChildren()) {
				processChildren(child);
			}
		}
	}
}

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

不积跬步<br/><br/>无以至千里<br/><br/>不积小流<br/><br/>无以成江海