上一篇笔记仅是记录了一下简单的关联查询，根据笔记中的场景：将某一车辆关联的耗损记录全部放在了一个字段当中。不知道现在中有没有这种场景，我们的应用中没有类似的场景，可能我们更关注的是某车辆的总耗损金额和总营收金额、总里程数等，因此这篇笔记记录一下怎么得到这些数据。要想获取这些记录我们首先想到的就是先按照车辆ID分组之后再对指定字段求和，可能是先入为主的原因（有了上一篇笔记），我没有按照传统的思路走下去，而是想着看看能不能在上一篇笔记的基础之上得到想要的结果。

　　我们沿着这条路在分析一下，车辆相关的耗损和营收都可以放到一个字段中。也就是说我们不用分组了，车辆相关的耗损和营收记录都冗余到了车辆信息记录中，那么接下来就是对数组中的某一字段或者多个进行求和了……查了半天并没有找到类似$sum这样的聚合管道可以对数组中的字段求和，不过得益于mongodb管道的强大，用另外一个管道间接实现了这个功能。

  1. db.getCollection('FormInstace').aggregate([
  2.     {
  3.         $match: {
  4.             "_id": { $in: ["1","2","3"] },
  5.             "FormItems.key": { $ne: null }
  6.         }
  7.     },
  8.     {
  9.         $addFields: {
  10.             FormValueObj: {
  11.                 $arrayToObject: {
  12.                     $map: {
  13.                         input: "$FormItems",
  14.                         as: "field",
  15.                         in: [ "$$field.key", "$$field.value" ]
  16.                     }
  17.                 }
  18.             }
  19.         }
  20.     },
  21.     {
  22.       $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  23.     },
  24.     {
  25.         $project: {
  26.             FormItems:0,
  27.             FormValueObj:0
  28.         }
  29.     },
  30.     {
  31.         $lookup:{
  32.             from:"FormInstace",
  33.             let: { tempMainRelationKey: "$_id" },
  34.             pipeline:[
  35.                 {
  36.                     $match: {
  37.                         FormId: "507048044944692000",
  38.                         "FormItems.key": { $ne: null }
  39.                     }
  40.                 },
  41.                 {
  42.                     $addFields: {
  43.                         FormValueObj: {
  44.                             $arrayToObject: {
  45.                                 $map: {
  46.                                     input: "$FormItems",
  47.                                     as: "field",
  48.                                     in: [ "$$field.key", "$$field.value" ]
  49.                                 }
  50.                             }
  51.                         }
  52.                     }
  53.                 },
  54.                 {
  55.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  56.                 },
  57.                 {
  58.                     $project: {
  59.                         FormItems:0,
  60.                         FormValueObj:0
  61.                     }
  62.                 },
  63.                 { $match:
  64.                      { $expr:
  65.                             { $eq: [ "$1572493552001.id","$$tempMainRelationKey" ] }
  66.                      }
  67.                 },
  68.             ],
  69.             as:'carWastage'
  70.         }
  71.     },
  72.     {
  73.         $lookup:{
  74.             from:"FormInstace",
  75.             let: { tempMainRelationKey: "$_id" },
  76.             pipeline:[
  77.                 {
  78.                     $match: {
  79.                         FormId: "507048044944693000",
  80.                         "FormItems.key": { $ne: null }
  81.                     }
  82.                 },
  83.                 {
  84.                     $addFields: {
  85.                         FormValueObj: {
  86.                             $arrayToObject: {
  87.                                 $map: {
  88.                                     input: "$FormItems",
  89.                                     as: "field",
  90.                                     in: [ "$$field.key", "$$field.value" ]
  91.                                 }
  92.                             }
  93.                         }
  94.                     }
  95.                 },
  96.                 {
  97.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  98.                 },
  99.                 {
  100.                     $project: {
  101.                         FormItems:0,
  102.                         FormValueObj:0
  103.                     }
  104.                 },
  105.                 { $match:
  106.                      { $expr:
  107.                             { $eq: [ "$1572493553001.id","$$tempMainRelationKey" ] }
  108.                      }
  109.                 },
  110.             ],
  111.             as:'carRevenue'
  112.         }
  113.     },
  114.     {
  115.         $addFields: {
  116.             carWastageStatistics: {
  117.                $reduce: {
  118.                   input: "$carWastage",
  119.                   initialValue: {wastageMoney:0},
  120.                   in: {
  121.                       wastageMoney:{ $add : ["$$value.wastageMoney", "$$this.1572493552005"] }
  122.                   }
  123.                }
  124.             }
  125.         }
  126.     },
  127.     {
  128.         $addFields: {
  129.             carRevenueStatistics: {
  130.                $reduce: {
  131.                   input: "$carRevenue",
  132.                   initialValue: {revenueMoney:0,mileage:0},
  133.                   in: {
  134.                     revenueMoney:{$add : ["$$value.revenueMoney", "$$this.1572493553005"]},
  135.                     mileage:{$add : ["$$value.mileage", "$$this.1572493553006"]}
  136.                   }
  137.                }
  138.             }
  139.         }
  140.     }
  141. ]);

