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

RestClient查询和数据聚合

news 2025/9/8 10:48:08

RestClient查询

文档的查询依然使用昨天学习的 RestHighLevelClient对象，查询的基本步骤如下：

1）创建request对象，这次是搜索，所以是SearchRequest

2）准备请求参数，也就是查询DSL对应的JSON参数

3）发起请求

4）解析响应，响应结果相对复杂，需要逐层解析

快速入门

之前说过，由于Elasticsearch对外暴露的接口都是Restful风格的接口，因此JavaAPI调用就是在发送Http请求。而我们核心要做的就是利用利用Java代码组织请求参数，解析响应结果。

这个参数的格式完全参考DSL查询语句的JSON结构，因此我们在学习的过程中，会不断的把JavaAPI与DSL语句对比。大家在学习记忆的过程中，也应该这样对比学习。

发送请求

首先以match_all查询为例，其DSL和JavaAPI的对比如图：

代码解读：

  • 第一步，创建SearchRequest对象，指定索引库名
  • 第二步，利用request.source()构建DSL，DSL中可以包含查询、分页、排序、高亮等
    • query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL
  • 第三步，利用client.search()发送请求，得到响应

这里关键的API有两个，一个是request.source()，它构建的就是DSL中的完整JSON参数。其中包含了query、sort、from、size、highlight等所有功能：

另一个是QueryBuilders，其中包含了我们学习过的各种叶子查询、复合查询等：

解析响应结果

在发送请求以后，得到了响应结果SearchResponse，这个类的结构与我们在kibana中看到的响应结果JSON结构完全一致：

{"took" : 0,"timed_out" : false,"hits" : {"total" : {"value" : 2,"relation" : "eq"},"max_score" : 1.0,"hits" : [{"_index" : "heima","_type" : "_doc","_id" : "1","_score" : 1.0,"_source" : {"info" : "Java讲师","name" : "赵云"}}]}
}

因此，我们解析SearchResponse的代码就是在解析这个JSON结果，对比如下：

代码解读：

elasticsearch返回的结果是一个JSON字符串，结构包含：

  • hits：命中的结果
    • total：总条数，其中的value是具体的总条数值
    • max_score：所有结果中得分最高的文档的相关性算分
    • hits：搜索结果的文档数组，其中的每个文档都是一个json对象
      • _source：文档中的原始数据，也是json对象

因此，我们解析响应结果，就是逐层解析JSON字符串，流程如下：

  • SearchHits：通过response.getHits()获取，就是JSON中的最外层的hits，代表命中的结果
    • SearchHits#getTotalHits().value：获取总条数信息
    • SearchHits#getHits()：获取SearchHit数组，也就是文档数组
      • SearchHit#getSourceAsString()：获取文档结果中的_source，也就是原始的json文档数据

总结

文档搜索的基本步骤是：

  1. 创建SearchRequest对象
  2. 准备request.source()，也就是DSL。
    1. QueryBuilders来构建查询条件
    2. 传入request.source() 的 query() 方法
  3. 发送请求，得到结果
  4. 解析结果（参考JSON结果，从外到内，逐层解析）

完整代码如下：

@Test
void testMatchAll() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数request.source().query(QueryBuilders.matchAllQuery());// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}private void handleResponse(SearchResponse response) {SearchHits searchHits = response.getHits();// 1.获取总条数long total = searchHits.getTotalHits().value;System.out.println("共搜索到" + total + "条数据");// 2.遍历结果数组SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {// 3.得到_source，也就是原始json文档String source = hit.getSourceAsString();// 4.反序列化并打印ItemDoc item = JSONUtil.toBean(source, ItemDoc.class);System.out.println(item);}
}

叶子查询

所有的查询条件都是由QueryBuilders来构建的，叶子查询也不例外。因此整套代码中变化的部分仅仅是query条件构造的方式，其它不动。

例如match查询：

@Test
void testMatch() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

再比如multi_match查询：

@Test
void testMultiMatch() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数request.source().query(QueryBuilders.multiMatchQuery("脱脂牛奶", "name", "category"));// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

还有range查询：

@Test
void testRange() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数request.source().query(QueryBuilders.rangeQuery("price").gte(10000).lte(30000));// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

