Python 解析JSON实现主机管理

大月

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它以易于阅读和编写的文本形式表示数据。JSON 是一种独立于编程语言的数据格式，因此在不同的编程语言中都有对应的解析器和生成器。JSON 格式的设计目标是易于理解、支持复杂数据结构和具有良好的可扩展性。
JSON 数据是以键值对的形式存在的，而且易于阅读和编写。以下是一个简单的 JSON 示例：

1. {
2.   "name": "John Doe",
3.   "age": 30,
4.   "city": "New York",
5.   "isStudent": false,
6.   "grades": [95, 88, 75, 92],
7.   "address": {
8.     "street": "123 Main St",
9.     "zipCode": "10001"
10.   }
11. }

复制代码

在这个例子中，JSON 对象包含了一些属性，包括字符串、数字、布尔值、数组和嵌套的对象。

• "name": "John Doe"：字符串键值对。
  
• "age": 30：数字键值对。
  
• "city": "New York"：字符串键值对。
  
• "isStudent": false：布尔键值对。
  
• "grades": [95, 88, 75, 92]：数组键值对。
  
• "address": {...}：嵌套对象。
  

在实际应用中，JSON 数据通常用于前后端之间的数据交换，或者配置文件的存储。各种编程语言都提供了处理 JSON数据的库或模块。
很早之前大概是两年前，当时为了实现批量管理SSH账号密码并实现自动巡检功能，写过一个简单的命令行工具，通过使用JSON实现对特定主机账号密码与组的管理，如下代码，通过定义AdminDataBase()类，传如数据库文件名database.json实现对特定JSON文件的增删改查功能，在编写该案例后我对JSON的使用变得更加深刻了。

