• 动态封装对象，属性来自json

    需求： 如何动态的获取一个对象的字段，假如一个对象里面有name,age，sex三个字段，我想取name的值，这个name是存在一个json中，json的格式如下[{"key":"name"},{"key":"age"},{"key":"sex"}]先遍历这个json,然后再根据key的值，取对象中对应的属性值。  也就是获取json对应的key的value，封装到对象中。

    GPT给出的答案：

    1. 在 Java 中，你可以按照以下步骤动态获取一个对象的字段：
    2.  
    3. 1. 遍历 JSON 数组，获取每个对象的 `key` 值。
    4. 2. 使用获取到的 `key` 值作为属性名称，利用 Java 反射机制获取对象的对应属性值。
    5.  
    6. 下面是一个示例代码：
    7.  
    8.  
    9. import com.fasterxml.jackson.databind.JsonNode;
    10. import com.fasterxml.jackson.databind.ObjectMapper;
    11.  
    12. import java.util.List;
    13.  
    14. public class Main {
    15.     public static void main(String[] args) throws Exception {
    16.         String jsonStr = "[{\"key\":\"name\"},{\"key\":\"age\"},{\"key\":\"sex\"}]";
    17.  
    18.         ObjectMapper objectMapper = new ObjectMapper();
    19.         List data = objectMapper.readValue(jsonStr, List.class);
    20.  
    21.         Person person = new Person("John", 25, "male");
    22.  
    23.         for (JsonNode item : data) {
    24.             String key = item.get("key").asText();
    25.             Object value = getValueByKey(person, key);
    26.             System.out.println(key + ": " + value);
    27.         }
    28.     }
    29.  
    30.     public static Object getValueByKey(Object obj, String key) throws Exception {
    31.         return obj.getClass().getMethod("get" + capitalize(key)).invoke(obj);
    32.     }
    33.  
    34.     public static String capitalize(String str) {
    35.         if (str == null || str.isEmpty()) {
    36.             return str;
    37.         }
    38.         return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    39.     }
    40. }
    41.  
    42. class Person {
    43.     private String name;
    44.     private int age;
    45.     private String sex;
    46.  
    47.     public Person(String name, int age, String sex) {
    48.         this.name = name;
    49.         this.age = age;
    50.         this.sex = sex;
    51.     }
    52.  
    53.     public String getName() {
    54.         return name;
    55.     }
    56.  
    57.     public int getAge() {
    58.         return age;
    59.     }
    60.  
    61.     public String getSex() {
    62.         return sex;
    63.     }
    64. }
    65.  
    66.  
    67. 这段代码将输出：
    68.  
    69.  
    70. name: John
    71. age: 25
    72. sex: male
    73.  
    74.  
    75. 请注意，上述代码中的 `Person` 类是一个简单的示例，具有 `name`、`age` 和 `sex` 三个字段，并为每个字段提供了对应的 `get` 方法。你可以根据你的实际需求修改代码以适应你的对象结构和命名规则。
    76.

    问题： 基于上面的问题，那要是想设置对象属性值呢？

    GPT的答案：

    1. 如果你想设置对象的属性值，你可以按照以下步骤进行操作：
    2.  
    3. 1. 遍历 JSON 数组，获取每个对象的 `key` 值和对应的属性值。
    4. 2. 使用获取到的 `key` 值作为属性名称，利用 Java 反射机制设置对象的属性值。
    5.  
    6. 下面是一个示例代码：
    7.  
    8.  
    9. import com.fasterxml.jackson.databind.JsonNode;
    10. import com.fasterxml.jackson.databind.ObjectMapper;
    11.  
    12. import java.util.List;
    13.  
    14. public class Main {
    15.     public static void main(String[] args) throws Exception {
    16.         String jsonStr = "[{\"key\":\"name\",\"value\":\"John\"},{\"key\":\"age\",\"value\":25},{\"key\":\"sex\",\"value\":\"male\"}]";
    17.  
    18.         ObjectMapper objectMapper = new ObjectMapper();
    19.         List data = objectMapper.readValue(jsonStr, List.class);
    20.  
    21.         Person person = new Person();
    22.  
    23.         for (JsonNode item : data) {
    24.             String key = item.get("key").asText();
    25.             Object value = item.get("value").asText();
    26.             setValueByKey(person, key, value);
    27.         }
    28.  
    29.         System.out.println(person);
    30.     }
    31.  
    32.     public static void setValueByKey(Object obj, String key, Object value) throws Exception {
    33.         obj.getClass().getMethod("set" + capitalize(key), value.getClass()).invoke(obj, value);
    34.     }
    35.  
    36.     public static String capitalize(String str) {
    37.         if (str == null || str.isEmpty()) {
    38.             return str;
    39.         }
    40.         return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    41.     }
    42. }
    43.  
    44. class Person {
    45.     private String name;
    46.     private int age;
    47.     private String sex;
    48.  
    49.     public Person() {
    50.     }
    51.  
    52.     public String getName() {
    53.         return name;
    54.     }
    55.  
    56.     public void setName(String name) {
    57.         this.name = name;
    58.     }
    59.  
    60.     public int getAge() {
    61.         return age;
    62.     }
    63.  
    64.     public void setAge(int age) {
    65.         this.age = age;
    66.     }
    67.  
    68.     public String getSex() {
    69.         return sex;
    70.     }
    71.  
    72.     public void setSex(String sex) {
    73.         this.sex = sex;
    74.     }
    75.  
    76.     @Override
    77.     public String toString() {
    78.         return "Person{" +
    79.                 "name='" + name + '\'' +
    80.                 ", age=" + age +
    81.                 ", sex='" + sex + '\'' +
    82.                 '}';
    83.     }
    84. }
    85.  
    86.  
    87. 这段代码将输出：
    88.  
    89. Person{name='John', age=25, sex='male'}
    90.  
    91.  
    92. 请注意，上述代码中的 `Person` 类是一个简单的示例，具有 `name`、`age` 和 `sex` 三个字段，并为每个字段提供了对应的 `get` 和 `set` 方法。你可以根据你的实际需求修改代码以适应你的对象结构和命名规则。
    93.

    具体在工作中的处理逻辑：

    1. 1. Mysql 任务属性字段已经确认，例如字段已经有了name,age
    2. 2. 变更：属性字段可配置，即支持用户前端设置，例如用户需要添加属性 地址address,联系方式phone等字段，字段个数不定。同时支持可以设置默认值或者选项值，例如：性别：男、女
    3. 3. 要求：在不修改Mysql结构的情况下，支持变更要求
    4. 4. 解决：① 设计规则，形成json规则字符串。
    5. 		   在创建任务的时候记录 此时用户需要的字段，若是已经存在的字段-则直接记录。 若是新添加的属性，则直接记录。		   
    6. 		 ② 设置Mysql对应结果字段，原有字段不变，例如：name,age。动态字段可以在表中新增一个custom_field，数据是json形式的，例如[{"key":"我的自定义标签","value":"val2"}]保存动态字段结果。
    7.          交互如下：		 
    8. 		 ③ 结果返回前端展示：查询数据库，将对象转换JSON，返回前端。JSON具体格式前后端商量即可。
    9. 		 ④ 前端提交参数入库(编辑)：JSON转换对象，操作数据库保存。
    10. 5. 技术：JSON和反射
    11.  
    12.  
    13. [
    14. 			{
    15. 				"canUpdate": 1,
    16. 				"enable": 1,
    17. 				"fieldName": "affiliatedCompany", //对应mysql表字段affiliated_company
    18. 				"id": 11,
    19. 				"inputBox": 1,
    20. 				"insertTime": "2023-09-05 15:45:02",
    21. 				"remark": "",
    22. 				"sort": 10,
    23. 				"status": 1,
    24. 				"tag": "所属公司", //字段的中文含义，在页面显示
    25. 				"type": 1,
    26. 				"updateTime": "2023-09-14 17:55:04"
    27. 			},
    28. 			{
    29. 				"canUpdate": 1,
    30. 				"enable": 1,
    31. 				"fieldName": "url",  //对应mysql表字段url
    32. 				"id": 64,
    33. 				"inputBox": 1,
    34. 				"insertTime": "2023-10-09 09:42:19",
    35. 				"remark": "",
    36. 				"status": 1,
    37. 				"tag": "网址",
    38. 				"type": 1,
    39. 				"updateTime": "2023-10-09 11:14:34"
    40. 			},
    41. 			{
    42. 				"canUpdate": 1,
    43. 				"dicInfoList": [
    44. 					{
    45. 						"dicValue": "val1",
    46. 						"id": 104,
    47. 						"tagLibraryId": 68
    48. 					},
    49. 					{
    50. 						"dicValue": "val2",
    51. 						"id": 105,
    52. 						"tagLibraryId": 68
    53. 					},
    54. 					{
    55. 						"dicValue": "val3",
    56. 						"id": 106,
    57. 						"tagLibraryId": 68
    58. 					}
    59. 				], //下拉框的可选项
    60. 				"enable": 1,
    61. 				"fieldName": "",  //自定义添加的，没有mysql对应字段，这个值就是空字符串
    62. 				"id": 68,
    63. 				"inputBox": 2,
    64. 				"insertTime": "2024-01-28 14:21:24",
    65. 				"remark": "",
    66. 				"status": 1,
    67. 				"tag": "我的自定义标签", //自定义添加的，页面显示
    68. 				"type": 1,
    69. 				"updateTime": "2024-01-28 14:21:24"
    70. 			}
    71. 		   ]
    72.  
    73.  
    74. 相关代码Util
    75.  
    76.  /**
    77.      * @description: 将 对象中的属性值 ，转换json
    78.      * @return: void
    79.      * @author: hezha
    80.      * @time: 2023/9/12 16:19
    81.      */
    82.     public static void transData(net.sf.json.JSONArray jsonArray, Object obj) {
    83.         try {
    84.             for(int i=0; i< jsonArray.size() ;i++){
    85.                 net.sf.json.JSONObject jsonObject = jsonArray.getJSONObject(i);
    86.                 String key = jsonObject.getString("key");
    87.                 String field = jsonObject.getString("field");
    88.                 if(org.apache.commons.lang3.StringUtils.isNotEmpty(field)){
    89.                     //有值，代表是基础指标，数据库就会存在对应的字段
    90.                     Object value = getValueByKey(obj, field);
    91.                     jsonObject.put("value", value!=null?value:"");
    92.                 }else{
    93.                     //无值，就是这个json不是基础字段，是扩展字段，就是存储在custom_field中的
    94.                     Object customField = getValueByKey(obj, "customField");
    95.                     if(customField != null){
    96.                         String customFieldStr = (String) customField;
    97.                         JSONArray customFieldArr = JSONArray.fromObject(customFieldStr);
    98.                         for(int j= 0; j< customFieldArr.size(); j++){
    99.                             JSONObject customFieldJson = customFieldArr.getJSONObject(j);
    100.                             String customFieldKey = customFieldJson.getString("key");
    101.                             String customFieldValue = customFieldJson.getString("value");
    102.                             if(key.equals(customFieldKey)){
    103.                                 jsonObject.put("value", customFieldValue);
    104.                             }
    105.                         }
    106.                     }
    107.                 }
    108.             }
    109.         }catch (Exception e){
    110.             e.printStackTrace();
    111.         }
    112.  
    113.     }
    114.  
    115.  
    116.     public static Object getValueByKey(Object obj, String key) throws Exception {
    117.         return obj.getClass().getMethod("get" + capitalize(key)).invoke(obj);
    118.     }
    119.  
    120.     public static String capitalize(String str) {
    121.         if (str == null || str.isEmpty()) {
    122.             return str;
    123.         }
    124.         return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    125.     }
    126.  
    127.  
    128.     public static void setValueByKey(Object obj, String key, Object value) throws Exception {
    129.         obj.getClass().getMethod("set" + capitalize(key), value.getClass()).invoke(obj, value);
    130.     }
    131.  
    132.  
    133.  
    134.     /**
    135.      * @description: 将json字符串转换对用的对象
    136.      * @return: java.lang.Object
    137.      * @author: hezha
    138.      * @time: 2023/9/5 20:16
    139.      */
    140.     public static Object transObj(String jsonStr, Object obj){
    141.         JSONArray array = new JSONArray();
    142.         try {
    143.             JSONArray jsonArray = JSONArray.fromObject(jsonStr);
    144.             for(int i=0; i< jsonArray.size(); i++){
    145.                 JSONObject jsonObject = jsonArray.getJSONObject(i);
    146.                 String field = jsonObject.get("field") != null? jsonObject.getString("field"):"";
    147.                 Object value = jsonObject.get("value") != null? jsonObject.get("value"):"";
    148.                if(com.wenge.util.StringUtils.isNotEmpty(field)){
    149.                    //字段不为空，就是基础字段，数据库中就有字段来保存
    150.                    Helper.setValueByKey(obj, field, value);
    151.                }else{
    152.                    JSONObject json = new JSONObject();
    153.                    //如果是null 就是扩展字段，所有的扩展字段使用一个json 存储在custom_field中
    154.                    String key = jsonObject.getString("key");
    155.                    json.put("key", key);
    156.                    json.put("value", value);
    157.                    array.add(json);
    158.                }
    159.  
    160.             }
    161.  
    162.             if(array.size() > 0){
    163.                 setValueByKey(obj, "CustomField", array.toString());
    164.             }
    165.         }catch (Exception e){
    166.             e.printStackTrace();
    167.         }
    168.  
    169.         return obj;
    170.  
    171.     }
    172.

  • 相关阅读:
    DFS专题训练1
    报错记录—feign转对象为linkedHashMap
    正雅齿科儿童咬合诱导及青少年隐形矫治线上线下融合峰会成功开展
    Matlab之查询子字符串在字符串中的起始位置函数strfind
    Python OpenCV 视频抽帧处理并保存
    ESP8266-Arduino编程实例-BMA400加速度传感器驱动
    基于springboot实现多线程抢锁的demo
    进程管理命令 动态监控进程 rpm yum
    如何实现多个不同目录下的Anaconda软件环境切换
    企业专线成本高？贝锐蒲公英轻松实现财务系统远程访问
  • 原文地址：https://blog.csdn.net/zhanghe687/article/details/132802692