还有term查询：

@Test
void testTerm() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数request.source().query(QueryBuilders.termQuery("brand", "华为"));// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

复合查询

复合查询也是由QueryBuilders来构建，我们以bool查询为例，DSL和JavaAPI的对比如图：

完整代码如下：

@Test
void testBool() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数// 2.1.准备bool查询BoolQueryBuilder bool = QueryBuilders.boolQuery();// 2.2.关键字搜索bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶"));// 2.3.品牌过滤bool.filter(QueryBuilders.termQuery("brand", "德亚"));// 2.4.价格过滤bool.filter(QueryBuilders.rangeQuery("price").lte(30000));request.source().query(bool);// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

排序和分页

之前说过，requeset.source()就是整个请求JSON参数，所以排序、分页都是基于这个来设置，其DSL和JavaAPI的对比如下：

完整示例代码：

@Test
void testPageAndSort() throws IOException {int pageNo = 1, pageSize = 5;// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数// 2.1.搜索条件参数request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));// 2.2.排序参数request.source().sort("price", SortOrder.ASC);// 2.3.分页参数request.source().from((pageNo - 1) * pageSize).size(pageSize);// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

高亮

高亮查询与前面的查询有两点不同：

  • 条件同样是在request.source()中指定，只不过高亮条件要基于HighlightBuilder来构造
  • 高亮响应结果与搜索的文档结果不在一起，需要单独解析

首先来看高亮条件构造，其DSL和JavaAPI的对比如图：

示例代码如下：

@Test
void testHighlight() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数// 2.1.query条件request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));// 2.2.高亮条件request.source().highlighter(SearchSourceBuilder.highlight().field("name").preTags("<em>").postTags("</em>"));// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

再来看结果解析，文档解析的部分不变，主要是高亮内容需要单独解析出来，其DSL和JavaAPI的对比如图：

代码解读：

  • 第3、4步：从结果中获取_source。hit.getSourceAsString()，这部分是非高亮结果，json字符串。还需要反序列为ItemDoc对象
  • 第5步：获取高亮结果。hit.getHighlightFields()，返回值是一个Map，key是高亮字段名称，值是HighlightField对象，代表高亮值
  • 第5.1步：从Map中根据高亮字段名称，获取高亮字段值对象HighlightField
  • 第5.2步：从HighlightField中获取Fragments，并且转为字符串。这部分就是真正的高亮字符串了
  • 最后：用高亮的结果替换ItemDoc中的非高亮结果

完整代码如下：

private void handleResponse(SearchResponse response) {SearchHits searchHits = response.getHits();// 1.获取总条数long total = searchHits.getTotalHits().value;System.out.println("共搜索到" + total + "条数据");// 2.遍历结果数组SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {// 3.得到_source，也就是原始json文档String source = hit.getSourceAsString();// 4.反序列化ItemDoc item = JSONUtil.toBean(source, ItemDoc.class);// 5.获取高亮结果Map<String, HighlightField> hfs = hit.getHighlightFields();if (CollUtils.isNotEmpty(hfs)) {// 5.1.有高亮结果，获取name的高亮结果HighlightField hf = hfs.get("name");if (hf != null) {// 5.2.获取第一个高亮结果片段，就是商品名称的高亮值String hfName = hf.getFragments()[0].string();item.setName(hfName);}}System.out.println(item);}
}

这里结合代码完整流程再详细地说一遍：

假设场景：用户在搜索框输入「手机」，后端需要从 Elasticsearch 中查询相关商品，并在页面上高亮显示「手机」关键词。

步骤 1：用户发起搜索请求

用户在前端输入「手机」并点击搜索，前端把这个关键词发送给后端。

步骤 2：后端向 Elasticsearch 发起查询

后端接收到「手机」关键词后，会构造一个 Elasticsearch 搜索请求，特别指定需要对「name」字段进行高亮处理（比如用 <em> 标签包裹匹配的关键词）。

这段代码虽然没展示，但这是前提：查询时必须设置高亮规则，否则 Elasticsearch 不会返回高亮数据。

步骤 3：Elasticsearch 返回响应结果

Elasticsearch 执行查询后，返回一个 SearchResponse 对象（就是代码中的 response 参数），这个对象包含两类关键数据：

  • 原始数据（_source）：存储时的完整数据，比如商品的名称、价格等（无高亮标签）。
  • 高亮数据（highlight）：额外生成的、带高亮标签的数据（仅包含匹配关键词的字段）。

步骤 4：后端处理响应（核心代码逻辑）

这就是你看到的 handleResponse 方法，作用是把 Elasticsearch 返回的原始数据和高亮数据整合成「可直接用于展示的对象」。

我们逐行对应流程看代码：

private void handleResponse(SearchResponse response) {// 1. 从响应中获取所有搜索结果的集合SearchHits searchHits = response.getHits();// 2. 获取总条数并打印（比如显示"共找到10条结果"）long total = searchHits.getTotalHits().value;System.out.println("共搜索到" + total + "条数据");// 3. 提取具体的每条结果（数组）SearchHit[] hits = searchHits.getHits();// 4. 遍历每条结果，处理后用于展示for (SearchHit hit : hits) {// 4.1 提取原始数据（_source），转成Java对象（方便操作）String source = hit.getSourceAsString(); // 原始JSON字符串，比如{"name":"苹果手机13","price":5999}ItemDoc item = JSONUtil.toBean(source, ItemDoc.class); // 转成ItemDoc对象，之后可以用item.getName()等方法// 4.2 提取高亮数据，替换原始对象中的对应字段Map<String, HighlightField> hfs = hit.getHighlightFields(); // 获取所有高亮字段的映射（比如{"name": 高亮对象}）// 判断是否有高亮数据if (CollUtils.isNotEmpty(hfs)) {// 获取"name"字段的高亮数据（因为我们只对name设置了高亮）HighlightField hf = hfs.get("name"); if (hf != null) {// 高亮数据可能有多个片段，这里取第一个，转成字符串（比如"苹果<em>手机</em>13"）String hfName = hf.getFragments()[0].string();// 用高亮后的name替换原始对象中的nameitem.setName(hfName); }}// 4.3 处理后的item对象可以用于后续展示（比如传给前端）// 此时item.getName()返回的是带高亮标签的字符串，其他字段（如price）还是原始值}
}

步骤 5：前端展示结果

后端把处理后的 ItemDoc 对象（包含带高亮标签的 name）返回给前端，前端直接渲染：

  • 对于 name 字段：因为有 <em> 标签，前端可以通过 CSS 让 <em> 内的文字标红（比如 em { color: red; }），实现关键词高亮。
  • 对于其他字段（如 price）：直接显示原始值即可。

这里可能有几个疑问：

1.为什么要把高亮数据替换到原始数据里，直接拿到原始数据，然后把数据里存在有搜索的关键词全部换成高亮数据然后再把整个对象返回给前端渲染不就好了吗？

  • 这完全是重复劳动，因为 Elasticsearch 在返回结果时，已经帮你完成了，它知道关键词在哪里，并且已经加好标签了
  • 如果关键词出现多次（比如 name:"手机品牌 手机型号"），自己写代码可能漏处理，而 Elasticsearch 的高亮结果会准确包含所有匹配位置。
  • 如果搜索条件复杂（比如模糊匹配、同义词匹配），自己判断「哪些词需要高亮」会非常困难，而 Elasticsearch 能精准对应搜索条件。

2.替换过去的高亮数据并不会展示出来是高亮，替换之后还是那个数据，比如要高亮name，那我set进去的还是name啊，数据没有什么变化，那前端怎么知道哪个要高亮呢？

注意替换的不是字段名，而是字段的值

假设原始数据的 name 是：

item.getName() → "苹果手机13"  // 无任何标签

替换后（用高亮数据）：

item.setName(hfName);  // hfName的值是 "苹果<em>手机</em>13"
item.getName() → "苹果<em>手机</em>13"  // 多了<em>标签

这里的 setName 是用带标签的新值覆盖了原始值，字段名还是 name，但值已经包含了高亮标记（<em>）。

前端拿到这个对象的时候getName看到这里有标签就知道这里是要高亮的部分，他们就会自己添加高亮了

3.把原始数据里高亮部分替换进去，那为什么不直接用带有高亮的数据，这里面不就是原始数据多了高亮标签吗，那替换过去的效果不就是高亮数据吗，那就不用替换，直接用就好了，为什么要多一步呢？

因为高亮数据只包含需要高亮的字段（比如只有 name），而你需要的是完整的商品信息（还包括 price、category 等其他字段）。

比如 Elasticsearch 返回的高亮数据可能只有：

"highlight": { "name": "苹果<em>手机</em>13" }  // 只有name字段

而原始数据包含所有字段：

"_source": {"name": "苹果手机13","price": 5999,"category": "电子产品"
}

如果不替换，你需要同时传递两个数据给前端：

  • 高亮数据（highlight.name）
  • 原始数据（_source.price、_source.category 等）

前端渲染时还要手动拼接：

<!-- 麻烦的方式：分开处理 -->
<div>名称：{{ highlightName }}</div>
<div>价格：{{ sourcePrice }}</div>
<div>分类：{{ sourceCategory }}</div>

而替换后，你只需要传递一个整合后的 item 对象给前端，前端直接使用：

<!-- 简洁的方式：一个对象搞定 -->
<div>名称：{{ item.name }}</div>  <!-- 带高亮标签 -->
<div>价格：{{ item.price }}</div>
<div>分类：{{ item.category }}</div>

数据聚合

聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析、运算。例如：

  • 什么品牌的手机最受欢迎？
  • 这些手机的平均价格、最高价格、最低价格？
  • 这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

官方文档：

Aggregations | Elasticsearch Guide [7.12] | Elastic

聚合常见的有三类：

  • 桶（Bucket）聚合：用来对文档做分组
    • TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
    • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
  • 度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
    • Avg：求平均值
    • Max：求最大值
    • Min：求最小值
    • Stats：同时求max、min、avg、sum等
  • 管道（pipeline）聚合：其它聚合的结果为基础做进一步运算

注意：参加聚合的字段必须是keyword、日期、数值、布尔类型

DSL实现聚合

与之前的搜索功能类似，我们依然先学习DSL的语法，再学习JavaAPI.

Bucket聚合

例如我们要统计所有商品中共有哪些商品分类，其实就是以分类（category）字段对数据分组。category值一样的放在同一组，属于Bucket聚合中的Term聚合。

基本语法如下：

GET /items/_search
{"size": 0, "aggs": {"category_agg": {"terms": {"field": "category","size": 20}}}
}

语法说明：

  • size：设置size为0，就是每页查0条，则结果中就不包含文档，只包含聚合
  • aggs：定义聚合
    • category_agg：聚合名称，自定义，但不能重复
      • terms：聚合的类型，按分类聚合，所以用term
      • field：参与聚合的字段名称
      • size：希望返回的聚合结果的最大数量

来看下查询的结果：

带条件聚合

默认情况下，Bucket聚合是对索引库的所有文档做聚合，例如我们统计商品中所有的品牌，结果如下：

可以看到统计出的品牌非常多。

但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。

例如，我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？

我们需要从需求中分析出搜索查询的条件和聚合的目标：

  • 搜索查询条件：
    • 价格高于3000
    • 必须是手机
  • 聚合目标：统计的是品牌，肯定是对brand字段做term聚合

语法如下：

GET /items/_search
{"query": {"bool": {"filter": [{"term": {"category": "手机"}},{"range": {"price": {"gte": 300000}}}]}}, "size": 0, "aggs": {"brand_agg": {"terms": {"field": "brand","size": 20}}}
}

聚合结果如下：

{"took" : 2,"timed_out" : false,"hits" : {"total" : {"value" : 13,"relation" : "eq"},"max_score" : null,"hits" : [ ]},"aggregations" : {"brand_agg" : {"doc_count_error_upper_bound" : 0,"sum_other_doc_count" : 0,"buckets" : [{"key" : "华为","doc_count" : 7},{"key" : "Apple","doc_count" : 5},{"key" : "小米","doc_count" : 1}]}}
}

可以看到，结果中只剩下3个品牌了。

Metric聚合

上节课，我们统计了价格高于3000的手机品牌，形成了一个个桶。现在我们需要对桶内的商品做运算，获取每个品牌价格的最小值、最大值、平均值。

这就要用到Metric聚合了，例如stat聚合，就可以同时获取min、max、avg等结果。

语法如下：

GET /items/_search
{"query": {"bool": {"filter": [{"term": {"category": "手机"}},{"range": {"price": {"gte": 300000}}}]}}, "size": 0, "aggs": {"brand_agg": {"terms": {"field": "brand","size": 20},"aggs": {"stats_meric": {"stats": {"field": "price"}}}}}
}

query部分就不说了，我们重点解读聚合部分语法。

可以看到我们在brand_agg聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。

  • stats_meric：聚合名称
    • stats：聚合类型，stats是metric聚合的一种
    • field：聚合字段，这里选择price，统计价格

由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值。

结果如下：

另外，我们还可以让聚合按照每个品牌的价格平均值排序：

总结

aggs代表聚合，与query同级，此时query的作用是？

  • 限定聚合的的文档范围

聚合必须的三要素：

  • 聚合名称
  • 聚合类型
  • 聚合字段

聚合可配置属性有：

  • size：指定聚合结果数量
  • order：指定聚合结果排序方式
  • field：指定聚合字段

RestClient实现聚合

可以看到在DSL中，aggs聚合条件与query条件是同一级别，都属于查询JSON参数。因此依然是利用request.source()方法来设置。

不过聚合条件的要利用AggregationBuilders这个工具类来构造。DSL与JavaAPI的语法对比如下：

聚合结果与搜索文档同一级别，因此需要单独获取和解析。具体解析语法如下：

完整代码如下：

@Test
void testAgg() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.准备请求参数BoolQueryBuilder bool = QueryBuilders.boolQuery().filter(QueryBuilders.termQuery("category", "手机")).filter(QueryBuilders.rangeQuery("price").gte(300000));request.source().query(bool).size(0);// 3.聚合参数request.source().aggregation(AggregationBuilders.terms("brand_agg").field("brand").size(5));// 4.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 5.解析聚合结果Aggregations aggregations = response.getAggregations();// 5.1.获取品牌聚合Terms brandTerms = aggregations.get("brand_agg");// 5.2.获取聚合中的桶List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();// 5.3.遍历桶内数据for (Terms.Bucket bucket : buckets) {// 5.4.获取桶内keyString brand = bucket.getKeyAsString();System.out.print("brand = " + brand);long count = bucket.getDocCount();System.out.println("; count = " + count);}
}