　　这次统计查询就查出了某些车辆的总耗损金额和总营收金额、总里程数；只不过将结果放到对象中了（方便统计一个表中的多个字段），但是现在看不到具体的结果，将代码在修改一下，看一下结果

  1. db.getCollection('FormInstace').aggregate([
  2.     {
  3.         $match: {
  4.             "_id": { $in: ["1","2","3"] },
  5.             "FormItems.key": { $ne: null }
  6.         }
  7.     },
  8.     {
  9.         $addFields: {
  10.             FormValueObj: {
  11.                 $arrayToObject: {
  12.                     $map: {
  13.                         input: "$FormItems",
  14.                         as: "field",
  15.                         in: [ "$$field.key", "$$field.value" ]
  16.                     }
  17.                 }
  18.             }
  19.         }
  20.     },
  21.     {
  22.       $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  23.     },
  24.     {
  25.         $project: {
  26.             FormItems:0,
  27.             FormValueObj:0
  28.         }
  29.     },
  30.     {
  31.         $lookup:{
  32.             from:"FormInstace",
  33.             let: { tempMainRelationKey: "$_id" },
  34.             pipeline:[
  35.                 {
  36.                     $match: {
  37.                         FormId: "507048044944692000",
  38.                         "FormItems.key": { $ne: null }
  39.                     }
  40.                 },
  41.                 {
  42.                     $addFields: {
  43.                         FormValueObj: {
  44.                             $arrayToObject: {
  45.                                 $map: {
  46.                                     input: "$FormItems",
  47.                                     as: "field",
  48.                                     in: [ "$$field.key", "$$field.value" ]
  49.                                 }
  50.                             }
  51.                         }
  52.                     }
  53.                 },
  54.                 {
  55.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  56.                 },
  57.                 {
  58.                     $project: {
  59.                         FormItems:0,
  60.                         FormValueObj:0
  61.                     }
  62.                 },
  63.                 { $match:
  64.                      { $expr:
  65.                             { $eq: [ "$1572493552001.id","$$tempMainRelationKey" ] }
  66.                      }
  67.                 },
  68.             ],
  69.             as:'carWastage'
  70.         }
  71.     },
  72.     {
  73.         $lookup:{
  74.             from:"FormInstace",
  75.             let: { tempMainRelationKey: "$_id" },
  76.             pipeline:[
  77.                 {
  78.                     $match: {
  79.                         FormId: "507048044944693000",
  80.                         "FormItems.key": { $ne: null }
  81.                     }
  82.                 },
  83.                 {
  84.                     $addFields: {
  85.                         FormValueObj: {
  86.                             $arrayToObject: {
  87.                                 $map: {
  88.                                     input: "$FormItems",
  89.                                     as: "field",
  90.                                     in: [ "$$field.key", "$$field.value" ]
  91.                                 }
  92.                             }
  93.                         }
  94.                     }
  95.                 },
  96.                 {
  97.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  98.                 },
  99.                 {
  100.                     $project: {
  101.                         FormItems:0,
  102.                         FormValueObj:0
  103.                     }
  104.                 },
  105.                 { $match:
  106.                      { $expr:
  107.                             { $eq: [ "$1572493553001.id","$$tempMainRelationKey" ] }
  108.                      }
  109.                 },
  110.             ],
  111.             as:'carRevenue'
  112.         }
  113.     },
  114.     {
  115.         $addFields: {
  116.             carWastage_Money: {
  117.                $reduce: {
  118.                   input: "$carWastage",
  119.                   initialValue: 0,
  120.                   in: { $add : ["$$value", "$$this.1572493552005"] }
  121.                }
  122.             }
  123.         }
  124.     },
  125.     {
  126.         $addFields: {
  127.             carRevenue_Money: {
  128.                $reduce: {
  129.                   input: "$carRevenue",
  130.                   initialValue: 0,
  131.                   in: { $add : ["$$value", "$$this.1572493553005"] }
  132.                }
  133.             }
  134.         }
  135.     },
  136.     {
  137.         $addFields: {
  138.             carRevenue_Mileage: {
  139.                $reduce: {
  140.                   input: "$carRevenue",
  141.                   initialValue: 0,
  142.                   in: { $add : ["$$value", "$$this.1572493553006"] }
  143.                }
  144.             }
  145.         }
  146.     }
  147. ]);

