Elasticsearch 入门 核心概念 分词器 javaAPI

1-今日内容

1. 初识 ElasticSearch
2. 安装 ElasticSearch
3. ElasticSearch 核心概念
4. 操作 ElasticSearch
5. ElasticSearch JavaAPI

2-初识ElasticSearch

2.1-基于数据库查询的问题

2.2-倒排索引

倒排索引：将文档进行分词，形成词条和id的对应关系即为反向索引。

以唐诗为例，所处包含“前”的诗句

正向索引：由《静夜思》–>窗前明月光—>“前”字

反向索引：“前”字–>窗前明月光–>《静夜思》

反向索引的实现就是对诗句进行分词，分成单个的词，由词推据，即为反向索引

“床前明月光”–> 分词

将一段文本按照一定的规则，拆分为不同的词条（term）

2.3-ES存储和查询的原理

index（索引）：相当于mysql的库

映射：相当于mysql 的表结构

document(文档)：相当于mysql的表中的数据

数据库查询存在的问题：

1. 性能低：使用模糊查询，左边有通配符，不会走索引，会全表扫描，性能低
2. 功能弱：如果以”华为手机“作为条件，查询不出来数据

Es使用倒排索引，对title 进行分词

2.4-ES概念详解

?ElasticSearch是一个基于Lucene的搜索服务器

?是一个分布式、高扩展、高实时的搜索与数据分析引擎

?基于RESTful web接口

?Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎

?官网：https://www.elastic.co/

应用场景

?搜索：海量数据的查询

?日志数据分析

?实时数据分析

3-安装ElasticSearch

1、上传ElasticSearch安装包

alt+p # 打开sftp窗口
# 上传es安装包
put e:/software/elasticsearch-7.4.0-linux-x86_64.tar.gz

2、执行解压操作 ，如下图

 # 将elasticsearch-7.4.0-linux-x86_64.tar.gz解压到opt文件夹下. -C 大写tar -zxvf elasticsearch-7.4.0-linux-x86_64.tar.gz  -C /opt

3、创建普通用户

因为安全问题，Elasticsearch 不允许root用户直接运行，所以要创建新用户，在root用户中创建新用户,执行如下命令：

useradd itheima  # 新增itheima用户
passwd  itheima  # 为itheima用户设置密码

5、为新用户授权，如下图

chown -R itheima:itheima /opt/elasticsearch-7.4.0 #文件夹所有者

将 /opt/elasticsearch-7.4.0文件夹授权给itheima用户，由上图可见，我们的文件夹权限赋给了itheima

6、修改elasticsearch.yml文件

vim /opt/elasticsearch-7.4.0/config/elasticsearch.yml 

# ======================== Elasticsearch Configuration =========================
cluster.name: my-application
node.name: node-1
network.host: 0.0.0.0
http.port: 9200
cluster.initial_master_nodes: ["node-1"]

cluster.name：配置elasticsearch的集群名称，默认是elasticsearch。建议修改成一个有意义的名称

node.name：节点名，elasticsearch会默认随机指定一个名字，建议指定一个有意义的名称，方便管理

network.host：设置为0.0.0.0允许外网访问

http.port：Elasticsearch的http访问端口

cluster.initial_master_nodes：初始化新的集群时需要此配置来选举master

7、修改配置文件

新创建的itheima用户最大可创建文件数太小，最大虚拟内存太小，切换到root用户，编辑下列配置文件， 添加类似如下内容

# 切换到root用户
su root #1. ===最大可创建文件数太小=======
vim /etc/security/limits.conf 
# 在文件末尾中增加下面内容
itheima soft nofile 65536
itheima hard nofile 65536
# =====
vim /etc/security/limits.d/20-nproc.conf
# 在文件末尾中增加下面内容
itheima soft nofile 65536
itheima hard nofile 65536
*  hard    nproc     4096
# 注：* 代表Linux所有用户名称 #2. ===最大虚拟内存太小=======
vim /etc/sysctl.conf
# 在文件中增加下面内容
vm.max_map_count=655360
# 重新加载，输入下面命令：
sysctl -p

8、启动elasticsearch

su itheima  # 切换到itheima用户启动
cd /opt/elasticsearch-7.4.0/bin
./elasticsearch #启动

通过上图我们可以看到elasticsearch已经成功启动

在访问elasticsearch前，请确保防火墙是关闭的，执行命令：

