当前位置：首页 > news >正文

MongoDB - 组合聚合阶段：$group、$match、$limit、$sort、$skip、$project、$count

news 2025/12/20 8:17:15

文章目录

- 1. $group
- 2. $group-> $project
- - - 2.1 $group
    - 2.2 $group-> $project
    - 2.3 SpringBoot 整合 MongoDB
- 3. $match-> $group -> $match
- - - 3.1 $match
    - 3.2 $match-> $group
    - 3.3 $match-> $group-> $match
    - 3.4 SpringBoot 整合 MongoDB
- 4. $match-> $group-> $project-> $sort-> skip-> $limit
- - - 4.1 $match
    - 4.2 $match-> $group
    - 4.3 $match-> $group-> $project
    - 4.4 $match-> $group-> $project-> $sort
    - 4.5 $match-> $group-> $project-> $sort-> $skip
    - 4.5 $match-> $group-> $project-> $sort-> $skip-> $limit
    - 4.6 SpringBoot 整合 MongoDB
- 5. $group-> $project
- - - 5.1 $group 多字段分组聚合
    - 5.2 $group-> $project
    - 5.3 $group-> $project-> $sort
    - 5.4 $group-> $project-> $sort-> $limit
    - 5.5 SpringBoot 整合 MongoDB

根据工作中常见的业务需求，构造了一些场景来练习 mongodb 聚合阶段的使用。

1. $group

$group 根据单个字段对文档进行分组。

构造测试数据：

db.sales.drop()db.sales.insertMany([{ "_id": 1, "product": "A", "category": "Electronics", "quantity": 10, "price": 100 },{ "_id": 2, "product": "B", "category": "Electronics", "quantity": 5, "price": 200 },{ "_id": 3, "product": "C", "category": "Electronics", "quantity": 5, "price": 300 },{ "_id": 4, "product": "D", "category": "Electronics", "quantity": 10, "price": 500 },{ "_id": 5, "product": "A", "category": "Clothing", "quantity": 8, "price": 500},{ "_id": 6, "product": "B", "category": "Clothing", "quantity": 12, "price": 200 },{ "_id": 7, "product": "C", "category": "Clothing", "quantity": 8, "price": 600 },{ "_id": 8, "product": "D", "category": "Clothing", "quantity": 12, "price": 700 }
])

根据 category 字段对文档进行分组并计算每个分组内文档的数量：

db.sales.aggregate([{$group : {_id : "$category",count: { $sum: 1 }}}
])

执行 $group 聚合阶段后输出的文档：

// 1
{"_id": "Clothing","count": 4
}// 2
{"_id": "Electronics","count": 4
}

SpringBoot整合MongoDB实现：

// 输入文档
@Data
@Document(collection = "sales")
public class Sales {@MongoIdprivate int _id;private String product;private String category;private int quantity;private int price;
}// 输出文档
@Data
public class AggregationResult {private int _id;private int count;
}// 聚合操作
@Test
public void aggregateTest() {// $group 聚合阶段GroupOperation group = Aggregation.group("category").count().as("count");// 组合聚合阶段Aggregation aggregation = Aggregation.newAggregation(group);// 执行聚合查询AggregationResults<AggregationResult> results= mongoTemplate.aggregate(aggregation, Sales.class, AggregationResult.class);List<AggregationResult> mappedResults = results.getMappedResults();// 打印结果mappedResults.forEach(System.out::println);//AggregationResult(_id=Clothing, count=4)//AggregationResult(_id=Electronics, count=4)
}

2. $group-> $project

$group 单字段分组 + $project 排除字段 + $project 重命名字段

构造测试数据：

db.sales.drop()db.sales.insertMany([{ "_id": 1, "product": "A", "category": "Electronics", "quantity": 10, "price": 100 },{ "_id": 2, "product": "B", "category": "Electronics", "quantity": 5, "price": 200 },{ "_id": 3, "product": "C", "category": "Electronics", "quantity": 5, "price": 300 },{ "_id": 4, "product": "D", "category": "Electronics", "quantity": 10, "price": 500 },{ "_id": 5, "product": "A", "category": "Clothing", "quantity": 8, "price": 500},{ "_id": 6, "product": "B", "category": "Clothing", "quantity": 12, "price": 200 },{ "_id": 7, "product": "C", "category": "Clothing", "quantity": 8, "price": 600 },{ "_id": 8, "product": "D", "category": "Clothing", "quantity": 12, "price": 700 }
])