　　这样就一目了然了。统计结果对不对呢？我们用传统的分组之后再求和在查询一下，将结果做一下对比（顺便记录一下，分组求和）

  1. db.getCollection('FormInstace').aggregate([
  2.     {
  3.         $match: {
  4.             "FormId":"507048044944692000",
  5.             "FormItems.key": { $ne: null }
  6.         }
  7.     },
  8.     {
  9.         $addFields: {
  10.             FormValueObj: {
  11.                 $arrayToObject: {
  12.                     $map: {
  13.                         input: "$FormItems",
  14.                         as: "field",
  15.                         in: [ "$$field.key", "$$field.value" ]
  16.                     }
  17.                 }
  18.             }
  19.         }
  20.     },
  21.     {
  22.         $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  23.     },
  24.     {
  25.         $match: {
  26.             "1572493552001.id": { $in:["1","2","3"]}
  27.         }
  28.     },
  29.     {
  30.         $project: {
  31.             FormItems:0,
  32.             FormValueObj:0
  33.         }
  34.     },
  35.     {
  36.         $group:{
  37.            _id: "$1572493552001.id",
  38.            wastageMoney: { $sum: "$1572493552005"}
  39.         }
  40.     },
  41.     { $sort : { _id: 1 } }
  42. ]);

统计指定车辆的耗损总额

  1. db.getCollection('FormInstace').aggregate([
  2.     {
  3.         $match: {
  4.             "FormId":"507048044944693000",
  5.             "FormItems.key": { $ne: null }
  6.         }
  7.     },
  8.     {
  9.         $addFields: {
  10.             FormValueObj: {
  11.                 $arrayToObject: {
  12.                     $map: {
  13.                         input: "$FormItems",
  14.                         as: "field",
  15.                         in: [ "$$field.key", "$$field.value" ]
  16.                     }
  17.                 }
  18.             }
  19.         }
  20.     },
  21.     {
  22.         $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  23.     },
  24.     {
  25.         $match: {
  26.             "1572493553001.id": { $in:["1","2","3"]}
  27.         }
  28.     },
  29.     {
  30.         $project: {
  31.             FormItems:0,
  32.             FormValueObj:0
  33.         }
  34.     },
  35.     {
  36.         $group:{
  37.            _id: "$1572493553001.id",
  38.            wastageMoney: { $sum: "$1572493553005"},
  39.            mileage: { $sum: "$1572493553006"}
  40.         }
  41.     },
  42.     { $sort : { _id: 1 } }
  43. ]);

统计指定车辆的营收总额和里程数

　　对比两次查询结果，两次不同的统计方式的结果相同。这样就放心了。好了就到这里了。

　　********************以下是修改补充部分********************