#暂时关闭防火墙
systemctl  stop  firewalld# 或者#永久设置防火墙状态
systemctl enable firewalld.service  #打开防火墙永久性生效，重启后不会复原 
systemctl disable firewalld.service #关闭防火墙，永久性生效，重启后不会复原 

浏览器输入http://192.168.149.135:9200/，如下图

此时elasticsearch已成功启动：

重点几个关注下即可:
number" : "7.4.0"   表示elasticsearch版本
lucene_version" : "8.2.0"  表示lucene版本
name ： 默认启动的时候指定了 ES 实例名称
cluster_name ： 默认名为 elasticsearch

Kibana安装

1、什么是Kibana

Kibana是一个针对Elasticsearch的开源分析及可视化平台，用来搜索、查看交互存储在Elasticsearch索引中的数据。使用Kibana，可以通过各种图表进行高级数据分析及展示。

Kibana让海量数据更容易理解。它操作简单，基于浏览器的用户界面可以快速创建仪表板（dashboard）实时显示Elasticsearch查询动态。

2、上传kibana

CRT中克隆一个窗口，上传Kibana

put ?E:\software\kibana-7.4.0-linux-x86_64.tar.gz

2、解压kibana

tar -xzf kibana-7.4.0-linux-x86_64.tar.gz -C /opt

解压到当前目录（/opt）下

3、修改kibana配置

vim /opt/kibana-7.4.0-linux-x86_64/config/kibana.yml

server.port: 5601
server.host: "0.0.0.0"
server.name: "kibana-itcast"
elasticsearch.hosts: ["http://127.0.0.1:9200"]
elasticsearch.requestTimeout: 99999

server.port：http访问端口

server.host：ip地址，0.0.0.0表示可远程访问

server.name：kibana服务名

elasticsearch.hosts：elasticsearch地址

elasticsearch.requestTimeout：请求elasticsearch超时时间，默认为30000，此处可根据情况设置

4、启动kibana

由于kibana不建议使用root用户启动，如果用root启动，需要加–allow-root参数

# 切换到kibana的bin目录
cd /opt/kibana-7.4.0-linux-x86_64/bin
# 启动
./kibana --allow-root

启动成功。

5、访问kibana

1.浏览器输入http://192.168.149.135:5601/，如下图：

http://192.168.149.135:5601/

看到这个界面，说明Kibanan已成功安装。

Discover：可视化查询分析器
Visualize：统计分析图表
Dashboard：自定义主面板（添加图表）
Timelion：Timelion是一个kibana时间序列展示组件（暂时不用）
Dev Tools：Console控制台（同CURL/POSTER，操作ES代码工具，代码提示，很方便）
Management：管理索引库(index)、已保存的搜索和可视化结果(save objects)、设置 kibana 服务器属性。

4-ElasticSearch核心概念

索引（index）

ElasticSearch存储数据的地方，可以理解成关系型数据库中的数据库概念。

映射（mapping）

mapping定义了每个字段的类型、字段所使用的分词器等。相当于关系型数据库中的表结构。

文档（document）

Elasticsearch中的最小数据单元，常以json格式显示。一个document相当于关系型数据库中的一行数据。

倒排索引

一个倒排索引由文档中所有不重复词的列表构成，对于其中每个词，对应一个包含它的文档id列表。

类型（type）

一种type就像一类表。如用户表、角色表等。在Elasticsearch7.X默认type为_doc

 \- ES 5.x中一个index可以有多种type。\- ES 6.x中一个index只能有一种type。\- ES 7.x以后，将逐步移除type这个概念，现在的操作已经不再使用，默认_doc

5-脚本操作ES

5.1-RESTful风格介绍

1.ST（Representational State Transfer），表述性状态转移，是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful。就是一种定义接口的规范。

2.基于HTTP。

3.使用XML格式定义或JSON格式定义。

4.每一个URI代表1种资源。

5.客户端使用GET、POST、PUT、DELETE 4个表示操作方式的动词对服务端资源进行操作：

GET：用来获取资源

POST：用来新建资源（也可以用于更新资源）

PUT：用来更新资源

DELETE：用来删除资源

5.2-操作索引

PUT

http://ip:端口/索引名称

查询

GET http://ip:端口/索引名称  # 查询单个索引信息
GET http://ip:端口/索引名称1,索引名称2...  # 查询多个索引信息
GET http://ip:端口/_all  # 查询所有索引信息