1. # -*- coding: utf-8 -*-
2. import os,json
4. class AdminDataBase(object):
5.     def __init__(self, database_path):
6.         self.database_path = database_path
7.     # 判断数据库文件是否存在,不存则则创建一个.
8.     def InitDatabase(self):
9.         if os.path.exists(self.database_path) != None :
10.             init_database = \
11.                 {
12.                     "HostList": [["1000", "127.0.0.1", "username", "password", "22"]],
13.                     "HostGroup": [{"DefaultGroup": ["1000"]}, ],
14.                 }
15.             with open(self.database_path, "w", encoding="utf-8") as fp:
16.                 fp.write(json.dumps(init_database))
17.             print("[+] {} 结构已被初始化.".format(self.database_path))
19.     # table 接收一个列表名,根据列表名输出列表中的数据
20.     def ShowHostList(self):
21.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
22.             load_json = json.loads(Read_Pointer.read())
23.             base = load_json.get("HostList")
24.             print("-" * 80)
25.             print("UUID \t 主机地址 \t\t\t 登录用户 \t\t 登录密码 \t 端口")
26.             print("-" * 80)
27.             for each in range(0, len(base)):
28.                 print("{0:4} \t {1:15} \t {2:10} \t {3:10} \t {4:10}"
29.                       .format(base[each][0], base[each][1], base[each][2], base[each][3], base[each][4]))
30.         print()
32.     # 在原来的基础上添加一台新的主机,添加到HostList表中
33.     def AddHost(self, uuid, address, username, password, port):
34.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
35.             # 读取 database.json 中的数据到内存中
36.             load_json = json.loads(Read_Pointer.read())
37.             # 先读入内存,修改后全部替换进去
38.             host_list = load_json.get("HostList")
39.             # 获取到最后一次循环的元素列表
40.             for each in range(len(host_list) - 1, len(host_list)):
41.                 # 判断如果UUID不重复则添加,否则跳过添加
42.                 if (host_list[each][0] != uuid):
43.                     host_list.append([uuid, address, username, password, port])
44.                     load_json["HostList"] = host_list
45.                     # 最后再次将改好的数据,回写到文件保存
46.                     with open(self.database_path, "w", encoding="utf-8") as Write_Pointer:
47.                         dump_json = json.dumps(load_json)
48.                         Write_Pointer.write(dump_json)
49.                         print("[+] UUID {} 添加成功.".format(uuid))
50.                 else:
51.                     print("[-] UUID {} 列表中存在,添加失败.".format(uuid))
52.                     return 0
54.     # 根据传入UUID号修改特定主机数据
55.     def ModifyHost(self,uuid,modify_address,modify_username,modify_password,modify_port):
56.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
57.             # 读取 database.json 中的数据到内存中
58.             load_json = json.loads(Read_Pointer.read())
59.             host_list = load_json.get("HostList")
61.             # 根据uuid寻找一维数组的下标位置
62.             index = -1
63.             for index, value in enumerate(host_list):
64.                 if value[0] == uuid:
65.                     print("[*] 已找到UUID {} 所在下标为 {}".format(uuid,index))
66.                     break
67.                 else:
68.                     index = -1
70.             # 判断是否找到了,找到了则修改
71.             if index != -1:
72.                 # 修改指定下标数值,并将修改后的数据放入原始JSON文件中
73.                 host_list[index] = [uuid,modify_address,modify_username,modify_password,modify_port]
74.                 load_json["HostList"] = host_list
76.                 # 最后再次将改好的数据,回写到文件保存
77.                 with open(self.database_path, "w", encoding="utf-8") as Write_Pointer:
78.                     dump_json = json.dumps(load_json)
79.                     Write_Pointer.write(dump_json)
80.                     print("[+] UUID {} 修改完成.".format(uuid))
81.                 return 0
82.             else:
83.                 print("[-] UUID {} 不存在.".format(uuid))
84.         return 0
86.     # 根据传入的UUID号删除主机数据,先删除所对的组中的数据,然后在删除主机数据
87.     def DeleteHost(self,uuid):
88.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
89.             load_json = json.loads(Read_Pointer.read())
90.             host_group = load_json.get("HostGroup")
91.             # 首先在HostGroup中寻找并弹出相应UUID
92.             for each in range(0,len(host_group)):
93.                 try:
94.                     # 循环每个字典
95.                     for k,v in host_group[each].items():
96.                         # 判断UUID是否存在于每个字典中
97.                         if v.count(uuid) != 0:
98.                             # 移除并放入原始JSON中
99.                             v.remove(uuid)
100.                             load_json["HostGroup"] = v
101.                             # 最后再次将改好的数据,回写到文件保存
102.                             with open(self.database_path, "w", encoding="utf-8") as Write_Pointer:
103.                                 dump_json = json.dumps(load_json)
104.                                 Write_Pointer.write(dump_json)
105.                                 #print("[+] UUID {} 修改完成.".format(uuid))
106.                         else:
107.                             #print("[-] 当前组 {} 不能存在: {}".format(k,uuid))
108.                             break
109.                 except Exception:
110.                     print("[-] 当前组不能存在: {}".format(uuid))
111.                     return 0
112.             # ----------------------------------------------
113.             # 其次寻找HostList中的数据并弹出
114.             host_list = load_json.get("HostList")
115.             try:
116.                 # 根据uuid寻找一维数组的下标位置
117.                 index = -1
118.                 for index, value in enumerate(host_list):
119.                     if value[0] == uuid:
120.                         #print("[*] 已找到UUID {} 所在下标为 {}".format(uuid,index))
121.                         break
122.                     else:
123.                         index = -1
124.                 # 如果找到了,则直接根据下标弹出数据
125.                 if index != -1:
126.                     host_list.pop(index)
127.                 load_json["HostList"] = host_list
128.                 # 最后再次将改好的数据,回写到文件保存
129.                 with open(self.database_path, "w", encoding="utf-8") as Write_Pointer:
130.                     dump_json = json.dumps(load_json)
131.                     Write_Pointer.write(dump_json)
132.                 print("[+] UUID {} 主机: {} 已被移除.".format(uuid,host_list[index][1]))
133.                 return 0
134.             except Exception:
135.                 return 0
137.     # 向数据库中的HostGroup字段中添加一个主机组
138.     def AddHostGroup(self,add_group_name):
139.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
140.             load_json = json.loads( Read_Pointer.read() )
141.             group_obj = load_json.get("HostGroup")
142.             # 循环所有字典中的组
143.             for each in range(0, len(group_obj)):
144.                 list_name = str(list(group_obj[each].keys())[0])
145.                 # print("组节点: {}".format(list_name))
147.                 # 循环判断表中是否存在指定的组名称
148.                 if (list_name == add_group_name):
149.                     print("[-] {} 存在于组中,无法继续添加.".format(list_name))
150.                     return 0
151.             # 读取原始JSON文件,并构建回写参数
152.             tmp = {}
153.             tmp[add_group_name] = ["1000"]
154.             group_obj.append(tmp)
156.             # 回写添加主机组
157.             with open(self.database_path, "w", encoding="utf-8") as Write_Pointer:
158.                 dump_json = json.dumps(load_json)
159.                 Write_Pointer.write(dump_json)
160.             print("[+] 主机组 {} 已添加".format(add_group_name))
162.     # 在主机组中删除一个主机组
163.     def DeleteHostGroup(self,delete_group_name):
164.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
165.             load_json = json.loads( Read_Pointer.read() )
166.             group_obj = load_json.get("HostGroup")
168.             # 循环所有字典中的组
169.             for each in range(0, len(group_obj)):
170.                 list_name = str(list(group_obj[each].keys())[0])
171.                 # 循环判断表中是否存在指定的组名称
172.                 if (list_name == delete_group_name):
173.                     # 如果存在于组中,那我们就把他的each弹出列表
174.                     group_obj.pop(each)
176.                     # 将弹出后的列表再次写回JSON序列中
177.                     with open(self.database_path, "w", encoding="utf-8") as Write_Pointer:
178.                         dump_json = json.dumps(load_json)
179.                         Write_Pointer.write(dump_json)
180.                     print("[-] 主机组 {} 已移除.".format(delete_group_name))
181.                     return 0
182.             print("[-] 主机组 {} 不存在.".format(delete_group_name))
183.         return 0
185.     # 向指定主机组中添加一个主机UUID
186.     def AddHostGroupOnUUID(self,group_name, uuid):
187.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
188.             load_json = json.loads( Read_Pointer.read() )
189.             group_obj = load_json.get("HostGroup")
190.             # 循环所有字典中的所有组
191.             for each in range(0, len(group_obj)):
192.                 list_name = str(list(group_obj[each].keys())[0])
193.                 # 如果找到了需要添加的组
194.                 if (list_name == group_name):
195.                     tmp = group_obj[each]
196.                     # 获取到原始列表中的数据
197.                     val = list(tmp.values())[0]
198.                     # 判断输入的UUID号,是否在val列表中,不在则添加
199.                     if str(uuid) not in val:
200.                         val.append(str(uuid))
201.                         # 将原始数据赋值到新的表中
202.                         group_obj[each][list_name] = val
203.                     else:
204.                         print("[-] UUID {} 已存在于 {} 主机组,添加失败.".format(uuid,group_name))
205.                         return 0
207.         with open(self.database_path, "w", encoding="utf-8") as Write_Pointer:
208.             dump_json = json.dumps(load_json)
209.             Write_Pointer.write(dump_json)
210.             print("[+] 向主机组 {} 增加UUID {} 完成".format(group_name, uuid))
211.         return 0
213.     # 从指定主机组中删除一个指定的UUID号
214.     def DeleteHostGroupOnUUID(self,group_name, uuid):
215.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
216.             load_json =json.loads( Read_Pointer.read() )
217.             group_obj = load_json.get("HostGroup")
218.             # 循环所有字典中的组
219.             for each in range(0, len(group_obj)):
220.                 list_name = str(list(group_obj[each].keys())[0])
221.                 # 先来寻找到需要删除的主机组
222.                 if (list_name == group_name):
223.                     tmp = group_obj[each]
224.                     # 寻找指定组中的指定列表
225.                     val = list(tmp.values())[0]
226.                     for x in range(0, len(val)):
227.                         if (val[x] == uuid):
228.                             print("[*] 搜索UUID: {} 索引值: {}".format(val[x], x))
229.                             # 将要删除的UUID弹出列表
230.                             val.pop(x)
231.                             # 将弹出后的列表重新复制到主机组中
232.                             group_obj[each][list_name] = val
233.                             # 保存弹出后的列表到序列中
234.                             with open(self.database_path, "w", encoding="utf-8") as write_fp:
235.                                 dump_json = json.dumps(load_json)
236.                                 write_fp.write(dump_json)
237.                             print("[+] 从主机组 {} 弹出UUID {} 完成".format(group_name, uuid))
238.                             return 0
239.         return 0
241.     # 输出所有主机组和全部节点信息
242.     def ShowAllGroup(self):
243.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
244.             load_json = json.loads( Read_Pointer.read() )
245.             group_obj = load_json.get("HostGroup")
246.             # 循环解析所有组,并解析出UUID所对应的主机地址等信息
247.             for each in range(0, len(group_obj)):
248.                 for k, v in group_obj[each].items():
249.                     print("-" * 140)
250.                     print("主机组: {}".format(k))
251.                     print("-" * 140)
252.                     for each in range(0, len(v)):
253.                         # print("--> UUID: {}".format(v[each]))
254.                         # 循环判断,拿着组内UUID判断是否存在,如果存在则打印出主机详细信息
255.                         base_obj = load_json.get("HostList")
256.                         for x in range(0, len(base_obj)):
257.                             if (v[each] == base_obj[x][0]):
258.                                 print("UUID: {0:6} \t 主机地址: {1:15} \t 主机账号: {2:15} \t 主机密码: {3:15} \t 端口: {4:5} \t".
259.                                       format(base_obj[x][0], base_obj[x][1], base_obj[x][2], base_obj[x][3],
260.                                              base_obj[x][4]))
261.                     print("\n")
263.     # 只显示所有的主机组,包括组中主机数
264.     def ShowGroup(self):
265.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
266.             load_json = json.loads( Read_Pointer.read() )
267.             group_obj = load_json.get("HostGroup")
268.             print("-" * 80)
269.             print("{0:20} \t {1:5} \t {2:100}".format("主机组名","主机数","主机列表"))
270.             print("-" * 80)
271.             for each in range(0,len(group_obj)):
272.                 for k,v in group_obj[each].items():
273.                     print("{0:20} \t {1:5} \t {2:100}".format(k,str(len(v)), str(v)))
274.         print()
275.         return 0
277.     # 对指定的主机组进行Ping测试
278.     def PingGroup(self,group_name):
279.         with open(self.database_path, "r", encoding="utf-8") as Read_Pointer:
280.             load_json = json.loads( Read_Pointer.read() )
281.             group_obj = load_json.get("HostGroup")
282.             # 循环遍历主机列表
283.             for each in range(0, len(group_obj)):
284.                 for k, v in group_obj[each].items():
285.                     # 寻找主机组,找到后提取出所有的Value
286.                     if (k == group_name):
287.                         item_list = v
288.                         # 再循环,拿着v的值对base进行循环,提取出其中的用户名密码等
289.                         for val in range(0, len(item_list)):
290.                             # 得到循环列表：print(item_list[val])
291.                             base_obj = load_json.get("HostList")
292.                             # 循环base表中的计数器
293.                             for base_count in range(0, len(base_obj)):
294.                                 # 判断base表中是否存在指定UUID,如果存在则输出其值
295.                                 if (base_obj[base_count][0] == item_list[val]):
296.                                     print("地址: {} \t 用户名: {} [ok]".format(base_obj[base_count][1],base_obj[base_count][2]))
297. if __name__ == "__main__":
298.     db = AdminDataBase("database.json")
299.     while True:
300.         try:
301.             cmd = str(input("[LyShell] # ")).split()
302.             if (cmd == ""):
303.                 continue
304.             elif (cmd[0] == "exit"):
305.                 exit(1)
306.             elif (cmd[0] == "clear"):
307.                 os.system("cls")
308.             elif(cmd[0] == "Init"):
309.                 db.InitDatabase()
310.             elif(cmd[0] == "ShowHostList"):
311.                 db.ShowHostList()
312.             elif(cmd[0] == "ShowGroup"):
313.                 db.ShowGroup()
314.             elif(cmd[0] == "ShowAllGroup"):
315.                 db.ShowAllGroup()
316.             elif(cmd[0] == "AddHost" or cmd[0] == "ModifyHost"):
317.                 if (len(cmd) - 1 >= 5):
318.                     uuid = str(cmd[1]).split("=")[1]
319.                     address = str(cmd[2]).split("=")[1]
320.                     username = str(cmd[3]).split("=")[1]
321.                     password = str(cmd[4]).split("=")[1]
322.                     port = str(cmd[5]).split("=")[1]
323.                     if cmd[0] == "AddHost":
324.                         db.AddHost(uuid,address,username,password,port)
325.                     elif cmd[0] == "ModifyHost":
326.                         db.ModifyHost(uuid,address,username,password,port)
327.             elif(cmd[0] == "DeleteHost"):
328.                 if(len(cmd)-1 >= 1):
329.                     uuid = str(cmd[1]).split("=")[1]
330.                     db.DeleteHost(uuid)
331.             elif(cmd[0] == "AddHostGroup"):
332.                 group_name = str(cmd[1]).split("=")[1]
333.                 db.AddHostGroup(group_name)
334.             elif(cmd[0] == "DeleteHostGroup"):
335.                 group_name = str(cmd[1]).split("=")[1]
336.                 db.DeleteHostGroup(group_name)
337.             elif(cmd[0] == "AddHostGroupOnUUID"):
338.                 group_name = str(cmd[1]).split("=")[1]
339.                 uuid = str(cmd[2]).split("=")[1]
340.                 db.AddHostGroupOnUUID(group_name,uuid)
341.             elif(cmd[0] == "DelHostGroupOnUUID"):
342.                 group_name = str(cmd[1]).split("=")[1]
343.                 uuid = str(cmd[2]).split("=")[1]
344.                 db.DeleteHostGroupOnUUID(group_name,uuid)
345.             elif(cmd[0] == "PingGroup"):
346.                 group_name = str(cmd[1]).split("=")[1]
347.                 db.PingGroup(group_name)
348.             elif (cmd[0] == "help"):
349.                 print("By: LyShark")
350.             else:
351.                 print("Not Command")
352.         except Exception:
353.             continue