　　打脸了，好疼，┭┮﹏┭┮……曾记得以前使用$sum对数组中的某一属性求和时没有得到预期的结果，这篇笔记写完之后，打算在按照常规思路（$unwind、$group、$sum等）在写一种查询方式，但是但是但是测试的时候发现$sum好使了，写放一下代码

  1. db.getCollection('FormInstace').aggregate([
  2.     {
  3.         $match: {
  4.             "_id": { $in: ["1","2","3"] },
  5.             "FormItems.key": { $ne: null }
  6.         }
  7.     },
  8.     {
  9.         $addFields: {
  10.             FormValueObj: {
  11.                 $arrayToObject: {
  12.                     $map: {
  13.                         input: "$FormItems",
  14.                         as: "field",
  15.                         in: [ "$$field.key", "$$field.value" ]
  16.                     }
  17.                 }
  18.             }
  19.         }
  20.     },
  21.     {
  22.       $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  23.     },
  24.     {
  25.         $project: {
  26.             FormItems:0,
  27.             FormValueObj:0
  28.         }
  29.     },
  30.     {
  31.         $lookup:{
  32.             from:"FormInstace",
  33.             let: { tempMainRelationKey: "$_id" },
  34.             pipeline:[
  35.                 {
  36.                     $match: {
  37.                         FormId: "507048044944692000",
  38.                         "FormItems.key": { $ne: null }
  39.                     }
  40.                 },
  41.                 {
  42.                     $addFields: {
  43.                         FormValueObj: {
  44.                             $arrayToObject: {
  45.                                 $map: {
  46.                                     input: "$FormItems",
  47.                                     as: "field",
  48.                                     in: [ "$$field.key", "$$field.value" ]
  49.                                 }
  50.                             }
  51.                         }
  52.                     }
  53.                 },
  54.                 {
  55.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  56.                 },
  57.                 {
  58.                     $project: {
  59.                         FormItems:0,
  60.                         FormValueObj:0
  61.                     }
  62.                 },
  63.                 { $match:
  64.                      { $expr:
  65.                             { $eq: [ "$1572493552001.id","$$tempMainRelationKey" ] }
  66.                      }
  67.                 },
  68.             ],
  69.             as:'carWastage'
  70.         }
  71.     },
  72.     {
  73.         $lookup:{
  74.             from:"FormInstace",
  75.             let: { tempMainRelationKey: "$_id" },
  76.             pipeline:[
  77.                 {
  78.                     $match: {
  79.                         FormId: "507048044944693000",
  80.                         "FormItems.key": { $ne: null }
  81.                     }
  82.                 },
  83.                 {
  84.                     $addFields: {
  85.                         FormValueObj: {
  86.                             $arrayToObject: {
  87.                                 $map: {
  88.                                     input: "$FormItems",
  89.                                     as: "field",
  90.                                     in: [ "$$field.key", "$$field.value" ]
  91.                                 }
  92.                             }
  93.                         }
  94.                     }
  95.                 },
  96.                 {
  97.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  98.                 },
  99.                 {
  100.                     $project: {
  101.                         FormItems:0,
  102.                         FormValueObj:0
  103.                     }
  104.                 },
  105.                 { $match:
  106.                      { $expr:
  107.                             { $eq: [ "$1572493553001.id","$$tempMainRelationKey" ] }
  108.                      }
  109.                 },
  110.             ],
  111.             as:'carRevenue'
  112.         }
  113.     },
  114.     {
  115.         $addFields: {
  116.             "carWastageStatistics.wastageMoney": { $sum: "$carWastage.1572493552005"},
  117.             "carRevenueStatistics.revenueMoney": { $sum: "$carRevenue.1572493553005"},
  118.             "carRevenueStatistics.mileage": { $sum: "$carRevenue.1572493553006"}
  119.         }
  120.     }
  121. ]);