数据聚合的作用和意义

“方便查询” 是数据聚合的表层作用，其核心价值是通过 “分组、计算、筛选” 等操作，将原始数据转化为可用于分析、决策的业务指标。它不仅是 “方便查询” 的工具，更是从分散数据中提取有意义信息、支撑决策的关键过程。

作用:

  1. 降低数据复杂度：原始数据可能有百万、千万条（比如电商平台一天的订单数据），直接查询单条数据效率低，且无法直接看出规律；聚合后能把数据压缩到几十、几百条（比如 “各省份订单量”），大幅降低理解成本。
  2. 提取业务洞察：查询是 “找数据”，而聚合是 “找规律”。比如：
    • 不是单纯查询 “某店铺今天的每笔销售”，而是聚合计算 “该店铺今天的总销售额、客单价、热销商品 TOP3”—— 这些结果能直接支撑 “店铺运营是否达标” 的判断。
    • 不是查询 “某城市每天的气温”，而是聚合计算 “该城市本月平均气温、最高温天数”—— 支撑 “是否出现极端天气” 的分析。
  3. 支撑上层应用：聚合结果是报表、仪表盘（Dashboard）、数据分析模型的核心数据源。比如企业的 “月度营收报表”，本质就是对 “全公司各业务线的订单、回款数据” 的聚合结果；AI 模型训练前的 “特征工程”，也常需要通过聚合生成 “用户活跃度”“商品复购率” 等关键特征。
  4. 当然还有方便查询