2.1 $group

执行 $group 聚合阶段后输出的文档：

db.sales.aggregate([{$group : {_id : "$category",count: { $sum: 1 }}}
])

// 1
{"_id": "Clothing","count": 4
}// 2
{"_id": "Electronics","count": 4
}

2.2 $group-> $project

执行 $g ro u p +$ project 聚合阶段后输出的文档：

db.sales.aggregate([// $group阶段：将聚合管道内的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$category",count: { $sum: 1 }}},// $project阶段：将聚合管道内的文档排除_id字段，并将count字段的名称重命名newCount字段{$project : {_id : 0,newCount: "$count"}}
])

// 1
{"newCount": 4
}// 2
{"newCount": 4
}

2.3 SpringBoot 整合 MongoDB

// 输入文档实体类
@Data
@Document(collection = "sales")
public class Sales {@Idprivate int _id;private String product;private String category;private int quantity;private int price;
}// 输出文档实体类
@Data
public class AggregationResult {private String newCount;
}// 聚合操作
@SpringBootTest
@RunWith(SpringRunner.class)
public class BeanLoadServiceTest {@Autowiredprivate MongoTemplate mongoTemplate;@Testpublic void aggregateTest() {// $group 聚合阶段GroupOperation group = Aggregation.group("category").count().as("count");// $project 聚合阶段ProjectionOperation project = Aggregation.project().andExclude("_id").and("count").as("newCount");// 组合聚合阶段Aggregation aggregation = Aggregation.newAggregation(group,project);// 执行聚合查询AggregationResults<AggregationResult> results= mongoTemplate.aggregate(aggregation, Sales.class, AggregationResult.class);List<AggregationResult> mappedResults = results.getMappedResults();// 打印结果mappedResults.forEach(System.out::println);//AggregationResult(newCount=4)//AggregationResult(newCount=4)}
}

3. $match-> $group -> $match

$match 根据条件筛选文档+ $group 根据单字段分组文档 + $match 筛选分组后的文档

构造测试数据：

db.sales.drop()db.sales.insertMany([{ "_id": 1, "product": "A", "category": "Electronics", "quantity": 10, "price": 100 },{ "_id": 2, "product": "B", "category": "Electronics", "quantity": 5, "price": 200 },{ "_id": 3, "product": "C", "category": "Electronics", "quantity": 5, "price": 300 },{ "_id": 4, "product": "D", "category": "Electronics", "quantity": 10, "price": 500 },{ "_id": 5, "product": "A", "category": "Clothing", "quantity": 8, "price": 500},{ "_id": 6, "product": "B", "category": "Clothing", "quantity": 12, "price": 200 },{ "_id": 7, "product": "C", "category": "Clothing", "quantity": 8, "price": 600 },{ "_id": 8, "product": "D", "category": "Clothing", "quantity": 12, "price": 700 }
])

3.1 $match

执行 $match 聚合阶段输出的文档为：

db.sales.aggregate([// 第一阶段：筛选出 price>=300 的文档{$match : {"price": { $gte: 300 }}}
])

// 1
{"_id": 3,"product": "C","category": "Electronics","quantity": 5,"price": 300
}// 2
{"_id": 4,"product": "D","category": "Electronics","quantity": 10,"price": 500
}// 3
{"_id": 5,"product": "A","category": "Clothing","quantity": 8,"price": 500
}// 4
{"_id": 7,"product": "C","category": "Clothing","quantity": 8,"price": 600
}// 5
{"_id": 8,"product": "D","category": "Clothing","quantity": 12,"price": 700
}

3.2 $match-> $group

执行 $ma t c h +$ group 聚合阶段是输出的文档为：

db.sales.aggregate([// 第一阶段：筛选出 price>=300 的文档{$match : {"price": { $gte: 300 }}},// 第二阶段：将聚合管道内的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$category",count: { $sum: 1 }}}
])

// 1
{"_id": "Clothing","count": 3
}// 2
{"_id": "Electronics","count": 2
}

3.3 $match-> $group-> $match

执行 $ma t c h +$ group+$match 聚合阶段是输出的文档为：

db.sales.aggregate([// 第一阶段：筛选出 price>=300 的文档{$match : {"price": { $gte: 300 }}},// 第二阶段：将聚合管道内的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$category",count: { $sum: 1 }}},// 第三阶段：筛选出 count>=3 的文档{$match : {"count": { $gte: 3 }}}
])

// 1
{"_id": "Clothing","count": 3
}

3.4 SpringBoot 整合 MongoDB

// 输入文档实体
@Data
@Document(collection = "sales")
public class Sales {@Idprivate int _id;private String product;private String category;private int quantity;private int price;
}// 输出文档实体
@Data
public class AggregationResult {private String _id;private int count;
}// 执行聚合阶段
@SpringBootTest
@RunWith(SpringRunner.class)
public class BeanLoadServiceTest {@Autowiredprivate MongoTemplate mongoTemplate;@Testpublic void aggregateTest() {// $match 聚合阶段MatchOperation match1 = Aggregation.match(Criteria.where("price").gte(300));// $group 聚合阶段GroupOperation group = Aggregation.group("category").count().as("count");// $match 聚合阶段MatchOperation match2 = Aggregation.match(Criteria.where("count").gte(3));// 组合聚合阶段Aggregation aggregation = Aggregation.newAggregation(match1,group,match2);// 执行聚合查询AggregationResults<AggregationResult> results= mongoTemplate.aggregate(aggregation, Sales.class, AggregationResult.class);List<AggregationResult> mappedResults = results.getMappedResults();// 打印结果mappedResults.forEach(System.out::println);//AggregationResult(_id=Clothing, count=3)}
}

4. $match-> $group-> $project-> $sort-> skip-> $limit

$match 根据条件筛选文档+ $group 根据单字段分组文档 + $project 重命名字段+ $sort 对文档按照唯一键排序

构造测试数据：

db.sales.drop()db.sales.insertMany([{ "_id": 1, "product": "C", "category": "Electronics", "quantity": 10, "price": 100 },{ "_id": 2, "product": "A", "category": "Electronics", "quantity": 5, "price": 200 },{ "_id": 3, "product": "A", "category": "Electronics", "quantity": 5, "price": 300 },{ "_id": 4, "product": "D", "category": "Electronics", "quantity": 10, "price": 500 },{ "_id": 5, "product": "A", "category": "Clothing", "quantity": 8, "price": 500},{ "_id": 6, "product": "B", "category": "Clothing", "quantity": 12, "price": 200 },{ "_id": 7, "product": "B", "category": "Clothing", "quantity": 8, "price": 600 },{ "_id": 8, "product": "C", "category": "Clothing", "quantity": 12, "price": 700 }
])

4.1 $match

执行 $match 聚合阶段输出的文档为：

db.sales.aggregate([// $match 阶段：筛选出 price>100 的文档{$match : {"price": { $gt: 100 }}}
])

// 1
{"_id": 2,"product": "A","category": "Electronics","quantity": 5,"price": 200
}// 2
{"_id": 3,"product": "A","category": "Electronics","quantity": 5,"price": 300
}// 3
{"_id": 4,"product": "D","category": "Electronics","quantity": 10,"price": 500
}// 4
{"_id": 5,"product": "A","category": "Clothing","quantity": 8,"price": 500
}// 5
{"_id": 6,"product": "B","category": "Clothing","quantity": 12,"price": 200
}// 6
{"_id": 7,"product": "B","category": "Clothing","quantity": 8,"price": 600
}// 7
{"_id": 8,"product": "C","category": "Clothing","quantity": 12,"price": 700
}

4.2 $match-> $group

执行 $match + $group 聚合阶段输出的文档为：

db.sales.aggregate([// $match阶段：筛选出 price>=300 的文档{$match : {"price": { $gt: 100 }}},// $group阶段：将聚合管道内的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$product",count: { $sum: 1 }}}
])

// 1
{"_id": "C","count": 1
}// 2
{"_id": "D","count": 1
}// 3
{"_id": "B","count": 2
}// 4
{"_id": "A","count": 3
}

4.3 $match-> $group-> $project

执行$match + $group + $project 聚合阶段输出的文档为：

db.sales.aggregate([// $match阶段：筛选出 price>=300 的文档{$match : {"price": { $gt: 100 }}},// $group阶段：将聚合管道的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$product",count: { $sum: 1 }}},// $project阶段：输出文档排除_id字段，包含count字段，并将_id字段重命名为product字段{$project : {_id:0,count: 1,product: "$_id"}}
])

// 1
{"count": 1,"product": "C"
}// 2
{"count": 1,"product": "D"
}// 3
{"count": 2,"product": "B"
}// 4
{"count": 3,"product": "A"
}

4.4 $match-> $group-> $project-> $sort

执行$match + $group + $project + $sort 聚合阶段输出的文档为：

db.sales.aggregate([// $match阶段：筛选出 price>=300 的文档{$match : {"price": { $gt: 100 }}}, // $group阶段：将聚合管道的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$product",count: { $sum: 1 }}},// $project阶段：将聚合管道内的文档排除_id字段，包含count字段，并将_id字段重命名为product字段{$project : {_id:0,count: 1,product: "$_id"}},// $sort阶段：将聚合管道内的文档按照count字段降序排序{$sort : {count:-1}}
])

// 1
{"count": 3,"product": "A"
}// 2
{"count": 2,"product": "B"
}// 3
{"count": 1,"product": "C"
}// 4
{"count": 1,"product": "D"
}

4.5 $match-> $group-> $project-> $sort-> $skip

db.sales.aggregate([// $match阶段：筛选出 price>=300 的文档{$match : {"price": { $gt: 100 }}}, // $group阶段：将聚合管道的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$product",count: { $sum: 1 }}},// $project阶段：将聚合管道内的文档排除_id字段，包含count字段，并将_id字段重命名为product字段{$project : {_id:0,count: 1,product: "$_id"}},// $sort阶段：将聚合管道内的文档按照count字段降序排序{$sort : {count:-1}},// $skip阶段：跳过聚合管道的前2个文档并输出{$skip: 2}
])

// 1
{"count": 1,"product": "C"
}// 2
{"count": 1,"product": "D"
}

4.5 $match-> $group-> $project-> $sort-> $skip-> $limit

执行 $match + $group + $project + $sort + $limit 聚合阶段输出的文档为：

db.sales.aggregate([// $match阶段：筛选出 price>=300 的文档{$match : {"price": { $gt: 100 }}}, // $group阶段：将聚合管道的文档按照category分组，并计算分组内的文档数量{$group : {_id : "$product",count: { $sum: 1 }}},// $project阶段：将聚合管道内的文档排除_id字段，包含count字段，并将_id字段重命名为product字段{$project : {_id:0,count: 1,product: "$_id"}},// $sort阶段：将聚合管道内的文档按照count字段降序排序{$sort : {count:-1}},// $skip阶段：跳过聚合管道的前2个文档并输出{$skip: 2},// $limit阶段：仅输出聚合管道内的前1个文档{$limit: 1}
])

// 1
{"count": 1,"product": "C"
}

4.6 SpringBoot 整合 MongoDB

// 输入文档实体类
@Data
@Document(collection = "sales")
public class Sales {@Idprivate int _id;private String product;private String category;private int quantity;private int price;
}// 输出文档实体类
@Data
public class AggregationResult {private int count;private String product;
}// 执行聚合操作
@SpringBootTest
@RunWith(SpringRunner.class)
public class BeanLoadServiceTest {@Autowiredprivate MongoTemplate mongoTemplate;@Testpublic void aggregateTest() {// $match 聚合阶段MatchOperation match = Aggregation.match(Criteria.where("price").gt(100));// $group 聚合阶段GroupOperation group = Aggregation.group("product").count().as("count");// $project 聚合阶段ProjectionOperation project = Aggregation.project("count").andExclude("_id").and("$_id").as("product");// $sort聚合阶段SortOperation sort = Aggregation.sort(Sort.Direction.DESC, "count");// $skip 聚合阶段SkipOperation skip = Aggregation.skip(2);// $limit 聚合阶段LimitOperation limit = Aggregation.limit(1);// 组合聚合阶段Aggregation aggregation = Aggregation.newAggregation(match,group,project,sort,skip,limit);// 执行聚合查询AggregationResults<AggregationResult> results= mongoTemplate.aggregate(aggregation, Sales.class, AggregationResult.class);List<AggregationResult> mappedResults = results.getMappedResults();// 打印结果mappedResults.forEach(System.out::println);//AggregationResult(count=1, product=C)}
}

5. $group-> $project

构造测试数据：

db.sales.drop()db.sales.insertMany([{ "_id": 1, "product": "C", "category": "Electronics", "quantity": 10, "price": 100 },{ "_id": 2, "product": "A", "category": "Electronics", "quantity": 5, "price": 200 },{ "_id": 3, "product": "A", "category": "Electronics", "quantity": 5, "price": 300 },{ "_id": 4, "product": "D", "category": "Electronics", "quantity": 10, "price": 500 },{ "_id": 5, "product": "A", "category": "Clothing", "quantity": 8, "price": 500},{ "_id": 6, "product": "B", "category": "Clothing", "quantity": 12, "price": 200 },{ "_id": 7, "product": "B", "category": "Clothing", "quantity": 8, "price": 600 },{ "_id": 8, "product": "C", "category": "Clothing", "quantity": 12, "price": 700 }
])

5.1 $group 多字段分组聚合

$group 根据 category 和 product 字段分组后输出的文档为：

db.sales.aggregate([{// $group聚合阶段：将输入文档按照category和product字段分组$group: {_id: {category: "$category",product: "$product"},count: { $sum: 1 }}}
])

// 1
{"_id": {"category": "Clothing","product": "C"},"count": 1
}// 2
{"_id": {"category": "Clothing","product": "B"},"count": 2
}// 3
{"_id": {"category": "Clothing","product": "A"},"count": 1
}// 4
{"_id": {"category": "Electronics","product": "A"},"count": 2
}// 5
{"_id": {"category": "Electronics","product": "D"},"count": 1
}// 6
{"_id": {"category": "Electronics","product": "C"},"count": 1
}

5.2 $group-> $project

执行 $group + $project 聚合阶段后输出的文档为：

db.sales.aggregate([// $group聚合阶段：将输入文档按照category和product字段分组{$group: {_id: {category: "$category",product: "$product"},count: { $sum: 1 }}},// $project聚合阶段：发将_id.category重命名为category，将_id.product重命名为product,包含count字段,排除_id字段{$project: {category: "$_id.category",product: "$_id.product",count: 1,_id: 0}}
])

// 1
{"count": 1,"category": "Clothing","product": "C"
}// 2
{"count": 2,"category": "Clothing","product": "B"
}// 3
{"count": 1,"category": "Clothing","product": "A"
}// 4
{"count": 2,"category": "Electronics","product": "A"
}// 5
{"count": 1,"category": "Electronics","product": "D"
}// 6
{"count": 1,"category": "Electronics","product": "C"
}

5.3 $group-> $project-> $sort

执行 $group + $project + $sort 聚合阶段后输出的文档为：

db.sales.aggregate([// $group聚合阶段：将输入文档按照category和product字段分组{$group: {_id: {category: "$category",product: "$product"},count: { $sum: 1 }}},// $project聚合阶段：发将_id.category重命名为category，将_id.product重命名为product,包含count字段,排除_id字段{$project: {category: "$_id.category",product: "$_id.product",count: 1,_id: 0}},// $sort聚合阶段：将聚合管道内的文档按照count字段升序排序{$sort: {count:1}}
])

// 1
{"count": 1,"category": "Clothing","product": "C"
}// 2
{"count": 1,"category": "Clothing","product": "A"
}// 3
{"count": 1,"category": "Electronics","product": "D"
}// 4
{"count": 1,"category": "Electronics","product": "C"
}// 5
{"count": 2,"category": "Clothing","product": "B"
}// 6
{"count": 2,"category": "Electronics","product": "A"
}

5.4 $group-> $project-> $sort-> $limit

执行 $group + $project + $sort + $limit 聚合阶段后输出的文档为：

db.sales.aggregate([// $group聚合阶段：将输入文档按照category和product字段分组{$group: {_id: {category: "$category",product: "$product"},count: { $sum: 1 }}},// $project聚合阶段：发将_id.category重命名为category，将_id.product重命名为product,包含count字段,排除_id字段{$project: {category: "$_id.category",product: "$_id.product",count: 1,_id: 0}},// $sort聚合阶段：将聚合管道内的文档按照count字段升序排序{$sort: {count:1}},// $limit聚合阶段：仅输出聚合管道内的前2个文档{$limit:2}
])

// 1
{"count": 1,"category": "Clothing","product": "A"
}// 2
{"count": 1,"category": "Clothing","product": "C"
}

5.5 SpringBoot 整合 MongoDB

// 输入文档实体类
@Data
@Document(collection = "sales")
public class Sales {@Idprivate int _id;private String product;private String category;private int quantity;private int price;
}// 输出文档实体类
@Data
public class AggregationResult {private int count;private String product;private String category;
}// 执行聚合操作
@SpringBootTest
@RunWith(SpringRunner.class)
public class BeanLoadServiceTest {@Autowiredprivate MongoTemplate mongoTemplate;@Testpublic void aggregateTest() {// $group 聚合阶段GroupOperation group = Aggregation.group("category","product").count().as("count");// $project 聚合阶段ProjectionOperation project = Aggregation.project("count").andExclude("_id").and("$_id.category").as("category").and("$_id.product").as("product");// $sort聚合阶段SortOperation sort = Aggregation.sort(Sort.Direction.DESC, "count");// $limit 聚合阶段LimitOperation limit = Aggregation.limit(2);// 组合聚合阶段Aggregation aggregation = Aggregation.newAggregation(group,project,sort,limit);// 执行聚合查询AggregationResults<AggregationResult> results= mongoTemplate.aggregate(aggregation, Sales.class, AggregationResult.class);List<AggregationResult> mappedResults = results.getMappedResults();// 打印结果mappedResults.forEach(System.out::println);//AggregationResult(count=2, product=A, category=Electronics)//AggregationResult(count=2, product=B, category=Clothing)}
}

MongoDB - 组合聚合阶段：$group、$match、$limit、$sort、$skip、$project、$count

文章目录 1. $group2. $group-> $project2.1 $group2.2 $group-> $project2.3 SpringBoot 整合 MongoDB 3. $match-> $group -> $match3.1 $match3.2 $match-> $group3.3 $match-> $group-> $match3.4 SpringBoot 整合 MongoDB 4. $match-> $group->…...

编程日记 2024/7/27 19:19:11

vue element-ui日期控件传参

前端：Vue element-ui <el-form-item label"过期时间" :rules"[ { required: true, message: 请选择过期时间, trigger: blur }]"><el-date-picker v-model"form.expireTime" type"date" format"yyyy-MM-dd&…...

编程日记 2024/7/27 19:17:09

MacOS安装SDKMan管理Java版本

文章目录 1 简介2 安装与卸载2.1 安装2.2 卸载 3 使用3.1 查看其他工具：支持 Ant, Maven 等3.2 查看Java版本3.3 安装Java，加上相关的版本3.4 设置Java版本(全局)3.5 只在当前窗口生效3.6 卸载1 默认环境无法卸载 4 jdk安装的位置5 与IDEA集成参考 1 简介…...

编程日记 2024/7/27 19:16:06

【网络安全的神秘世界】文件包含漏洞

🌝博客主页：泥菩萨 💖专栏：Linux探索之旅 | 网络安全的神秘世界 | 专接本 | 每天学会一个渗透测试工具一、概述文件包含：重复使用的函数写在文件里，需要使用某个函数时直接调用此文件，而无需再…...

编程日记 2024/7/27 19:14:03

并发编程--volatile

1.什么是volatile volatile是轻量级的 synchronized，它在多处理器开发中保证了共享变量的 “ 可见性 ” 。可见性的意思是当一个线程修改一个共享变量时 ，另外一个线程能读到这个修改的值。如果 volatile 变量修饰符使用…...

编程日记 2024/7/27 19:13:01

记录unraid docker更新的域名

背景：级联一、安装内容 unraid更新docker，之前一直失败，修改网络后可以进行安装。二、查看域名查看域名，发现是走github的，怪不得有一些docker无法正常更新三、解决方法更改代理，这里为unraid的…...

编程日记 2024/7/27 19:09:58

SpringCloud+Vue3多对多，多表联查

♥️作者：小宋1021 🤵‍♂️个人主页：小宋1021主页 ♥️坚持分析平时学习到的项目以及学习到的软件开发知识，和大家一起努力呀！！！ 🎈🎈加油！ 加油&#xff01…...

编程日记 2024/7/27 19:06:55

麒麟系统信创改造

麒麟系统信创改造一、查看操作系统架构下载相应的依赖，压缩包1、查看Linux系统架构、CPU（1）uname -m（2）lscpu（3）cat /proc/cpuinfo（4）arch（5）getconf LONG_BIT（6）dmidecode2、根据Linux系统架构、CPU的差异进行下载相关依赖，看第二项二、以下是根据本系统的aarc…...

编程日记 2024/7/27 19:03:52

【Android】ListView和RecyclerView知识总结

文章目录 ListView步骤适配器AdpterArrayAdapterSimpleAdapterBaseAdpter效率问题 RecyclerView具体实现不同布局形式的设置横向滚动瀑布流网格点击事件 ListView ListView 是 Android 中的一种视图组件，用于显示可滚动的垂直列表。每个列表项都是一个视图对象&…...

编程日记 2024/7/27 19:02:51

泛域名绑定到wordpress网站二级目录

要将WordPress的泛域名绑定到二级目录，你需要在你的服务器上修改Apache或Nginx配置文件。以下是两种最常见的服务器配置的示例： Apache服务器编辑你的虚拟主机配置文件，通常位于/etc/apache2/sites-available/目录下。 <VirtualHost *…...

编程日记 2024/7/27 19:01:50

8、从0搭建企业门户网站——网站部署

目录正文 1、域名解析 2、云服务器端口授权 3、Mysql数据库初始化 4、上传网站软件包 5、Tomcat配置 6、运行Tomcat 7、停止Tomcat 8、部署后发现验证码无法使用完毕！正文当云服务器租用、域名购买和软件开发都完成后，我们就可以开始网站部署上线，ICP备案会长…...

编程日记 2024/7/27 19:00:48

uniapp中出现图片过小会与盒子偏离

结论：在image的父盒子中加上display: flex，原因不清楚出问题的代码和图片如下： <template><view style" background-color: greenyellow; height: 10rpx;width: 10rpx;"><image :src"imgSrc.seatnull" …...

编程日记 2024/7/27 18:59:46

MySQL练手 --- 1934. 确认率

题目链接：1934. 确认率思路由题可知，两个表，一个表为Signups注册表，另一个表为Confirmations信息确认表，表的关联关系为一对一，且user_id作为两个表的连接条件（匹配字段）&#…...

编程日记 2024/7/27 18:56:41

【OpenCV C++20 学习笔记】扫描图片数据

扫描图片数据应用情景图像数据扫描的难点颜色空间缩减（color space reduction）查询表扫描算法计算查询表统计运算时长连续内存3种扫描方法C风格的扫描方法迭代器方法坐标方法LUT方法算法效率对比结论应用情景图像数据扫描的难点在上一篇文章《基…...

编程日记 2024/7/27 18:50:34

LeetCode：爬楼梯（C语言）

1、问题概述：每次可以爬 1 或 2 个台阶。有多少种不同的方法可以爬到楼顶 2、示例示例 1： 输入：n 2 输出：2 解释：有两种方法可以爬到楼顶。 1. 1 阶 1 阶 2. 2 阶示例 2： 输入：n 3 输出&a…...

编程日记 2024/7/27 18:49:33

银河麒麟（arm64）环境下通过docker安装postgis3，并实现数据整体迁移

银河麒麟(arm64)环境下通过docker安装postgis3，并实现数据整体迁移硬件配置：麒麟9006C 系统环境：银河麒麟桌面版v10 sp1 数据库：postgresql11+postgis3.0 具体的步骤参考https://blog.csdn.net/qq_34817440/article/details/103914574 -----主要操作-----------------…...

编程日记 2024/7/27 18:46:29

C语言 | Leetcode C语言题解之第278题第一个错误的版本

题目： 题解： int firstBadVersion(int n) {int left 1, right n;while (left < right) { // 循环直至区间左右端点相同int mid left (right - left) / 2; // 防止计算时溢出if (isBadVersion(mid)) {right mid; // 答案在区间 [left, mid] 中…...

编程日记 2024/7/27 18:43:25

京东科技集团将在香港发行与港元1:1挂钩的加密货币稳定币

据京东科技集团旗下公司京东币链科技(香港)官网信息，京东稳定币是一种基于公链并与港元(HKD) 1:1挂钩的稳定币，将在公共区块链上发行，其储备由高度流动且可信的资产组成，这些资产安全存放于持牌金融机构的独立账户中，通…...

编程日记 2024/7/27 18:41:24

Vue 实现电子签名并生成签名图片

目录前言项目结构代码实现安装依赖创建签名画布组件生成签名图片总结相关阅读 1. 前言电子签名在现代Web应用中越来越普遍，例如合同签署、确认表单等。本文将介绍如何使用Vue.js实现一个简单的电子签名功能，并将签名生成图片。 2. 项目结构项…...

编程日记 2024/7/27 18:40:23

Visual Studio 2022美化

说明： VS版本：Visual Studio Community 2022 背景美化【扩展】【管理扩展】搜索“ClaudiaIDE”，【下载】，安装完扩展要重启VS 在wallhaven下载壁纸图片作为文本编辑器区域背景图片【工具】【选项】搜索ClaudiaIDE&#xff…...

编程日记 2024/7/27 18:39:22

java调用dll出现unsatisfiedLinkError以及JNA和JNI的区别

UnsatisfiedLinkError 在对接硬件设备中，我们会遇到使用 java 调用 dll文件的情况，此时大概率出现UnsatisfiedLinkError链接错误，原因可能有如下几种类名错误包名错误方法名参数错误使用 JNI 协议调用，结果 dll 未实现 JNI 协…...

编程新知 2025/10/6 16:38:04

如何为服务器生成TLS证书

TLS（Transport Layer Security）证书是确保网络通信安全的重要手段，它通过加密技术保护传输的数据不被窃听和篡改。在服务器上配置TLS证书，可以使用户通过HTTPS协议安全地访问您的网站。本文将详细介绍如何在服务器上生成一个TLS证…...

编程新知 2025/12/17 5:54:30

HBuilderX安装（uni-app和小程序开发）

下载HBuilderX 访问官方网站：https://www.dcloud.io/hbuilderx.html 根据您的操作系统选择合适版本： Windows版（推荐下载标准版） Windows系统安装步骤运行安装程序： 双击下载的.exe安装文件如果出现安全提示&…...

编程新知 2025/12/15 13:32:19

A2A JS SDK 完整教程：快速入门指南

目录什么是 A2A JS SDK?A2A JS 安装与设置A2A JS 核心概念创建你的第一个 A2A JS 代理A2A JS 服务端开发A2A JS 客户端使用A2A JS 高级特性A2A JS 最佳实践A2A JS 故障排除什么是 A2A JS SDK? A2A JS SDK 是一个专为 JavaScript/TypeScript 开发者设计的强大库&#xff…...

编程新知 2025/12/12 8:42:24

C++.OpenGL （20/64）混合（Blending）

混合（Blending）透明效果核心原理 #mermaid-svg-SWG0UzVfJms7Sm3e {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-SWG0UzVfJms7Sm3e .error-icon{fill:#552222;}#mermaid-svg-SWG0UzVfJms7Sm3e .error-text{fill…...

编程新知 2025/9/24 22:51:29

android13 app的触摸问题定位分析流程

一、知识点一般来说，触摸问题都是app层面出问题，我们可以在ViewRootImpl.java添加log的方式定位；如果是touchableRegion的计算问题，就会相对比较麻烦了，需要通过adb shell dumpsys input > input.log指令，且通过打印堆栈的方式，逐步定位问题，并找到修改方案。问题…...

编程新知 2025/12/2 1:15:53