在文中第一个查询语句基础上修改

  1. db.getCollection('FormInstace').aggregate([
  2.     {
  3.         $match: {
  4.             "_id": { $in: ["1","2","3"] },
  5.             "FormItems.key": { $ne: null }
  6.         }
  7.     },
  8.     {
  9.         $addFields: {
  10.             FormValueObj: {
  11.                 $arrayToObject: {
  12.                     $map: {
  13.                         input: "$FormItems",
  14.                         as: "field",
  15.                         in: [ "$$field.key", "$$field.value" ]
  16.                     }
  17.                 }
  18.             }
  19.         }
  20.     },
  21.     {
  22.       $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  23.     },
  24.     {
  25.         $project: {
  26.             FormItems:0,
  27.             FormValueObj:0
  28.         }
  29.     },
  30.     {
  31.         $lookup:{
  32.             from:"FormInstace",
  33.             let: { tempMainRelationKey: "$_id" },
  34.             pipeline:[
  35.                 {
  36.                     $match: {
  37.                         FormId: "507048044944692000",
  38.                         "FormItems.key": { $ne: null }
  39.                     }
  40.                 },
  41.                 {
  42.                     $addFields: {
  43.                         FormValueObj: {
  44.                             $arrayToObject: {
  45.                                 $map: {
  46.                                     input: "$FormItems",
  47.                                     as: "field",
  48.                                     in: [ "$$field.key", "$$field.value" ]
  49.                                 }
  50.                             }
  51.                         }
  52.                     }
  53.                 },
  54.                 {
  55.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  56.                 },
  57.                 {
  58.                     $project: {
  59.                         FormItems:0,
  60.                         FormValueObj:0
  61.                     }
  62.                 },
  63.                 { $match:
  64.                      { $expr:
  65.                             { $eq: [ "$1572493552001.id","$$tempMainRelationKey" ] }
  66.                      }
  67.                 },
  68.             ],
  69.             as:'carWastage'
  70.         }
  71.     },
  72.     {
  73.         $lookup:{
  74.             from:"FormInstace",
  75.             let: { tempMainRelationKey: "$_id" },
  76.             pipeline:[
  77.                 {
  78.                     $match: {
  79.                         FormId: "507048044944693000",
  80.                         "FormItems.key": { $ne: null }
  81.                     }
  82.                 },
  83.                 {
  84.                     $addFields: {
  85.                         FormValueObj: {
  86.                             $arrayToObject: {
  87.                                 $map: {
  88.                                     input: "$FormItems",
  89.                                     as: "field",
  90.                                     in: [ "$$field.key", "$$field.value" ]
  91.                                 }
  92.                             }
  93.                         }
  94.                     }
  95.                 },
  96.                 {
  97.                   $replaceRoot: { newRoot: { $mergeObjects: [ "$FormValueObj", "$$ROOT" ] } }
  98.                 },
  99.                 {
  100.                     $project: {
  101.                         FormItems:0,
  102.                         FormValueObj:0
  103.                     }
  104.                 },
  105.                 { $match:
  106.                      { $expr:
  107.                             { $eq: [ "$1572493553001.id","$$tempMainRelationKey" ] }
  108.                      }
  109.                 },
  110.             ],
  111.             as:'carRevenue'
  112.         }
  113.     },
  114.     {
  115.         $addFields: {
  116.             "carWastage_Money": { $sum: "$carWastage.1572493552005"},
  117.             "carRevenue_Money": { $sum: "$carRevenue.1572493553005"},
  118.             "carRevenue_Mileage": { $sum: "$carRevenue.1572493553006"},
  119.         }
  120.     }
  121. ]);

在文中第二个查询语句基础上修改

　　下面看一下对比图，看一下改动情况

　　再看一下，执行结果截图

　　和上面的结果一模一样……对mongodb管道认识不够深入，应用中有需求就是查一下，太片面了，没有验证的东西千万别乱说，切记切记切记！！！特尴尬，￣□￣｜｜