除了 “分类 / 条件查询、极值 / 均值”，数据聚合还有这些核心操作

你提到的操作是聚合的基础，但实际应用中会根据需求组合更丰富的逻辑，常见操作可分为两类：

操作类型

具体示例

业务意义

数据分组

按 “地区” 分组、按 “时间（日 / 周 / 月）” 分组、按 “用户等级” 分组

实现 “分类查询” 的核心，比如 “各省份的销量”

数值计算

1. 总量：总销量、总用户数
2. 均值：客单价、日均访问量
3. 极值：最高销售额、最低库存
4. 占比：某商品销量占比、新用户占比
5. 去重：独立访客数（UV）

从 “数量” 维度提取关键指标，比如 “客单价” 反映用户消费能力

数据筛选

筛选 “销售额> 10 万的店铺”、筛选 “近 7 天的订单”

聚焦目标数据，排除无关信息

多维度组合

按 “地区 + 时间” 双维度聚合（比如 “北京 10 月每周的销量”）

挖掘更精细的规律，比如 “北京 10 月第二周销量突增的原因”


文章转载自：

http://BUuKL4h8.qbLcm.cn
http://0hvFlxSM.qbLcm.cn
http://mCH7hZY6.qbLcm.cn
http://O6FjQ4nN.qbLcm.cn
http://nnOlAjVb.qbLcm.cn
http://qB3UFM5r.qbLcm.cn
http://8x8CSYPo.qbLcm.cn
http://BCylhVsb.qbLcm.cn
http://gP6aseeS.qbLcm.cn
http://5j7gErpn.qbLcm.cn
http://vL4Muiog.qbLcm.cn
http://QdKFYWLy.qbLcm.cn
http://OepjjD6W.qbLcm.cn
http://zGfs840Z.qbLcm.cn
http://aMDHlHoN.qbLcm.cn
http://RhVCMXoU.qbLcm.cn
http://EIHqT4Ls.qbLcm.cn
http://KYJpGUmC.qbLcm.cn
http://pr2PgO4X.qbLcm.cn
http://ONSCWdWu.qbLcm.cn
http://fKeCAw05.qbLcm.cn
http://JrHU2uoL.qbLcm.cn
http://dSZBAhuc.qbLcm.cn
http://PFauszZv.qbLcm.cn
http://0x9bSyDm.qbLcm.cn
http://I4LA4Kxn.qbLcm.cn
http://hatW4iga.qbLcm.cn
http://QOtJNyNq.qbLcm.cn
http://Q97vVpik.qbLcm.cn
http://EFblKPts.qbLcm.cn
http://www.dtcms.com/a/372330.html