?删除索引

DELETE http://ip:端口/索引名称

?关闭、打开索引

POST http://ip:端口/索引名称/_close  
POST http://ip:端口/索引名称/_open 

5.3-ES数据类型

1. 简单数据类型

• 字符串

聚合：相当于mysql 中的sum（求和）

text：会分词，不支持聚合keyword：不会分词，将全部内容作为一个词条，支持聚合

• 数值

• 布尔：boolean

• 二进制：binary

• 范围类型

integer_range, float_range, long_range, double_range, date_range 

• 日期:date

2. 复杂数据类型

?数组：[ ] Nested: nested (for arrays of JSON objects 数组类型的JSON对象)

?对象：{ } Object: object(for single JSON objects 单个JSON对象)

5.4-操作映射

 PUT personGET person#添加映射PUT /person/_mapping{
    "properties":{
    "name":{
    "type":"text"},"age":{
    "type":"integer"}}}

#创建索引并添加映射

 #创建索引并添加映射PUT /person1
{
    "mappings": {
    "properties": {
    "name": {
    "type": "text"},"age": {
    "type": "integer"}}}
}GET person1/_mapping

添加字段

#添加字段
PUT /person1/_mapping
{
    "properties": {
    "name": {
    "type": "text"},"age": {
    "type": "integer"}}
}

5.5-操作文档

?添加文档，指定id

POST /person1/_doc/2
{
    "name":"张三","age":18,"address":"北京"
}GET /person1/_doc/1

?添加文档，不指定id

#添加文档，不指定id
POST /person1/_doc/
{
    "name":"张三","age":18,"address":"北京"
}#查询所有文档
GET /person1/_search

#删除指定id文档
DELETE /person1/_doc/1

6-分词器

?IKAnalyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包

?是一个基于Maven构建的项目

?具有60万字/秒的高速处理能力

?支持用户词典扩展定义

?下载地址：https://github.com/medcl/elasticsearch-analysis-ik/archive/v7.4.0.zip

安装包在资料文件夹中提供

6.2-ik分词器安装

1、环境准备

Elasticsearch 要使用 ik，就要先构建 ik 的 jar包，这里要用到 maven 包管理工具，而 maven 需要java 环境，而 Elasticsearch 内置了jdk， 所以可以将JAVA_HOME设置为Elasticsearch 内置的jdk

1）设置JAVA_HOME

vim /etc/profile
# 在profile文件末尾添加
#java environment
export JAVA_HOME=/opt/elasticsearch-7.4.0/jdk
export PATH=$PATH:${JAVA_HOME}/bin# 保存退出后，重新加载profile
source /etc/profile

2）下载maven安装包

wget http://mirror.cc.columbia.edu/pub/software/apache/maven/maven-3/3.1.1/binaries/apache-maven-3.6.3-bin.tar.gz  

3）解压maven安装包

tar xzf apache-maven-3.6.3-bin.tar.gz 

4）设置软连接

ln -s apache-maven-3.6.3 maven 

5）设置path

打开文件

 vim  /etc/profile.d/maven.sh

将下面的内容复制到文件，保存

export MAVEN_HOME=/opt/maven  
export PATH=${MAVEN_HOME}/bin:${PATH} 

设置好Maven的路径之后，需要运行下面的命令使其生效

source /etc/profile.d/maven.sh

6）验证maven是否安装成功

mvn -v

2、安装IK分词器

1）下载IK

wget https://github.com/medcl/elasticsearch-analysis-ik/archive/v7.4.0.zip

执行如下图：

2）解压IK

由于这里是zip包不是gz包，所以我们需要使用unzip命令进行解压，如果本机环境没有安装unzip，请执行：

yum install zip 
yum install unzip

解压IK

unzip v7.4.0.zip

3）编译jar包

# 切换到 elasticsearch-analysis-ik-7.4.0目录
cd elasticsearch-analysis-ik-7.4.0/
#打包
mvn package

4） jar包移动

package执行完毕后会在当前目录下生成target/releases目录，将其中的elasticsearch-analysis-ik-7.4.0.zip。拷贝到elasticsearch目录下的新建的目录plugins/analysis-ik，并解压

