• Json字符串内容比较-超实用版

    背景

    之前有类似接口diff对比，数据对比的测试需求，涉及到json格式的数据对比，调研了几个大神们分享的代码，选了一个最符合自己需求的研究了下。

    说明

    这个对比方法，支持JsonObject和JsonArray类型的数据对比，支持：

    • 深度的对比：list变化（个数、内容）、层级结构变化

    • 字段的对比：新增、修改、删除数据可察觉，能找到对应的旧数据

    • 支持特定字段忽略对比

    输出的对比结果格式为：

    源码分为JsonCompareUtils， JsonAndMapSortUtils两个类，对比入口是compareTwoJson方法

    核心逻辑在JsonCompareUtils类中，JsonAndMapSortUtils主要做过程中的数据排序功能，相对独立。

     上源码：

    1. import com.alibaba.fastjson.JSON;
    2. import com.alibaba.fastjson.JSONArray;
    3. import com.alibaba.fastjson.JSONObject;
    4. import org.apache.commons.lang.ArrayUtils;
    5. import org.apache.commons.lang.StringUtils;
    6.  
    7. import java.util.HashMap;
    8. import java.util.Iterator;
    9. import java.util.LinkedHashMap;
    10. import java.util.Map;
    11. import java.util.stream.Stream;
    12.  
    13. public class JsonCompareUtils {
    14.     //标志位：对json报文中含有JsonArray类型的数据是否进行排序
    15.     private static boolean isSort;
    16.  
    17.     private Map oldJsonToMap = new LinkedHashMap<>();
    18.     private Map newJsonToMap = new LinkedHashMap<>();
    19.  
    20.     //每一个实体里的排序字段
    21.     private static Map filedNameMap = new HashMap<>();
    22.  
    23.     static {
    24.         filedNameMap.put("ojb1", "id");
    25.         filedNameMap.put("ojb2", "id");
    26.     }
    27.  
    28.     //可以跳过比对的字段
    29.     private static String[] skipCompareFiledNameMap = {"createTime"};
    30.  
    31.     /**
    32.      * 两json报文比对入口
    33.      *
    34.      * @param oldJsonStr
    35.      * @param newJsonStr
    36.      * @return
    37.      */
    38.     public String compare2Json(String oldJsonStr, String newJsonStr) {
    39.         /**
    40.          * 递归遍历json对象所有的key-value，以map形式的path:value进行存储
    41.          * 然后对两个map进行比较
    42.          */
    43.         convertJsonToMap(JSON.parseObject(oldJsonStr), "", false);
    44.         convertJsonToMap(JSON.parseObject(newJsonStr), "", true);
    45.         //获取比较结果
    46.         Map differenceMap = compareTwoMaps(oldJsonToMap, newJsonToMap);
    47.         String diffJsonResult = convertMapToJson(differenceMap);
    48.         return diffJsonResult;
    49.     }
    50.  
    51.     /**
    52.      * 将json数据转换为map存储--用于后续比较map
    53.      *
    54.      * @param json
    55.      * @param root
    56.      * @param isNew 区别新旧报文
    57.      */
    58.     private void convertJsonToMap(Object json, String root, boolean isNew) {
    59.         if (json instanceof JSONObject) {
    60.             JSONObject jsonObject = ((JSONObject) json);
    61.             Iterator iterator = jsonObject.keySet().iterator();
    62.             while (iterator.hasNext()) {
    63.                 Object key = iterator.next();
    64.                 Object value = jsonObject.get(key);
    65.                 String newRoot = "".equals(root) ? key + "" : root + "." + key;
    66.                 fillInResultMap(value, newRoot, isNew);
    67.             }
    68.         } else if (json instanceof JSONArray) {
    69.             JSONArray jsonArray = (JSONArray) json;
    70.             //将jsonArray进行排序
    71.             if (isSort) {
    72.                 //需要排序
    73.                 String sortEntityName = root.substring(root.lastIndexOf(".") + 1);
    74.                 //需要排序 获取排序字段
    75.                 String sortFiledName = filedNameMap.get(sortEntityName);
    76.                 if (!StringUtils.isEmpty(sortFiledName)) {
    77.                     jsonArray = JsonAndMapSortUtils.jsonArrayToSort(jsonArray, sortFiledName, true);
    78.                 }
    79.             }
    80.             final JSONArray jsonArray1 = jsonArray;
    81.             Stream.iterate(0, integer -> integer + 1).limit(jsonArray1.size()).forEach(index -> {
    82.                 Object value = jsonArray1.get(index);
    83.                 String newRoot = "".equals(root) ? "[" + index + "]" : root + ".[" + index + "]";
    84.                 fillInResultMap(value, newRoot, isNew);
    85.             });
    86.         }
    87.     }
    88.  
    89.     /**
    90.      * 封装json转map后的数据
    91.      *
    92.      * @param value
    93.      * @param newRoot
    94.      * @param isNew   区别新旧json
    95.      */
    96.     public void fillInResultMap(Object value, String newRoot, boolean isNew) {
    97.         if (value instanceof JSONObject || value instanceof JSONArray) {
    98.             convertJsonToMap(value, newRoot, isNew);
    99.         } else {
    100.             //设置跳过比对的字段，直接不装入map
    101.             boolean check = ArrayUtils.contains(JsonCompareUtils.skipCompareFiledNameMap, newRoot);
    102.             if (!check){
    103.                 if (!isNew) {
    104.                     oldJsonToMap.put(newRoot, value);
    105.                 } else {
    106.                     newJsonToMap.put(newRoot, value);
    107.                 }
    108.             }
    109.         }
    110.     }
    111.  
    112.     /**
    113.      * 比较两个map，将不同的数据以map形式存储并返回
    114.      *
    115.      * @param oldJsonMap
    116.      * @param newJsonMap
    117.      * @return
    118.      */
    119.     private Map compareTwoMaps(Map oldJsonMap, Map newJsonMap) {
    120.         //1.将newJsonMap的不同数据装进oldJsonMap，同时删除oldJsonMap中与newJsonMap相同的数据
    121.         newJsonMap.forEach((k, v) -> {
    122.             Map differenceMap = new HashMap<>();
    123.             if (oldJsonMap.containsKey(k)) {
    124.                 Object oldValue = oldJsonMap.get(k);
    125.                 if (v.equals(oldValue)) {
    126.                     oldJsonMap.remove(k);
    127.                 } else {
    128.                     differenceMap.put("oldValue", oldValue);
    129.                     differenceMap.put("newValue", v);
    130.                     oldJsonMap.put(k, differenceMap);
    131.                 }
    132.             } else {
    133.                 differenceMap.put("oldValue", "no exists " + k);
    134.                 differenceMap.put("newValue", v);
    135.                 oldJsonMap.put(k, differenceMap);
    136.             }
    137.         });
    138.         //2.统一oldJsonMap中newMap不存在的数据的数据结构，便于解析
    139.         oldJsonMap.forEach((k, v) -> {
    140.             if (!(v instanceof Map)) {
    141.                 Map differenceMap = new HashMap<>();
    142.                 differenceMap.put("oldValue", v);
    143.                 differenceMap.put("newValue", "no exists " + k);
    144.                 oldJsonMap.put(k, differenceMap);
    145.             }
    146.         });
    147.         return oldJsonMap;
    148.     }
    149.  
    150.     /**
    151.      * 将已经找出不同数据的map根据key的层级结构封装成json返回
    152.      *
    153.      * @param map
    154.      * @return
    155.      */
    156.     private String convertMapToJson(Map map) {
    157.         JSONObject resultJSONObject = new JSONObject();
    158.         for (Iterator> it = map.entrySet().iterator(); it.hasNext(); ) {
    159.             Map.Entry item = it.next();
    160.             String key = item.getKey();
    161.             Object value = item.getValue();
    162.             String[] paths = key.split("\\.");
    163.             int i = 0;
    164.             //用於深度標識對象
    165.             Object remarkObject = null;
    166.             int indexAll = paths.length - 1;
    167.             while (i <= paths.length - 1) {
    168.                 String path = paths[i];
    169.                 if (i == 0) {
    170.                     //初始化对象标识
    171.                     if (resultJSONObject.containsKey(path)) {
    172.                         remarkObject = resultJSONObject.get(path);
    173.                     } else {
    174.                         if (indexAll > i) {
    175.                             if (paths[i + 1].matches("\\[[0-9]+\\]")) {
    176.                                 remarkObject = new JSONArray();
    177.                             } else {
    178.                                 remarkObject = new JSONObject();
    179.                             }
    180.                             resultJSONObject.put(path, remarkObject);
    181.                         } else {
    182.                             resultJSONObject.put(path, value);
    183.                         }
    184.                     }
    185.                     i++;
    186.                     continue;
    187.                 }
    188.                 //匹配集合对象
    189.                 if (path.matches("\\[[0-9]+\\]")) {
    190.                     int startIndex = path.lastIndexOf("[");
    191.                     int endIndext = path.lastIndexOf("]");
    192.                     int index = Integer.parseInt(path.substring(startIndex + 1, endIndext));
    193.                     if (indexAll > i) {
    194.                         if (paths[i + 1].matches("\\[[0-9]+\\]")) {
    195.                             while (((JSONArray) remarkObject).size() <= index) {
    196.                                 if (((JSONArray) remarkObject).size() == index) {
    197.                                     ((JSONArray) remarkObject).add(index, new JSONArray());
    198.                                 } else {
    199.                                     ((JSONArray) remarkObject).add(null);
    200.                                 }
    201.                             }
    202.                         } else {
    203.                             while (((JSONArray) remarkObject).size() <= index) {
    204.                                 if (((JSONArray) remarkObject).size() == index) {
    205.                                     ((JSONArray) remarkObject).add(index, new JSONObject());
    206.                                 } else {
    207.                                     ((JSONArray) remarkObject).add(null);
    208.                                 }
    209.                             }
    210.                         }
    211.                         remarkObject = ((JSONArray) remarkObject).get(index);
    212.                     } else {
    213.                         while (((JSONArray) remarkObject).size() <= index) {
    214.                             if (((JSONArray) remarkObject).size() == index) {
    215.                                 ((JSONArray) remarkObject).add(index, value);
    216.                             } else {
    217.                                 ((JSONArray) remarkObject).add(null);
    218.                             }
    219.                         }
    220.                     }
    221.                 } else {
    222.                     if (indexAll > i) {
    223.                         if (paths[i + 1].matches("\\[[0-9]+\\]")) {
    224.                             if (!((JSONObject) remarkObject).containsKey(path)) {
    225.                                 ((JSONObject) remarkObject).put(path, new JSONArray());
    226.                             }
    227.                         } else {
    228.                             if (!((JSONObject) remarkObject).containsKey(path)) {
    229.                                 ((JSONObject) remarkObject).put(path, new JSONObject());
    230.                             }
    231.                         }
    232.                         remarkObject = ((JSONObject) remarkObject).get(path);
    233.                     } else {
    234.                         ((JSONObject) remarkObject).put(path, value);
    235.                     }
    236.                 }
    237.                 i++;
    238.             }
    239.         }
    240.         return JSON.toJSONString(resultJSONObject);
    241.     }
    242.  
    243.     public boolean isSort() {
    244.         return isSort;
    245.     }
    246.  
    247.     public void setSort(boolean sort) {
    248.         isSort = sort;
    249.     }
    250.  
    251.     public static void main(String[] args) {
    252.         String oldStr = "{\"abilityLevel\":\"2020101240000000000002\",\"activityId\":\"202208301413310000412\",\"addLibTime\":1662083360000,\"ansKnowModelIds\":\"1#201812051814150000475\",\"answer\":\"AB\",\"ascriptionItemLib\":\"0\",\"attributeList\":[{\"content\":\"
      A
      \",\"id\":\"202209020949170005783\",\"itemId\":\"202209020949150001521\",\"knowModelRelId\":\"201812051814150000475\",\"name\":\"A\",\"sort\":1,\"type\":\"option\"},{\"content\":\"
      B
      \",\"id\":\"202209020949170005784\",\"itemId\":\"202209020949150001521\",\"name\":\"B\",\"sort\":2,\"type\":\"option\"},{\"content\":\"
      C
      \",\"id\":\"202209020949170005785\",\"itemId\":\"202209020949150001521\",\"name\":\"C\",\"sort\":3,\"type\":\"option\"},{\"content\":\"
      D
      \",\"id\":\"202209020949170005786\",\"itemId\":\"202209020949150001521\",\"name\":\"D\",\"sort\":4,\"type\":\"option\"},{\"content\":\"11\",\"createTime\":1662083368000,\"createTimeString\":\"2022-09-02 09:49:28\",\"creater\":\"10001\",\"id\":\"202209020949170005787\",\"itemId\":\"202209020949150001521\",\"name\":\"大纲依据\",\"searchFlag\":\"1\",\"sort\":1,\"subItemTypeAttrId\":\"100041\",\"type\":\"expandAttr\"},{\"content\":\"11\",\"createTime\":1662083370000,\"createTimeString\":\"2022-09-02 09:49:30\",\"creater\":\"10001\",\"id\":\"202209020949280005788\",\"itemId\":\"202209020949150001521\",\"name\":\"教材依据\",\"searchFlag\":\"1\",\"sort\":2,\"subItemTypeAttrId\":\"100042\",\"type\":\"expandAttr\"},{\"content\":\"11\",\"createTime\":1662083371000,\"createTimeString\":\"2022-09-02 09:49:31\",\"creater\":\"10001\",\"id\":\"202209020949290005789\",\"itemId\":\"202209020949150001521\",\"name\":\"关键字\",\"searchFlag\":\"1\",\"sort\":3,\"subItemTypeAttrId\":\"100043\",\"type\":\"expandAttr\"}],\"auditCount\":0,\"auditStatus\":0,\"childItemList\":[],\"createTime\":1662083350000,\"createTimeString\":\"2022-09-02 09:49:10\",\"creater\":\"10001\",\"delFlag\":\"0\",\"difficult\":\"3\",\"id\":\"202209020949150001521\",\"isComposite\":0,\"isTopVersion\":0,\"itemCode\":\"KJCJ202209020949140001501\",\"itemContent\":\"
      2.按照并购双方行业相关性划分，判断并购类型（横向并购or混合并购）
      \",\"itemKnowledgeList\":[{\"id\":\"202209020949300001537\",\"itemId\":\"202209020949150001521\",\"knowledgeId\":\"1240004\",\"knowledgeStr\":\"2020年经济法基础/第一章总论/第一节法律基础/一、法和法律/（一）法和法律的概念\",\"level\":\"1\",\"pid\":\"202209020946580001519\"}],\"itemLevel\":1,\"itemSource\":\"202208301413310000412\",\"itemTypeId\":\"4\",\"itemVersion\":\"1\",\"keyWord\":\"\",\"knowledgeId\":\"1240004\",\"knowledgeStr\":\"2020年经济法基础/第一章总论/第一节法律基础/一、法和法律/（一）法和法律的概念\",\"knowledgeSyllabusName\":\"2020年经济法基础\",\"lockStatus\":1,\"modifyChlidItems\":[],\"paperCount\":0,\"paperItemRelation\":{},\"paperStructure\":{},\"parentId\":\"202209020946580001519\",\"processedItemContent\":\"
      2.按照并购双方行业相关性划分，判断并购类型（横向并购or混合并购）
      \",\"score\":2,\"sort\":2,\"sourceType\":\"2\",\"structId\":\"\",\"subItemTypeId\":\"20180228155501000004\",\"subjectId\":\"4\",\"updateTime\":1662083350000,\"updateTimeString\":\"2022-09-02 09:49:10\",\"updater\":\"10001\"}"      ;
    253.         String newStr = "{\"abilityLevel\":\"2020101240000000000002\",\"activityId\":\"202208301413310000412\",\"addLibTime\":1662083360000,\"analysis\":\"\",\"ansKnowModelIds\":\"1#201812051814150000475\",\"answer\":\"AB\",\"ascriptionItemLib\":\"0\",\"attributeList\":[{\"content\":\"
      A
      \",\"id\":\"202209021135210005855\",\"itemId\":\"202209020949150001521\",\"knowModelRelId\":\"201812051814150000475\",\"name\":\"A\",\"sort\":1,\"type\":\"option\"},{\"content\":\"
      B
      \",\"id\":\"202209021135210005856\",\"itemId\":\"202209020949150001521\",\"name\":\"B\",\"sort\":2,\"type\":\"option\"},{\"content\":\"
      C
      \",\"id\":\"202209021135210005857\",\"itemId\":\"202209020949150001521\",\"name\":\"C\",\"sort\":3,\"type\":\"option\"},{\"content\":\"
      D
      \",\"id\":\"202209021135210005858\",\"itemId\":\"202209020949150001521\",\"name\":\"D\",\"sort\":4,\"type\":\"option\"},{\"content\":\"11\",\"createTime\":1662089721000,\"createTimeString\":\"2022-09-02 11:35:21\",\"creater\":\"10001\",\"id\":\"202209021135210005859\",\"itemId\":\"202209020949150001521\",\"name\":\"大纲依据\",\"searchFlag\":\"1\",\"sort\":1,\"subItemTypeAttrId\":\"100041\",\"type\":\"expandAttr\"},{\"content\":\"11\",\"createTime\":1662089721000,\"createTimeString\":\"2022-09-02 11:35:21\",\"creater\":\"10001\",\"id\":\"202209021135210005860\",\"itemId\":\"202209020949150001521\",\"name\":\"教材依据\",\"searchFlag\":\"1\",\"sort\":2,\"subItemTypeAttrId\":\"100042\",\"type\":\"expandAttr\"},{\"content\":\"11\",\"createTime\":1662089722000,\"createTimeString\":\"2022-09-02 11:35:22\",\"creater\":\"10001\",\"id\":\"202209021135210005861\",\"itemId\":\"202209020949150001521\",\"name\":\"关键字\",\"searchFlag\":\"1\",\"sort\":3,\"subItemTypeAttrId\":\"100043\",\"type\":\"expandAttr\"}],\"auditCount\":0,\"auditStatus\":0,\"childItemList\":[],\"createTime\":1662083350000,\"createTimeString\":\"2022-09-02 09:49:10\",\"creater\":\"10001\",\"delFlag\":\"0\",\"difficult\":\"5\",\"id\":\"202209020949150001521\",\"isComposite\":0,\"isTopVersion\":0,\"itemCode\":\"KJCJ202209020949140001501\",\"itemContent\":\"
      2.按照并购双方行业相关性划分，判断并购类型（横向并购or混合并购）
      \",\"itemKnowledgeList\":[{\"id\":\"202209021135230001557\",\"itemId\":\"202209020949150001521\",\"knowledgeId\":\"1240004\",\"knowledgeStr\":\"2020年经济法基础/第一章总论/第一节法律基础/一、法和法律/（一）法和法律的概念\",\"level\":\"1\",\"pid\":\"202209020946580001519\"}],\"itemLevel\":1,\"itemSource\":\"202208301413310000412\",\"itemTypeId\":\"4\",\"itemVersion\":\"2\",\"keyWord\":\"\",\"knowledgeId\":\"1240004\",\"knowledgeStr\":\"2020年经济法基础/第一章总论/第一节法律基础/一、法和法律/（一）法和法律的概念\",\"knowledgeSyllabusName\":\"2020年经济法基础\",\"lockStatus\":1,\"modifyChlidItems\":[],\"paperCount\":0,\"paperItemRelation\":{},\"paperStructure\":{},\"parentId\":\"202209020946580001519\",\"processedItemContent\":\"
      2.按照并购双方行业相关性划分，判断并购类型（横向并购or混合并购）
      \",\"score\":2,\"sort\":2,\"sourceType\":\"2\",\"structId\":\"\",\"subItemTypeId\":\"20180228155501000004\",\"subjectId\":\"4\",\"updateTime\":1662089720000,\"updateTimeString\":\"2022-09-02 11:35:20\",\"updater\":\"10001\"}"      ;
    254.         System.out.println(new JsonCompareUtils().compare2Json(oldStr, newStr));
    255.         System.out.println("\n========测试复杂json的比对============");
    256.     }
    257. }

    JsonAndMapSortUtils 用于jsonArray排序

    1. import com.alibaba.fastjson.JSONArray;
    2. import com.alibaba.fastjson.JSONObject;
    3. import sun.misc.ASCIICaseInsensitiveComparator;
    4.  
    5. import java.util.*;
    6.  
    7. public class JsonAndMapSortUtils {
    8.  
    9.     /**
    10.      * map排序
    11.      * @param map
    12.      * @param keySort
    13.      * @param 
    14.      * @param 
    15.      * @return
    16.      */
    17.     public static  List mapByKeyToSort(Map map , final Comparator keySort){
    18.         List> entryList = new ArrayList<>(map.entrySet());
    19.         Collections.sort(entryList, (o1, o2) -> keySort.compare(o1.getKey(),o2.getKey()));
    20.         System.out.println("排序=====");
    21.         entryList.forEach(m->{
    22.             System.out.println(m.getKey()+"===>"+m.getValue());
    23.         });
    24.         return entryList;
    25.     }
    26.  
    27.     /**
    28.      * JSONArray排序
    29.      * @param jsonArray
    30.      * @param fildName
    31.      * @param isAsc
    32.      * @return
    33.      */
    34.     public static JSONArray jsonArrayToSort(JSONArray jsonArray,final String fildName,final boolean isAsc){
    35.         JSONArray afterSortJsonArray = new JSONArray();
    36.         List objectList = new ArrayList<>();
    37.         jsonArray.forEach(obj ->{
    38.             objectList.add((JSONObject)obj);
    39.         });
    40.         Collections.sort(objectList, (o1, o2) -> {
    41.             String fildValueA = o1.getString(fildName);
    42.             String fildValueB = o2.getString(fildName);
    43.             if (isAsc){
    44.                 return fildValueA.compareTo(fildValueB);
    45.             }
    46.             return fildValueB.compareTo(fildValueA);
    47.         });
    48.         objectList.forEach(obj->{
    49.             afterSortJsonArray.add(obj);
    50.         });
    51.         return afterSortJsonArray;
    52.     }
    53.  
    54.     /**
    55.      *准备map测试数据
    56.      */
    57.     public static Map getMapData(){
    58.         LinkedHashMap map = new LinkedHashMap<>();
    59.         map.put("key1","测试1");
    60.         map.put("key3","测试3");
    61.         map.put("key5","测试5");
    62.         map.put("key2","测试2");
    63.         map.put("key4","测试4");
    64.         return map;
    65.     }
    66.     /**
    67.      *准备json测试数据
    68.      */
    69.     public static JSONArray getJsonArrayData(){
    70.         JSONArray jsonArray = new JSONArray();
    71.         JSONObject jsonObject1 = new JSONObject();
    72.         jsonObject1.put("userId","1001");
    73.         jsonObject1.put("name","测试1");
    74.         jsonArray.add(jsonObject1);
    75.  
    76.         JSONObject jsonObject3 = new JSONObject();
    77.         jsonObject3.put("userId","1003");
    78.         jsonObject3.put("name","测试3");
    79.         jsonArray.add(jsonObject3);
    80.  
    81.         JSONObject jsonObject2 = new JSONObject();
    82.         jsonObject2.put("userId","1002");
    83.         jsonObject2.put("name","测试2");
    84.         jsonArray.add(jsonObject2);
    85.  
    86.         return jsonArray;
    87.     }
    88.      
    89.     public static void main(String[] args) {
    90.         Map map = JsonAndMapSortUtils.getMapData();
    91.         JSONArray jsonArray = JsonAndMapSortUtils.getJsonArrayData();
    92.         List afterSortMap = JsonAndMapSortUtils.mapByKeyToSort(map,new ASCIICaseInsensitiveComparator());
    93.  
    94.         JSONArray afterSortJsonArray_isAsc = JsonAndMapSortUtils.jsonArrayToSort(jsonArray,"userId",true);
    95.         JSONArray afterSortJsonArray_noAsc = JsonAndMapSortUtils.jsonArrayToSort(jsonArray,"userId",false);
    96.  
    97.         System.out.println("map排序前："+map);
    98.         System.out.println("map排序后："+afterSortMap+"\n");
    99.  
    100.         System.out.println("JsonArray排序前："+jsonArray);
    101.         System.out.println("JsonArray排序后==》升序："+afterSortJsonArray_isAsc);
    102.         System.out.println("JsonArray排序后==》降序："+afterSortJsonArray_noAsc);
    103.     }
    104.  
    105. }


    源码走读
    整个源码调用链路如下图，简单来说过程就是：object拆分解析-新旧数据逐个对比-结果信息组装三个步骤

  • 相关阅读:
    QT之QML开发 行列布局，流布局，网格布局
    第12章 - 执行引擎
    vulnhub靶机DC5
    C++ vector 功能强大的数组
    【问题记录】解决Git上传文件到GitHub时收到 “GH001: Large files detected” 错误信息！
    Could not resolve dependencies for project
    C++模拟OpenGL库——图片处理及纹理系统（三)：图片缩放操作：简单插值&二次线性插值
    《深入浅出.NET框架设计与实现》笔记6.2——ASP.NET Core应用程序多种运行模式之二——IIS 服务承载
    SQL Server教程 - SQL Server 安全管理（SECURITY）
    SQL interview Questions
  • 原文地址：https://blog.csdn.net/hnhygkx/article/details/132707556