相关文章：

  • 前后端中的回调机制：含义、作用与实现详解
  • 四、神经网络的学习（下）
  • 万字详解网络编程之socket
  • PNG和JPEG和BMP文件格式转换
  • 语音之战+通用大模型，AI霸权决战打响
  • eslint 和 prettier 的相同点和区别
  • 苹果 FoundationModels 秘典侠客行：隐私为先的端侧 AI 江湖
  • hot100链表类题目
  • 算法：链表
  • Vscode中开发VUE项目的调试方案
  • Lua ＞ OpenResty HelloWorld
  • FreeRTOS项目（2）摇杆按键检测
  • 《一往无前：雷军亲述小米热血 10 年》（上部）读书笔记
  • 线性代数 | 行图像 / 列图像
  • 【PCIe EP 设备入门学习专栏 -- 8.2.1 PCIe EP Capability Register 介绍】
  • 基于Python的在线课程学习平台【2026最新】
  • 矩阵的对称，反对称分解
  • [论文阅读] 人工智能 + 软件工程 | 从Dialogflow到Rasa：MUTABOT如何让聊天机器人缺陷无所遁形？
  • 视频软件 SMPLAYER
  • AutoGPT实战体验：AI自动任务工具如何高效完成深度调研？避坑技巧分享
  • tcp粘包产生的根源
  • JavaScript 结构型模式详解
  • Cursor 提示词探索——如何打造真正懂自己的Agent
  • Selfie Vibe-AI头像生成器
  • 内网后渗透攻击--linux系统（权限维持）
  • MySQL中实施排序(sorting)及分组(grouping)操作
  • 《sklearn机器学习——管道和复合估算器》异构数据的列转换器
  • === 和 == 的规则及原理
  • Python：基于LangChain的AI Agent（智能代理）应用开发实践
  • Java ConcurrentHashMap 底层原理与线程安全机制深度解析