表单生成器(Form Builder)之mongodb表单数据查询——统计查询求和的更多相关文章

  1. 表单生成器(Form Builder)之mongodb表单数据——整理数据

    在上篇笔记中,为车辆信息表.车辆耗损表以及车辆营收表插入了一些数据.之后便是查询了,重点也在查询……按照之前定好的数据结构,如果查询mongodb document的最外层比较简单,但是我们的重点应该 ...

  2. 表单生成器(Form Builder)之mongodb表单数据查询——关联查询

    这一篇接着记录一下查询相关的操作.想象一下,如果想要在一张表格中展示某些车辆的耗损和营收情况,我们该怎么处理.车辆.耗损.营收各自存储在一张表中,耗损和营收中冗余了车辆信息……我们便想到了关联查询.m ...

  3. 表单生成器(Form Builder)之mongodb表单数据查询——返回分页数据和总条数

    上一篇笔记将开始定义的存储结构处理了一下,将FormItems数组中的表单项都拿到mongodb document的最外层,和以前的关系型数据类似,之不过好多列都是动态的,不固定,不过这并没有什么影响 ...

  4. 表单生成器(Form Builder)之伪造表单数据番外篇——随机车辆牌照

    前几天记录了一下表单生成器(Form Builder)之表单数据存储结构mongodb篇,之后便想着伪造一些数据.为什么要伪造数据呢?说来惭愧,因为拖拉拽设计表单以及表单对应的列表的PC端和移动端该显 ...

  5. 表单生成器(Form Builder)之伪造表单数据mongodb篇

    这篇文章终于回到了正轨:为mongodb伪造数据.之前的随机数.随机车牌照.随机时间还有这篇笔记中的获取指定长度的中文字符串,都是为这篇笔记做准备.看一下我们的准备(基础代码) // 1.获取指定范围 ...

  6. 表单生成器(Form Builder)之伪造表单数据番外篇——指定范围随机时间

    为了伪造一些尽量真实的假数据,也真是够费劲的.上一篇笔记记录了一下获取一个随机车辆牌照,这篇笔记记录一下怎么获取一个随机时间.这篇就不说那么多废话了,直接上代码 // 获取指定范围的随机数 var g ...

  7. 表单生成器(Form Builder)之表单数据存储结构mongodb篇

    从这篇笔记开始,记录一下表单生成器(Form Builder)相关的一些东西,网上关于他的介绍有很多,这里就不解释了. 开篇说一下如何存储Form Builder生成的数据.

  8. Ext JS4 学习笔记之发送表单（Form）时也将表单下的表格（Grid）数据一同发送的方法

    Ext JS4 学习笔记之发送表单(Form)时也将表单下的表格(Grid)数据一同发送的方法 昨天在开发的时候遇到个小问题,就是如何将Grid的内容与Form一起发送到服务器端.默认情况下,表单(F ...

  9. 表单组件 form fastadmin（生成表单元素）

    Form组件 定义文件位置: /extend/fast/Formphp 通用参数 $name 通常为我们组件的名称(name属性值),我们在后台接收时可以通过这个名称来获取到它所对应的值 $value ...

随机推荐

  1. [TimLinux] JavaScript 模态框可拖动功能实现——jQuery版

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title> ...

  2. UVA-136Ugly numbers

    Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9 ...

  3. html小工具——文章注释编辑器

    在网上阅读文章时,读者时常会想针对某段文字写一些自己的感想,可惜大部分阅读网站并不提供这样的功能,读者往往只能将文本复制到本地或在线的编辑器中编辑注释,之后如果想在其他地方回顾这些注释也必须先本地安装 ...

  4. 6张图说清楚Tomcat原理及请求流程

    前言 很多东西在时序图中体现的已经非常清楚了,没有必要再一步一步的作介绍,本文以图为主,然后对部分内容加以简单解释. 绘制图形使用的工具是 PlantUML + Visual Studio Code ...

  5. ELK 理论小知识

    ELK 是现阶段众多企业单位都在使用的一种日志分析系统,它能够方便的为我们收集你想要的日志并且展示出来 ELK是Elasticsearch.Logstash.Kibana的简称,这三者都是开源软件,通 ...

  6. 《Java基础知识》Java类的基本运行顺序

    我们以下面的类来说明一个基本的 Java 类的运行顺序: public class Demo { private String name; private int age; public Demo() ...

  7. 使用saltstack自动部署K8S

    使用saltstack自动部署K8S 一.环境准备 1.1 规划 1. 操作系统 CentOS-7.x-x86_64. 2. 关闭 iptables 和 SELinux. 3. 所有节点的主机名和 I ...

  8. web前端分享JavaScript到底是什么？特点有哪些？

    web前端分享JavaScript到底是什么?特点有哪些?这也是成为web前端工程师必学的内容.今天为大家分享了这篇关于JavaScript的文章,我们一起来看看. 一.JavaScript是什么? ...

  9. Java 打印Word文档

    本文介绍如何在Java程序中通过物理打印机和虚拟打印机来打印Word文档的方法.文中使用了类库Spire.Doc for Java,可通过官网下载jar文件并导入程序或者直接通过maven仓库安装导入 ...

  10. 庖丁解牛 Activity 启动流程

    前言 这是 Android 9.0 AOSP 系列 的第五篇了,先来回顾一下前面几篇的大致内容. Java 世界的盘古和女娲 -- Zygote 主要介绍了 Android 世界的第一个 Java 进 ...