复制代码

使用案例

管理数据库（AdminDataBase）中的主机信息和主机分组信息。用户通过输入命令来执行不同的操作，如初始化数据库、显示主机列表、添加主机、修改主机信息、删除主机等。
以下是代码的主要功能和命令列表：

• 初始化数据库：Init
  
• 显示主机列表：ShowHostList
  
• 显示主机分组：ShowGroup
  
• 显示所有主机分组：ShowAllGroup
  
• 添加主机：AddHost
  
• 修改主机信息：ModifyHost
  
• 删除主机：DeleteHost
  
• 添加主机分组：AddHostGroup
  
• 删除主机分组：DeleteHostGroup
  
• 将主机添加到指定分组：AddHostGroupOnUUID
  
• 从指定分组删除主机：DelHostGroupOnUUID
  
• 按组执行 Ping 操作：PingGroup
  
• 清屏：clear
  
• 退出程序：exit
  
• 帮助：help
  

Init
初次使用需要执行本命令，对数据库文件进行写出，如下所示；

ShowHostList
用于输出当前主机列表信息，如下图所示；

ShowGroup
用于输出当前主机组，如下图所示；

ShowAllGroup
用于输出所有的主机组以及组内的主机详细信息，如下图所示；

AddHost
添加一个新的主机记录，如下图所示；

ModifyHost
修改一个已有的主机记录，此处以UUID作为修改条件，如下图所示；

DeleteHost
根据一个UUID唯一标识，删除一个已存在的主机记录，如下图所示；

AddHostGroup
新增一个组名，默认会携带1000为初始主机，如下图所示；

DeleteHostGroup
删除一整个主机组，如下图所示；

AddHostGroupOnUUID
根据UUID号将特定主机添加到特定组内，如下图所示；

DelHostGroupOnUUID
根据主机组名，删除特定的UUID，如下图所示；

PingGroup
对特定主机组执行Ping功能测试，此处可以扩展，如下图所示；

总结部分

该案例只是用于学习如何灵活运用JSON实现数据的增删改查，其实在实战中意义不大，因为完全可以使用SQLite这类精简数据库，此案例只是本人为了熟悉JSON的增删改查而写的一个Demo工具。

来源:https://www.cnblogs.com/LyShark/p/17875693.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！