“_id” : “1”,
“_version” : 2,
“result” : “updated”,
“_shards” : {
“total” : 2,
“successful” : 1,
“failed” : 0
},
“_seq_no” : 1,
“_primary_term” : 1
}
新的方法 POST 命令更新
POST /test/_doc/1/_update
{
“doc”: {
“name”:“张三”
}
}
// 结果
{
“_index” : “test”,
“_type” : “_doc”,
“_id” : “1”,
“_version” : 3,
“_seq_no” : 2,
“_primary_term” : 1,
“found” : true,
“_source” : {
“name” : “张三”,
“age” : 18,
“gender” : “male”
}
}
6.4 删除索引
删除索引!!!
DELETE test
通过 delete 命令实现删除,根据你的请求来判断删除的是索引 还是 文档
========================================================================
7.1 基本操作 (复习巩固)
- 添加数据(添加多条记录)
PUT /gorit/user/1
{
“name”: “CodingGorit”,
“age”: 23,
“desc”: “一个独立的个人开发者”,
“tags”: [“Python”,“Java”,“JavaScript”]
}
PUT /gorit/user/2
{
“name”: “龙”,
“age”: 20,
“desc”: “全栈工程师”,
“tags”: [“Python”,“JavaScript”]
}
结果:
#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).
{
“_index” : “gorit”,
“_type” : “user”,
“_id” : “1”,
“_version” : 1,
“result” : “created”,
“_shards” : {
“total” : 2,
“successful” : 1,
“failed” : 0
},
“_seq_no” : 0,
“_primary_term” : 1
}
- 获取数据
GET /gorit/user/_search # 查询所有数据
GET /gorit/user/1 # 查询单个数据
- 更新数据 PUT
PUT /gorit/user/3
{
“name”: “李四222”,
“age”: 20,
“desc”: “Java开发工程师”,
“tags”: [“Python”,“Java”]
}
PUT 更新字段不完整,数据会被滞空
- post _update , 推荐使用这种方式!
修改方式和 PUT 一样会使数据滞空
POST /gorit/user/1
{
“doc”: {
“name”: “coco”
}
}
修改数据不会滞空, 效率更加高效
POST /gorit/user/1/_update
{
“doc”: {
“name”: “coco”
}
}
简单的搜索!
查询一条记录
GET /gorit/user/1
查询所有
GET /gorit/user/_search
条件查询 [精确匹配] ,如果我们没有个这个属性设置字段,它会背默认设置为 keyword,这个 keyword 字段就是使用全匹配来匹配的,如果是 text 类型,模糊查询就会起效果
GET /gorit/user/_search?q=name:coco
7.2 复杂的查询搜索:select(排序、分页、高亮、模糊查询、精确查询)!
- 过滤加指定字段查询
GET /gorit/user/_search
{
“query”: {
“match”: {
“name”: “李四”
}
},
“_source”: [“name”,“desc”]
}
7.3 排序
GET /gorit/user/_search
{
“query”: {
“match”: {
“name”: “gorit”
}
},
“sort”: [
{
“age”: {
“order”: “desc”
}
}
]
}
7.4 分页查询
使用字段 from 和 size 进行分页查询,方式和 limit pageSize 是一模一样的
-
from 从第几页开始
-
返回多少条数据
GET /gorit/user/_search
{
“query”: {
“match”: {
“name”: “李四”
}
},
“sort”: [
{
“age”: {
“order”: “desc”
}
}
],
“from”: 0,
“size”: 1
}
7.5 filiter 区间查询
根据年龄的范围大小查询
GET /gorit/user/_search
{
“query”: {
“bool”: {
“must”: [
{
“match”: {
“name”: “gorit”
}
}
],
“filter”: [
{
“range”: {
“age”: {
“gte”: 1,
“lte”: 25
}
}
}
]
}
}
}
-
gt 大于
-
gte 大于等于
-
lt 小于
-
lte 小于等于
7.6 布尔值查询
must (and), 所有的条件都要符合 where id=1 and name = xxx
布尔查询
GET /gorit/user/_search
{
“query”: {
“bool”: {
“must”: [
{
“match”: {
“name”: “gorit”
}
},{
“match”: {
“age”: “16”
}
}
]
}
}
}
7.7 匹配多个条件
同时匹配即可
多个条件用空格隔开,只要满足一个即可被查出,这个时候可以根据分值判断
GET /gorit/user/_search
{
“query”: {
“match”: {
“tags”: “Java Python”
}
}
}
7.7 精确查询
term 查询是直接通过倒排索引指定的词条进程精确的查找的!
关于分词
-
term,直接精确查询
-
match:会使用分词器解析!!(先分析文档,然后通过分析的文档进行查询!!!)
两个类型 text keyword
结论:
-
text 可分
-
keyword 不可再分
7.8 高亮查询
高亮查询, 搜索的结果,可以高亮显示, 也能添加自定义高亮条件
GET /gorit/user/_search
{
“query”: {
“match”: {
“name”: “Gorit”
}
},
“highlight”: {
“pre_tags”: “
”,
“post_tags”: “”,
“fields”: {
“name”: {}
}
}
}
响应结果
#! Deprecation: [types removal] Specifying types in search requests is deprecated.
{
“took” : 2,
“timed_out” : false,
“_shards” : {
“total” : 1,
“successful” : 1,
“skipped” : 0,
“failed” : 0
},
“hits” : {
“total” : {
“value” : 1,
“relation” : “eq”
},
“max_score” : 1.6375021,
“hits” : [
{
“_index” : “gorit”,
“_type” : “user”,
“_id” : “6”,
“_score” : 1.6375021,
“_source” : {
“name” : “Gorit”,
“age” : 16,
“desc” : “运维工程师”,
“tags” : [
“Linux”,
“c++”,
“python”
]
},
“highlight” : {
“name” : [
“
Gorit
”]
}
}
]
}
}
这些 MySQL 也可以做,只是 MySQL 效率更低
-
匹配
-
按照条件匹配
-
精确匹配
-
区间范围匹配
-
匹配字段过滤
-
多条件查询
-
高亮查询
-
倒排索引
==============================================================================
找官方文档
具体测试
-
创建索引
-
判断索引是否存在
-
删除索引
-
创建文档
-
操作文档
// 坐标依赖
org.springframework.boot
spring-boot-starter-data-elasticsearch
// 核心代码
package cn.gorit;
import cn.gorit.pojo.User;
import com.alibaba.fastjson.JSON;
import javafx.scene.control.IndexRange;
import org.apache.lucene.util.QueryBuilder;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContent;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.json.JSONObject;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.codec.cbor.Jackson2CborDecoder;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;
/**
- es 7.6.2 API 测试
*/
@SpringBootTest
class DemoApplicationTests {
// 名称匹配
@Autowired
@Qualifier(“restHighLevelClient”)
private RestHighLevelClient client;
@Test
void contextLoads() {
}
// 索引的创建
@Test
void testCreateIndex() throws IOException {
// 1. 创建索引请求 等价于 PUT /gorit_index
CreateIndexRequest request = new CreateIndexRequest(“gorit_index”);
// 2. 执行创建请求 IndicesClient, 请求后获得响应
CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
System.out.println(response);
}
// 测试获取索引,判断其是否存在
@Test
void testGetIndexExist() throws IOException {
GetIndexRequest request = new GetIndexRequest(“gorit_index”);
boolean exist = client.indices().exists(request,RequestOptions.DEFAULT);
System.out.println(exist);
}
// 删除索引
@Test
void testDeleteIndex() throws IOException {
DeleteIndexRequest request = new DeleteIndexRequest(“gorit_index”);
// 删除
AcknowledgedResponse delete = client.indices().delete(request,RequestOptions.DEFAULT);
System.out.println(delete.isAcknowledged());
}
// 添加文档
@Test
void testAddDocument() throws IOException {
// 创建对象
User u = new User(“Gorit”,3);
// 创建请求
IndexRequest request = new IndexRequest(“gorit_index”);
// 规则 PUT /gorit_index/_doc/1
request.id(“1”);
request.timeout(TimeValue.timeValueSeconds(3));
request.timeout(“1s”);
// 将数据放入请求 json
IndexRequest source = request.source(JSON.toJSONString(u), XContentType.JSON);
// 客户端发送请求
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
System.out.println(response.toString());
System.out.println(response.status());// 返回对应的状态 CREATED
}
// 获取文档,判断存在 get /index/_doc/1
@Test
void testIsExists() throws IOException {
GetRequest getRequest = new GetRequest(“gorit_index”, “1”);
// 不获取返回的 _source 的上下文了
getRequest.fetchSourceContext(new FetchSourceContext(false));
getRequest.storedFields(“none”);
boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
System.out.println(exists);
}
// 获取文档信息
@Test
void testGetDocument() throws IOException {
GetRequest getRequest = new GetRequest(“gorit_index”, “1”);
GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
// 打印文档的内容
System.out.println(getResponse.getSourceAsString());
System.out.println(getResponse); // 返回全部的内容和命令是一样的
}
// 更新文档信息
@Test
void testUpdateDocument() throws IOException {
UpdateRequest updateRequest = new UpdateRequest(“gorit_index”, “1”);
updateRequest.timeout(“1s”);
User user = new User(“CodingGoirt”, 18);
updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);
// 打印文档的内容
System.out.println(updateResponse.status());
System.out.println(updateResponse); // 返回全部的内容和命令是一样的
}
// 删除文档记录
@Test
void testDeleteDocument() throws IOException {
DeleteRequest deleteRequest = new DeleteRequest(“gorit_index”, “1”);
deleteRequest.timeout(“1s”);
DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);
// 打印文档的内容
System.out.println(deleteResponse.status());
System.out.println(deleteResponse); // 返回全部的内容和命令是一样的
}
// 特殊的,真的项目。 批量插入数据
@Test
void testBulkRequest() throws IOException {
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.timeout(“10s”);
ArrayList userList = new ArrayList<>();
userList.add(new User(“张三1”,1));
userList.add(new User(“张三2”,2));
userList.add(new User(“张三3”,3));
userList.add(new User(“张三4”,4));
userList.add(new User(“张三5”,5));
userList.add(new User(“张三6”,6));
userList.add(new User(“张三7”,7));
// 批处理请求
for (int i=0;i<userList.size();i++) {
// 批量更新,批量删除,就在这里修改为对应的请求即可
bulkRequest.add(new IndexRequest(“gorit_index”)
.id(“”+(i+1))
.source(JSON.toJSONString(userList.get(i)),XContentType.JSON));
}
BulkResponse bulkItemResponses = client.bulk(bulkRequest, RequestOptions.DEFAULT);
System.out.println(bulkItemResponses.hasFailures()); // 是否失败
System.out.println(bulkItemResponses.status());
}
// 查询
// SearchRequest 搜索请求
// SearchSourceBuilder条件构造
// HighlightBuilder 构建高亮
// TermQueryBuilder 精确查询
// MatchAllQueryBuilder
// xxx QueryBuilder
@Test
void testSearch() throws IOException {
SearchRequest searchRequest = new SearchRequest(“gorit_index”);
// 构建搜索的条件
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
/**
-
查询条件 使用 QueryBuilders 工具类来实现
-
QueryBuilders.termQuery 精确
-
QueryBuilders.matchAllQueryBuilder() 匹配所有
*/
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“name”, “gorit1”);//精确查询
// MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
sourceBuilder.query(termQueryBuilder);
// 分页
sourceBuilder.from();
sourceBuilder.size();
sourceBuilder.highlighter(); // 设置高亮
sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
// 构建搜索
searchRequest.source(sourceBuilder);
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
System.out.println(JSON.toJSONString(searchResponse.getHits()));
System.out.println(“==========================================”);
for (SearchHit documentFields: searchResponse.getHits().getHits()) {
System.out.println(documentFields.getSourceAsMap());
}
}
}
===================================================================
项目依赖
org.jsoup
jsoup
1.10.2
com.alibaba
fastjson
1.2.68
org.springframework.boot
spring-boot-starter-data-elasticsearch
org.springframework.boot
spring-boot-starter-thymeleaf
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-devtools
runtime
true
org.springframework.boot
spring-boot-configuration-processor
true
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
爬虫
配置文件
package cn.gorit.config;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
-
Spring 步骤
-
- 找对象
-
- 放到 spring 中使用
-
- 分析源码
-
@Classname ElasticSearchConfig
-
@Description TODO
-
@Date 2020/10/21 17:20
-
@Created by CodingGorit
-
@Version 1.0
*/
@Configuration // xml -bean
public class ElasticSearchConfig {
@Bean
public RestHighLevelClient restHighLevelClient() {
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost(“localhost”, 9200, “http”)
)
);
return client;
}
}
爬取京东搜索的内容
config 配置类
package cn.gorit.util;
import cn.gorit.pojo.Content;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.springframework.stereotype.Component;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
/**
-
@Classname HtmlParseUtil
-
@Description TODO
-
@Date 2020/10/21 23:17
-
@Created by CodingGorit
-
@Version 1.0
*/
@Component
public class HtmlParseUtil {
// public static void main(String[] args) throws Exception {
// new HtmlParseUtil().parseJD(“英语”).forEach(System.out::println);
// }
public List parseJD(String keyword) throws Exception {
// 请求 url
// 联网,不能获取 ajax 数据
String url = “https://search.jd.com/Search?keyword=wd&enc=utf-8”;
// 解析网页 (返回的 Document 对象)
Document document = Jsoup.parse(new URL(url.replace(“wd”,keyword)),30000);
// 获取所有节点标签
Element element = document.getElementById(“J_goodsList”);
// 获取所有的 li 元素
Elements elements = element.getElementsByTag(“li”);
// 获取元素中的内容
List goodsList = new ArrayList<>();
for (Element e: elements) {
String img = e.getElementsByTag(“img”).eq(0).attr(“data-lazy-img”);
String price = e.getElementsByClass(“p-price”).eq(0).text();
String title = e.getElementsByClass(“p-name”).eq(0).text();
goodsList.add(new Content(title,img,price));
// System.out.println(img);
// System.out.println(price);
// System.out.println(title);
}
return goodsList;
}
}
Service 方法
package cn.gorit.service;
import cn.gorit.pojo.Content;
import cn.gorit.util.HtmlParseUtil;
import com.alibaba.fastjson.JSON;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
-
@Classname ContentService
-
@Description TODO
-
@Date 2020/10/22 18:44
-
@Created by CodingGorit
-
@Version 1.0
*/
@Service
public class ContentService {
@Autowired
private RestHighLevelClient restHighLevelClient;
// 不能直接使用,只要 Spring 容器
public static void main(String[] args) throws Exception {
new ContentService().parseContent(“java”);
}
// 1. 解析数据放入 es 索引中
public Boolean parseContent (String keywords) throws Exception {
// 获取查询到的列表的信息
List contents = new HtmlParseUtil().parseJD(keywords);
// 把查询到的数据放入 es 中
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.timeout(“2m”);
for (int i=0;i < contents.size();++i) {
bulkRequest.add(
new IndexRequest(“jd_goods”)
.source(JSON.toJSONString(contents.get(i)),XContentType.JSON));
}
BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
return !bulkResponse.hasFailures();
}
// 2. 获取这些数据,实现基本的搜索功能
public List<Map<String,Object>> searchPagehighLight (String keyword, int pageNo,int pageSize) throws IOException {
if (pageNo <= 1)
pageNo = 1;
// 条件清晰
SearchRequest searchRequest = new SearchRequest(“jd_goods”);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.from(pageNo);
builder.size(pageSize);
// 精准匹配
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“title”,keyword);
builder.query(termQueryBuilder);
builder.timeout(new TimeValue(60, TimeUnit.SECONDS));
// 高亮
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.field(“title”);
highlightBuilder.requireFieldMatch(false);
highlightBuilder.preTags(“”);
highlightBuilder.postTags(“”);
builder.highlighter(highlightBuilder);
// 执行搜索
searchRequest.source(builder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
// 解析结果
ArrayList<Map<String,Object>> list= new ArrayList<>();
for (SearchHit hit: searchResponse.getHits().getHits()) {
// 解析高亮的字段
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
HighlightField title = highlightFields.get(“title”);
Map<String,Object> sourceAsMap = hit.getSourceAsMap();// 原来的结果
// 解析高亮字段,将原来的字段换成我们高亮的字段即可
if (title != null) {
Text[] fragments = title.fragments();
StringBuilder nTitle = new StringBuilder();
for (Text text:fragments) {
nTitle.append(text);
}
sourceAsMap.put(“title”,nTitle);
}
list.add(hit.getSourceAsMap()); // 高亮的字段替换为原来的内容即可
}
return list;
}
// 2. 获取这些数据,实现基本的搜索功能
public List<Map<String,Object>> searchPage (String keyword, int pageNo,int pageSize) throws IOException {
if (pageNo <= 1)
pageNo = 1;
// 条件清晰
SearchRequest searchRequest = new SearchRequest(“jd_goods”);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.from(pageNo);
builder.size(pageSize);
// 精准匹配
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“title”,keyword);
builder.query(termQueryBuilder);
builder.timeout(new TimeValue(60, TimeUnit.SECONDS));
// 执行搜索
searchRequest.source(builder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
// 解析结果
ArrayList<Map<String,Object>> list= new ArrayList<>();
for (SearchHit hit: searchResponse.getHits().getHits()) {
list.add(hit.getSourceAsMap()); // 高亮的字段替换为原来的内容即可
}
return list;
}
}
Controller
package cn.gorit.controller;
import cn.gorit.pojo.Content;
import cn.gorit.service.ContentService;
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
null) {
Text[] fragments = title.fragments();
StringBuilder nTitle = new StringBuilder();
for (Text text:fragments) {
nTitle.append(text);
}
sourceAsMap.put(“title”,nTitle);
}
list.add(hit.getSourceAsMap()); // 高亮的字段替换为原来的内容即可
}
return list;
}
// 2. 获取这些数据,实现基本的搜索功能
public List<Map<String,Object>> searchPage (String keyword, int pageNo,int pageSize) throws IOException {
if (pageNo <= 1)
pageNo = 1;
// 条件清晰
SearchRequest searchRequest = new SearchRequest(“jd_goods”);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.from(pageNo);
builder.size(pageSize);
// 精准匹配
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(“title”,keyword);
builder.query(termQueryBuilder);
builder.timeout(new TimeValue(60, TimeUnit.SECONDS));
// 执行搜索
searchRequest.source(builder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
// 解析结果
ArrayList<Map<String,Object>> list= new ArrayList<>();
for (SearchHit hit: searchResponse.getHits().getHits()) {
list.add(hit.getSourceAsMap()); // 高亮的字段替换为原来的内容即可
}
return list;
}
}
Controller
package cn.gorit.controller;
import cn.gorit.pojo.Content;
import cn.gorit.service.ContentService;
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-xDst8jsb-1715670182179)]
[外链图片转存中…(img-BKADkxOQ-1715670182180)]
[外链图片转存中…(img-VBYRueik-1715670182180)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!