#切换目录
cd /opt/elasticsearch-7.4.0/plugins/
#新建目录
mkdir analysis-ik
cd analysis-ik
#执行拷贝
cp -R /opt/elasticsearch-analysis-ik-7.4.0/target/releases/elasticsearch-analysis-ik-7.4.0.zip      /opt/elasticsearch-7.4.0/plugins/analysis-ik
#执行解压
unzip  /opt/elasticsearch-7.4.0/plugins/analysis-ik/elasticsearch-analysis-ik-7.4.0.zip

5）拷贝辞典

将elasticsearch-analysis-ik-7.4.0目录下的config目录中的所有文件 拷贝到elasticsearch的config目录

cp -R /opt/elasticsearch-analysis-ik-7.4.0/config/*   /opt/elasticsearch-7.4.0/config

记得一定要重启Elasticsearch！！！

3、使用IK分词器

IK分词器有两种分词模式：ik_max_word和ik_smart模式。

1、ik_max_word

会将文本做最细粒度的拆分，比如会将“乒乓球明年总冠军”拆分为“乒乓球、乒乓、球、明年、总冠军、冠军。

#方式一ik_max_word
GET /_analyze
{
    "analyzer": "ik_max_word","text": "乒乓球明年总冠军"
}

ik_max_word分词器执行如下：

{
    "tokens" : [{
    "token" : "乒乓球","start_offset" : 0,"end_offset" : 3,"type" : "CN_WORD","position" : 0},{
    "token" : "乒乓","start_offset" : 0,"end_offset" : 2,"type" : "CN_WORD","position" : 1},{
    "token" : "球","start_offset" : 2,"end_offset" : 3,"type" : "CN_CHAR","position" : 2},{
    "token" : "明年","start_offset" : 3,"end_offset" : 5,"type" : "CN_WORD","position" : 3},{
    "token" : "总冠军","start_offset" : 5,"end_offset" : 8,"type" : "CN_WORD","position" : 4},{
    "token" : "冠军","start_offset" : 6,"end_offset" : 8,"type" : "CN_WORD","position" : 5}]
}

2、ik_smart
会做最粗粒度的拆分，比如会将“乒乓球明年总冠军”拆分为乒乓球、明年、总冠军。

#方式二ik_smart
GET /_analyze
{
    "analyzer": "ik_smart","text": "乒乓球明年总冠军"
}

ik_smart分词器执行如下：

{
    "tokens" : [{
    "token" : "乒乓球","start_offset" : 0,"end_offset" : 3,"type" : "CN_WORD","position" : 0},{
    "token" : "明年","start_offset" : 3,"end_offset" : 5,"type" : "CN_WORD","position" : 1},{
    "token" : "总冠军","start_offset" : 5,"end_offset" : 8,"type" : "CN_WORD","position" : 2}]
}

由此可见 使用ik_smart可以将文本"text": "乒乓球明年总冠军"分成了【乒乓球】【明年】【总冠军】

这样看的话，这样的分词效果达到了我们的要求。

执行如下命令时如果出现 打包失败（501码）将maven镜像换成阿里云的

mvn package

/opt/apache-maven-3.6.3/conf/setting.xml

	<mirror><id>alimaven</id><name>aliyun maven</name><url>http://maven.aliyun.com/nexus/content/groups/public/</url><mirrorOf>central</mirrorOf></mirror>

6.3-ik分词器使用

IK分词器有两种分词模式：ik_max_word和ik_smart模式。

1、ik_max_word

会将文本做最细粒度的拆分，比如会将“乒乓球明年总冠军”拆分为“乒乓球、乒乓、球、明年、总冠军、冠军。

#方式一ik_max_word
GET /_analyze
{
    "analyzer": "ik_max_word","text": "乒乓球明年总冠军"
}

ik_max_word分词器执行如下：

{
    "tokens" : [{
    "token" : "乒乓球","start_offset" : 0,"end_offset" : 3,"type" : "CN_WORD","position" : 0},{
    "token" : "乒乓","start_offset" : 0,"end_offset" : 2,"type" : "CN_WORD","position" : 1},{
    "token" : "球","start_offset" : 2,"end_offset" : 3,"type" : "CN_CHAR","position" : 2},{
    "token" : "明年","start_offset" : 3,"end_offset" : 5,"type" : "CN_WORD","position" : 3},{
    "token" : "总冠军","start_offset" : 5,"end_offset" : 8,"type" : "CN_WORD","position" : 4},{
    "token" : "冠军","start_offset" : 6,"end_offset" : 8,"type" : "CN_WORD","position" : 5}]
}

2、ik_smart
会做最粗粒度的拆分，比如会将“乒乓球明年总冠军”拆分为乒乓球、明年、总冠军。

#方式二ik_smart
GET /_analyze
{
    "analyzer": "ik_smart","text": "乒乓球明年总冠军"
}

ik_smart分词器执行如下：

{
    "tokens" : [{
    "token" : "乒乓球","start_offset" : 0,"end_offset" : 3,"type" : "CN_WORD","position" : 0},{
    "token" : "明年","start_offset" : 3,"end_offset" : 5,"type" : "CN_WORD","position" : 1},{
    "token" : "总冠军","start_offset" : 5,"end_offset" : 8,"type" : "CN_WORD","position" : 2}]
}

由此可见 使用ik_smart可以将文本"text": "乒乓球明年总冠军"分成了【乒乓球】【明年】【总冠军】

这样看的话，这样的分词效果达到了我们的要求。

6.4使用IK分词器-查询文档

?词条查询：term

? 词条查询不会分析查询条件，只有当词条和查询字符串完全匹配时才匹配搜索

?全文查询：match

? 全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

1.创建索引，添加映射，并指定分词器为ik分词器

PUT person2
{
    "mappings": {
    "properties": {
    "name": {
    "type": "keyword"},"address": {
    "type": "text","analyzer": "ik_max_word"}}}
}

2.添加文档

POST /person2/_doc/1
{"name":"张三","age":18,"address":"北京海淀区"
}POST /person2/_doc/2
{"name":"李四","age":18,"address":"北京朝阳区"
}POST /person2/_doc/3
{"name":"王五","age":18,"address":"北京昌平区"
}

3.查询映射

GET person2

4.查看分词效果

GET _analyze
{
    "analyzer": "ik_max_word","text": "北京海淀"
}

5.词条查询：term

查询person2中匹配到"北京"两字的词条

GET /person2/_search
{
    "query": {
    "term": {
    "address": {
    "value": "北京"}}}
}

6.全文查询：match

? 全文查询会分析查询条件，先将查询条件进行分词，然后查询，求并集

GET /person2/_search
{"query": {"match": {"address":"北京昌平"}}
}

7-ElasticSearch JavaApi

7.1SpringBoot整合ES

  <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.8.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-high-level-client</artifactId><version>7.4.0</version></dependency><dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-client</artifactId><version>7.4.0</version></dependency><dependency><groupId>org.elasticsearch</groupId><artifactId>elasticsearch</artifactId><version>7.4.0</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.51</version><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>

config

@Configuration
@ConfigurationProperties(prefix = "elasticsearch")
public class ElasticSearchConfig {
    private String host;private int port;public String getHost() {
    return host;}public void setHost(String host) {
    this.host = host;}public int getPort() {
    return port;}public void setPort(int port) {
    this.port = port;}@Beanpublic RestHighLevelClient client(){
    return new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.23.129",9200,"http")));}
}

Person

public class Person {
    private String id;private String name;private int age;private String address;public String getId() {
    return id;}public void setId(String id) {
    this.id = id;}public String getName() {
    return name;}public void setName(String name) {
    this.name = name;}public int getAge() {
    return age;}public void setAge(int age) {
    this.age = age;}public String getAddress() {
    return address;}public void setAddress(String address) {
    this.address = address;}@Overridepublic String toString() {
    return "Person{" +"id='" + id + '\'' +", name='" + name + '\'' +", age=" + age +", address='" + address + '\'' +'}';}
}

ElasticSearchApplication

@SpringBootApplication
public class ElasticSearchApplication {
    public static void main(String[] args) {
    SpringApplication.run(ElasticSearchApplication.class,args);}
}

resources

elasticsearch:host: 192.168.23.129port: 9200

Elasticsearch

package com.itheima.elasticsearchdemo;import com.alibaba.fastjson.JSON;
import com.itheima.domain.Person;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
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.support.master.AcknowledgedResponse;
import org.elasticsearch.client.IndicesClient;
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.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.io.IOException;
import java.util.HashMap;
import java.util.Map;@SpringBootTest
class ElasticsearchDemoApplicationTests {
    @Autowiredprivate RestHighLevelClient client;@Testvoid contextLoads() {
    /* //1.创建ES客户端对象RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.149.135",9200,"http")));*/System.out.println(client);}/*** 添加索引*/@Testpublic void addIndex() throws IOException {
    //1.使用client获取操作索引的对象IndicesClient indicesClient = client.indices();//2.具体操作，获取返回值CreateIndexRequest createRequest = new CreateIndexRequest("itheima");CreateIndexResponse response = indicesClient.create(createRequest, RequestOptions.DEFAULT);//3.根据返回值判断结果System.out.println(response.isAcknowledged());}/*** 添加索引*/@Testpublic void addIndexAndMapping() throws IOException {
    //1.使用client获取操作索引的对象IndicesClient indicesClient = client.indices();//2.具体操作，获取返回值CreateIndexRequest createRequest = new CreateIndexRequest("itcast");//2.1 设置mappingsString mapping = "{\n" +" \"properties\" : {\n" +" \"address\" : {\n" +" \"type\" : \"text\",\n" +" \"analyzer\" : \"ik_max_word\"\n" +" },\n" +" \"age\" : {\n" +" \"type\" : \"long\"\n" +" },\n" +" \"name\" : {\n" +" \"type\" : \"keyword\"\n" +" }\n" +" }\n" +" }";createRequest.mapping(mapping,XContentType.JSON);CreateIndexResponse response = indicesClient.create(createRequest, RequestOptions.DEFAULT);//3.根据返回值判断结果System.out.println(response.isAcknowledged());}/*** 查询索引*/@Testpublic void queryIndex() throws IOException {
    IndicesClient indices = client.indices();GetIndexRequest getReqeust = new GetIndexRequest("itcast");GetIndexResponse response = indices.get(getReqeust, RequestOptions.DEFAULT);//获取结果Map<String, MappingMetaData> mappings = response.getMappings();for (String key : mappings.keySet()) {
    System.out.println(key+":" + mappings.get(key).getSourceAsMap());}}/*** 删除索引*/@Testpublic void deleteIndex() throws IOException {
    IndicesClient indices = client.indices();DeleteIndexRequest deleteRequest = new DeleteIndexRequest("itheima");AcknowledgedResponse response = indices.delete(deleteRequest, RequestOptions.DEFAULT);System.out.println(response.isAcknowledged());}/*** 判断索引是否存在*/@Testpublic void existIndex() throws IOException {
    IndicesClient indices = client.indices();GetIndexRequest getRequest = new GetIndexRequest("itcast");boolean exists = indices.exists(getRequest, RequestOptions.DEFAULT);System.out.println(exists);}/*** 添加文档,使用map作为数据*/@Testpublic void addDoc() throws IOException {
    //数据对象，mapMap data = new HashMap();data.put("address","北京昌平");data.put("name","大胖");data.put("age",20);//1.获取操作文档的对象IndexRequest request = new IndexRequest("itcast").id("1").source(data);//添加数据，获取结果IndexResponse response = client.index(request, RequestOptions.DEFAULT);//打印响应结果System.out.println(response.getId());}/*** 添加文档,使用对象作为数据*/@Testpublic void addDoc2() throws IOException {
    //数据对象，javaObjectPerson p = new Person();p.setId("2");p.setName("小胖2222");p.setAge(30);p.setAddress("陕西西安");//将对象转为jsonString data = JSON.toJSONString(p);//1.获取操作文档的对象IndexRequest request = new IndexRequest("itcast").id(p.getId()).source(data,XContentType.JSON);//添加数据，获取结果IndexResponse response = client.index(request, RequestOptions.DEFAULT);//打印响应结果System.out.println(response.getId());}/*** 修改文档：添加文档时，如果id存在则修改，id不存在则添加*/@Testpublic void updateDoc() throws IOException {
    }/*** 根据id查询文档*/@Testpublic void findDocById() throws IOException {
    GetRequest getReqeust = new GetRequest("itcast","1");//getReqeust.id("1");GetResponse response = client.get(getReqeust, RequestOptions.DEFAULT);//获取数据对应的jsonSystem.out.println(response.getSourceAsString());}/*** 根据id删除文档*/@Testpublic void delDoc() throws IOException {
    DeleteRequest deleteRequest = new DeleteRequest("itcast","1");DeleteResponse response = client.delete(deleteRequest, RequestOptions.DEFAULT);System.out.println(response.getId());}}