Elasticsearch
需要安装elasticsearch和Kibana，应为Kibana中有一套控制台可以方便的进行操作。
安装elasticsearch
使用docker命令安装：
docker run -d \
--name es \
-e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \ //设置他的运行内存空间，不要低于512否则出问题
-e "discovery.type=single-node" \ //设置安装模式，当前为单点模式，而非集群模式。
-v es-data:/usr/share/elasticsearch/data \
-v es-plugins:/usr/share/elasticsearch/plugins \
--privileged \
--network hm-net \
-p 9200:9200 \
-p 9300:9300 \ //集群通信的端口。
elasticsearch:7.12.1安装Kibana
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=hm-net \
-p 5601:5601 \
kibana:7.12.1
通过kibana向es发送Http请求。
倒排索引
小结：
IK分词器
安装
在线安装：
docker exec -it es ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip重启：
docker restart es线下安装：
首先，查看之前安装的Elasticsearch容器的plugins数据卷目录：
docker volume inspect es-plugins结果如下：
[
{
"CreatedAt": "2024-11-06T10:06:34+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/es-plugins/_data",
"Name": "es-plugins",
"Options": null,
"Scope": "local"
}
]可以看到elasticsearch的插件挂载到了/var/lib/docker/volumes/es-plugins/_data这个目录。我们需要把IK分词器上传至这个目录。
找到课前资料提供的ik分词器插件，课前资料提供了7.12.1版本的ik分词器压缩文件，你需要对其解压：
然后上传至虚拟机的/var/lib/docker/volumes/es-plugins/_data这个目录
重启es容器：
docker restart esIK分词器包含两种模式：
-
ik_smart：智能语义切分 -
ik_max_word：最细粒度切分
POST /_analyze
{
"analyzer": "ik_smart",
"text": "黑马程序员学习java太棒了"
}结果：
{
"tokens" : [
{
"token" : "黑马",
"start_offset" : 0,
"end_offset" : 2,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "程序员",
"start_offset" : 2,
"end_offset" : 5,
"type" : "CN_WORD",
"position" : 1
},
{
"token" : "学习",
"start_offset" : 5,
"end_offset" : 7,
"type" : "CN_WORD",
"position" : 2
},
{
"token" : "java",
"start_offset" : 7,
"end_offset" : 11,
"type" : "ENGLISH",
"position" : 3
},
{
"token" : "太棒了",
"start_offset" : 11,
"end_offset" : 14,
"type" : "CN_WORD",
"position" : 4
}
]
}
由于互联网词汇不断增多，需要拓展词汇库。
所以要想正确分词，IK分词器的词库也需要不断的更新，IK分词器提供了扩展词汇的功能。
1）打开IK分词器config目录：
注意，如果采用在线安装的通过，默认是没有config目录的，需要把课前资料提供的ik下的config上传至对应目录。
在IKAnalyzer.cfg.xml配置文件内容添加：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>IK Analyzer 扩展配置</comment>
<!--用户可以在这里配置自己的扩展字典 *** 添加扩展词典-->
<entry key="ext_dict">ext.dic</entry>
</properties>在IK分词器的config目录新建一个 ext.dic，可以参考config目录下复制一个配置文件进行修改：
传智播客
泰裤辣重启elasticsearch
docker restart es再次测试，可以发现传智播客和泰裤辣都正确分词了：
{
"tokens" : [
{
"token" : "传智播客",
"start_offset" : 0,
"end_offset" : 4,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "开设",
"start_offset" : 4,
"end_offset" : 6,
"type" : "CN_WORD",
"position" : 1
},
{
"token" : "大学",
"start_offset" : 6,
"end_offset" : 8,
"type" : "CN_WORD",
"position" : 2
},
{
"token" : "真的",
"start_offset" : 9,
"end_offset" : 11,
"type" : "CN_WORD",
"position" : 3
},
{
"token" : "泰裤辣",
"start_offset" : 11,
"end_offset" : 14,
"type" : "CN_WORD",
"position" : 4
}
]
}总结
分词器的作用是什么？
-
创建倒排索引时，对文档分词
-
用户搜索时，对输入的内容分词
IK分词器有几种模式？
-
ik_smart：智能切分，粗粒度 -
ik_max_word：最细切分，细粒度
IK分词器如何拓展词条？如何停用词条？
-
利用config目录的
IkAnalyzer.cfg.xml文件添加拓展词典和停用词典 -
在词典中添加拓展词条或者停用词条
基础概念
索引库操作
Mapping映射属性
索引库操作
Restful规范
索引库操作
创建索引库：
基本语法：
-
请求方式：
PUT -
请求路径：
/索引库名，可以自定义 -
请求参数：
mapping映射
格式：
PUT /索引库名称
{
"mappings": {
"properties": {
"字段名":{
"type": "text",
"analyzer": "ik_smart"
},
"字段名2":{
"type": "keyword",
"index": "false"
},
"字段名3":{
"properties": {
"子字段": {
"type": "keyword"
}
}
},
// ...略
}
}
}实例代码
PUT /hmall
{
"mappings": {
"properties": {
"info":{
"type": "text",
"analyzer": "ik_smart"
},
"email":{
"type": "keyword",
"index": false
},
"name":{
"properties": {
"firstName":{
"type":"keyword"
},
"lastName":{
"type":"keyword"
}
}
}
}
}
}返回结果：
{
"acknowledged" : true,
"shards_acknowledged" : true,
"index" : "hmall"
}查询索引库
基本语法：
-
请求方式：GET
-
请求路径：/索引库名
-
请求参数：无
格式
GET /索引库名实例代码
GET /hmall查询结果：
{
"hmall" : {
"aliases" : { },
"mappings" : {
"properties" : {
"email" : {
"type" : "keyword",
"index" : false
},
"info" : {
"type" : "text",
"analyzer" : "ik_smart"
},
"name" : {
"properties" : {
"firstName" : {
"type" : "keyword"
},
"lastName" : {
"type" : "keyword"
}
}
}
}
},
"settings" : {
"index" : {
"routing" : {
"allocation" : {
"include" : {
"_tier_preference" : "data_content"
}
}
},
"number_of_shards" : "1",
"provided_name" : "hmall",
"creation_date" : "1731489076840",
"number_of_replicas" : "1",
"uuid" : "KJqNTGY9RhiqFHkliRdGcw",
"version" : {
"created" : "7120199"
}
}
}
}
}修改索引库
倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库一旦创建，无法修改mapping。
虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。因此修改索引库能做的就是向索引库中添加新字段，或者更新索引库的基础属性。
语法说明：
PUT /索引库名/_mapping
{
"properties": {
"新字段名":{
"type": "integer"
}
}
}添加字段：
PUT /hmall/_mapping
{
"properties": {
"age":{
"type": "integer"
}
}
}返回结果：
{
"acknowledged" : true
}删除索引库
语法：
-
请求方式：DELETE
-
请求路径：/索引库名
-
请求参数：无
语法格式
DELETE /索引库名删除库
DELETE /hmall执行结果
{
"acknowledged" : true
}
索引库操作总结：
索引库操作有哪些？
-
创建索引库：PUT /索引库名
-
查询索引库：GET /索引库名
-
删除索引库：DELETE /索引库名
-
修改索引库，添加字段：PUT /索引库名/_mapping
可以看到，对索引库的操作基本遵循的Restful的风格，因此API接口非常统一，方便记忆。
文档操作
新增文档
语法规范
POST /索引库名/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
"字段3": {
"子属性1": "值3",
"子属性2": "值4"
},
}实例代码
POST /hmall/_doc/1
{
"info": "黑马程序员Java讲师",
"email": "zy@itcast.cn",
"name": {
"firstName": "云",
"lastName": "赵"
}
}运行结果
{
"_index" : "hmall",
"_type" : "_doc",
"_id" : "1",
"_version" : 8,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 8,
"_primary_term" : 1
}查询文档
语法规范
GET /{索引库名称}/_doc/{id}实例代码
GET /hmall/_doc/1运行结果
{
"_index" : "hmall",
"_type" : "_doc",
"_id" : "1",
"_version" : 8,
"_seq_no" : 8,
"_primary_term" : 1,
"found" : true,
"_source" : {
"info" : "黑马程序员Java讲师",
"email" : "zy@itcast.cn",
"name" : {
"firstName" : "云",
"lastName" : "赵"
}
}
}
删除文档
语法规范
DELETE /{索引库名}/_doc/id值实例代码
DELETE /hmall/_doc/1运行结果
{
"_index" : "hmall",
"_type" : "_doc",
"_id" : "1",
"_version" : 9,
"result" : "deleted",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 9,
"_primary_term" : 1
}
修改文档
全量修改
语法规范
PUT /{索引库名}/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
// ... 略
}实例代码
#全量修改
PUT /hmall/_doc/1
{
"info": "黑马程序员Python讲师",
"email": "ls@itcast.cn",
"name": {
"firstName": "四",
"lastName": "李"
}
}运行结果
第一次运行，由于前面已经删除了该文档所以 执行类型为 created.
{
"_index" : "hmall",
"_type" : "_doc",
"_id" : "1",
"_version" : 10,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 10,
"_primary_term" : 1
}第二次运行，为修改返回的类型为 updated。
{
"_index" : "hmall",
"_type" : "_doc",
"_id" : "1",
"_version" : 11,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 11,
"_primary_term" : 1
}部分修改
语法规范
POST /{索引库名}/_update/文档id
{
"doc": {
"字段名": "新的值",
}
}实例代码
#局部修改
POST /hmall/_update/1
{
"doc": {
"email":"ZhaoYuen@itcast.com"
}
}运行结果
{
"_index" : "hmall",
"_type" : "_doc",
"_id" : "1",
"_version" : 12,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 1,
"failed" : 0
},
"_seq_no" : 12,
"_primary_term" : 1
}当前文档的数据：
{
"_index" : "hmall",
"_type" : "_doc",
"_id" : "1",
"_version" : 12,
"_seq_no" : 12,
"_primary_term" : 1,
"found" : true,
"_source" : {
"info" : "黑马程序员Python讲师",
"email" : "ZhaoYuen@itcast.com",
"name" : {
"firstName" : "四",
"lastName" : "李"
}
}
}文档基础操作小结
文档批量处理
-
index代表新增操作-
_index：指定索引库名 -
_id指定要操作的文档id -
{ "field1" : "value1" }：则是要新增的文档内容
-
-
delete代表删除操作-
_index：指定索引库名 -
_id指定要操作的文档id
-
-
update代表更新操作-
_index：指定索引库名 -
_id指定要操作的文档id -
{ "doc" : {"field2" : "value2"} }：要更新的文档字段
-
#批量新增
POST /_bulk
{"index": {"_index":"hmall", "_id": "3"}}
{"info": "黑马程序员C++讲师", "email": "ww@itcast.cn", "name":{"firstName": "五", "lastName":"王"}}
{"index": {"_index":"hmall", "_id": "4"}}
{"info": "黑马程序员前端讲师", "email": "zhangsan@itcast.cn", "name":{"firstName": "三", "lastName":"张"}}
POST /_bulk
{"delete":{"_index":"hmall", "_id": "3"}}
{"delete":{"_index":"hmall", "_id": "4"}}JavaRestClient
作用：向restful接口发送请求。
客户端初始化
1）在item-service模块中引入es的RestHighLevelClient依赖：
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>2）因为SpringBoot默认的ES版本是7.17.10，所以我们需要覆盖默认的ES版本：
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<elasticsearch.version>7.12.1</elasticsearch.version>
</properties>3）初始化RestHighLevelClient：
初始化的代码如下：
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.150.101:9200")
));4)创建一个测试用例来实现
package com.hmall.item.es;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import java.io.IOException;
public class Test {
private RestHighLevelClient client;
//创建开始初始化函数，对客户端进行初始化
@BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.21.101:9200")));
}
//测试代码
@org.junit.jupiter.api.Test
public void test(){
System.out.println(client);
}
//测试用例结束后释放资源
@AfterEach
void tearDown() throws IOException {
client.close();
}
}
商品Mapping映射
分析那些字段需要添加到文档中。
根据分析编写的需求：
PUT /hmall
{
"mappings": {
"properties": {
"id":{
"type": "keyword"
},
"name":{
"type": "text",
"analyzer": "ik_smart"
},
"price":{
"type": "integer"
},
"image":{
"type": "keyword",
"index": false
},
"category":{
"type": "keyword"
},
"brand":{
"type": "keyword"
},
"sold":{
"type": "integer"
},
"commentCount":{
"type": "integer",
"index": false
},
"isAD":{
"type": "boolean"
},
"updateTime":{
"type": "date"
}
}
}
}索引库操作
创建索引库：
//创建索引库
@org.junit.jupiter.api.Test
public void testCreateIndex() throws IOException {
//创建Requst对象
CreateIndexRequest request = new CreateIndexRequest("items");
//准备参数 ,将编写的JSON字符串赋值给MAPPINF_JSON，XContentType.JSON用于指定是JSON格式
request.source(MAPPINF_JSON, XContentType.JSON);
//发送请求，RequestOptions.DEFAULT为是否有自定义配置，选择默认
client.indices().create(request, RequestOptions.DEFAULT);
}
private final String MAPPINF_JSON = "{\n" +
" \"mappings\": {\n" +
" \"properties\": {\n" +
" \"id\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"name\":{\n" +
" \"type\": \"text\",\n" +
" \"analyzer\": \"ik_smart\"\n" +
" },\n" +
" \"price\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"image\":{\n" +
" \"type\": \"keyword\",\n" +
" \"index\": false\n" +
" },\n" +
" \"category\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"brand\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"sold\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"commentCount\":{\n" +
" \"type\": \"integer\",\n" +
" \"index\": false\n" +
" },\n" +
" \"isAD\":{\n" +
" \"type\": \"boolean\"\n" +
" },\n" +
" \"updateTime\":{\n" +
" \"type\": \"date\"\n" +
" }\n" +
" }\n" +
" }\n" +
"}";删除索引库
//删除索引库
@org.junit.jupiter.api.Test
public void testDeleteIndex() throws IOException {
//创建Requst对象
DeleteIndexRequest request = new DeleteIndexRequest("items");
//发送请求
client.indices().delete(request,RequestOptions.DEFAULT);
}查看索引库
//查找索引库
@org.junit.jupiter.api.Test
public void testGetIndex() throws IOException {
//创建Requst对象
GetIndexRequest request = new GetIndexRequest("items");
//发送2请求
// client.indices().get(request, RequestOptions.DEFAULT);
//由于GEt请求返回的数据较多，如果只需要判断是否存在，则使用exists方法
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
System.out.println("exists = " + exists);
}文档操作
新增文档
由于索引库结构与数据库结构还存在一些差异，因此我们要定义一个索引库结构对应的实体。
package com.hmall.item.domain.po;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.time.LocalDateTime;
@Data
@ApiModel(description = "索引库实体")
public class ItemDoc{
@ApiModelProperty("商品id")
private String id;
@ApiModelProperty("商品名称")
private String name;
@ApiModelProperty("价格（分）")
private Integer price;
@ApiModelProperty("商品图片")
private String image;
@ApiModelProperty("类目名称")
private String category;
@ApiModelProperty("品牌名称")
private String brand;
@ApiModelProperty("销量")
private Integer sold;
@ApiModelProperty("评论数")
private Integer commentCount;
@ApiModelProperty("是否是推广广告，true/false")
private Boolean isAD;
@ApiModelProperty("更新时间")
private LocalDateTime updateTime;
}API语法
POST /{索引库名}/_doc/1
{
"name": "Jack",
"age": 21
}
可以看到与索引库操作的API非常类似，同样是三步走：
-
1）创建Request对象，这里是
IndexRequest，因为添加文档就是创建倒排索引的过程 -
2）准备请求参数，本例中就是Json文档
-
3）发送请求
变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。
//新增文档
@org.junit.jupiter.api.Test
public void test() throws IOException {
//读取数据库获取商品信息
Item item = service.getById(317578);
//将商品信息对象转换为Dto
ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
//将对象转换为JSON
String jsonStr = JSONUtil.toJsonStr(itemDoc);
//创建Requst对象
IndexRequest request = new IndexRequest("items").id(itemDoc.getId());
request.source(jsonStr, XContentType.JSON);
//发送信息
client.index(request, RequestOptions.DEFAULT);
}
package com.hmall.item.es;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONUtil;
import com.hmall.item.domain.dto.ItemDoc;
import com.hmall.item.domain.po.Item;
import com.hmall.item.service.impl.ItemServiceImpl;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
@SpringBootTest(properties = {"spring.profiles.active=local"})
public class docTest {
private RestHighLevelClient client;
@Autowired
private ItemServiceImpl service;
//创建开始初始化函数，对客户端进行初始化
@BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.21.101:9200")));
}
//新增文档,全局修改文档
@org.junit.jupiter.api.Test
public void test() throws IOException {
//读取数据库获取商品信息
Item item = service.getById(317578);
//将商品信息对象转换为Dto
ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
//将对象转换为JSON
String jsonStr = JSONUtil.toJsonStr(itemDoc);
//创建Requst对象
IndexRequest request = new IndexRequest("items").id(itemDoc.getId());
request.source(jsonStr, XContentType.JSON);
//发送信息
client.index(request, RequestOptions.DEFAULT);
}
//查看文档
@org.junit.jupiter.api.Test
public void testGet() throws IOException {
//创建Requst对象
GetRequest request = new GetRequest("items","317578");
//发送信息
GetResponse response = client.get(request, RequestOptions.DEFAULT);
String json = response.getSourceAsString();
ItemDoc bean = JSONUtil.toBean(json, ItemDoc.class);
System.out.println("bean = " + bean);
}
//删除文档
@org.junit.jupiter.api.Test
public void testdelect() throws IOException {
//创建Requst对象
DeleteRequest request = new DeleteRequest("items","317578");
//发送信息
client.delete(request, RequestOptions.DEFAULT);
}
//修改文档
@org.junit.jupiter.api.Test
public void testupdata2() throws IOException {
//创建Requst对象
UpdateRequest request = new UpdateRequest("items","317578");
//数据都是独立的不是成对出现的
request.doc(
"price", 10000
);
//发送信息
client.update(request, RequestOptions.DEFAULT);
}
//测试用例结束后释放资源
@AfterEach
void tearDown() throws IOException {
client.close();
}
}
批量操作文档
//新增文档,全局修改文档
@org.junit.jupiter.api.Test
public void testBulk() throws IOException {
//设置分页信息
int size = 1000,pageNo = 1;
//循环写入数据
while (true){
//读取数据库获取商品信息分页查询
//设置当前查询条件，即状态为起售
//创建分页对象
Page<Item> page = service.lambdaQuery().eq(Item::getStatus, 1).page(new Page<Item>(pageNo, size));
List<Item> records = page.getRecords();
//判空
if (records.isEmpty()||records == null){
return;
}
//创建Requst对象
// BulkRequest request = new BulkRequest();
// for (Item item : records) {
// request.add(new IndexRequest("items")
// .id(item.getId().toString())
// .source(JSONUtil.toJsonStr(BeanUtil.copyProperties(item, ItemDoc.class))),XContentType.JSON
// );
// }
BulkRequest request = new BulkRequest("items");
for (Item item : records) {
// 2.1.转换为文档类型ItemDTO
ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
// 2.2.创建新增文档的Request对象
request.add(new IndexRequest()
.id(itemDoc.getId())
.source(JSONUtil.toJsonStr(itemDoc), XContentType.JSON));
}
//发送信息
client.bulk(request, RequestOptions.DEFAULT);
pageNo++;
}
}
![[ 网络安全介绍 5 ] 为什么要学习网络安全？](https://i-blog.csdnimg.cn/direct/c7e6039198cd498eb9fc2e2bd5d4e45e.png)
