ES的基本使用

1、简介

elasticSearch【分布式开源搜索与分析引擎,适用于所有类型的数据,包括文本,数字,地理空间,结构化和非结构化数据, 秒级从海量数据从检索出我们所需要的数据,而mysql单表如果达到了百万级数据,检索很慢】

用途:

1、应用程序搜索

2、网站搜索

3、企业搜索

4、日志处理和分析

5、基础设施指标和容器检测

6、应用程序性能检测

7、地理空间数据分析和可视化

8、安全分析和业务分析 mysql【数据的持久化管理curd】

2、基本概念

1、Index(索引),相当于mysql的insert操作,插入(索引)一条数据到数据库;名词形式相当于mysql的database; 2、Type(类型),在索引中,可以定义一个或者多个类型,类似于mysql的table,每一种类型的数据放到一起; 3、Document(文档),保存在某个索引(Index)下,某种类型(Type)的一个数据(Document),文档是Json格式的,Document就像是Mysql中的某个table里边的内容; ES集群 google microsoft megacorp 索引 employee product employee product 类型 {id:1,name:张三} 文档,一条记录 {id:2,name:李四} id被称为属性,==列 ES的概念2:倒排索引;Mysql中保存一条数据,可能是正向索引; 在ES中,会维护一张倒排索引表; 词 记录位置 红海 1,2,3,4,5 行动 1,2,3 特工 5

会有一个相关性得分:3号记录命中了两个单词;

3、基本环境搭建

docker pull elasticsearch
docker pull libana ##可视化检索数据
mkdir -p /mydata/elasticsearch/config #挂载到外部,方便修改
mkdir -p /mydata/elasticsearch/data #挂载到外部,方便修改
echo "http.host:0.0.0.0">> /mydata/elasticsearch/config/elasticsearch.yml #标识ES的机器,可以被远程任何机器访问,写入到yml里边
cat elasticsearch.yml
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \ #9200是restAPI的时候给9200发送请求,9300是ES在分布式集群下节点之间的通信端口
-e "discovery.type = single-node" \#单节点模式运行
-e ES_JAVA_OPTS = "-Xms64m -Xmx128m" \ #真正上线之后,内存都是32G左右的
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \    #这是进行挂载配置文件
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \  #这是挂载数据
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \  #这是挂载插件目录
-d elasticsearch:latest
#查看镜像版本:
docker image inspect nginx:latest | grep -i version

生成elasticsearch容器[完整,有时行,有时不行,看内存好像,elasticsearch,默认好像占用全部内存,不要脸。]:
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms512m -Xmx1024m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:latest
生成之后,容器2秒后死亡,扩大运行内存试试??【不管用,那就多分配点资源,不设置最小内存了】
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch

free -m 查看使用的虚拟机内存



启动Kibana
##docker run --name kibana -e ELASTICSEARCH_HOSTS=192.168.52.130:9200 -p 5601:5601 -d kibana:latest
docker run --name kibana -e ELASTICSEARCH_URL=http://192.168.52.130:9200 -p 5601:5601 -d kibana:latest

http://192.168.52.130:5601/app/kibana#?_g=()

/elastic/elasticsearch/master/docs/src/test/resources/accounts.json

--删除容器:
docker stop elasticsearch
docker rm elasticsearch
查看错误日志:
docker logs elasticsearch
--挂载的文件需要有读写权限:任何用户任何组都有执行权限;
chmod -R 777 /mydata/elasticsearch
执行前:
ll
drwxr-xr-x
执行后:
ll
drwxrwxrwx
elasticsearch的镜像启动成功之后,访问下:
http://192.168.52.130:9200/
{
  "name" : "ZeFr4rR",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "Hg9BNYkUQCy650XP26sYkw",
  "version" : {
    "number" : "5.6.12",
    "build_hash" : "cfe3d9f",
    "build_date" : "2018-09-10T20:12:43.732Z",
    "build_snapshot" : false,
    "lucene_version" : "6.6.1"
  },
  "tagline" : "You Know, for Search"
}

相关DSL的语句使用

es查询节点相关信息
http://192.168.52.130:9200/_cat
=^.^=
/_cat/allocation
/_cat/shards
/_cat/shards/{index}
/_cat/master
/_cat/nodes
/_cat/tasks
/_cat/indices
/_cat/indices/{index}
/_cat/segments
/_cat/segments/{index}
/_cat/count
/_cat/count/{index}
/_cat/recovery
/_cat/recovery/{index}
/_cat/health
/_cat/pending_tasks
/_cat/aliases
/_cat/aliases/{alias}
/_cat/thread_pool
/_cat/thread_pool/{thread_pools}
/_cat/plugins
/_cat/fielddata
/_cat/fielddata/{fields}
/_cat/nodeattrs
/_cat/repositories
/_cat/snapshots/{repository}
/_cat/templates

http://192.168.52.130:9200/_cat/nodes
	127.0.0.1 12 62 0 0.01 0.07 0.12 mdi * ZeFr4rR 【在集群状态下,哪个节点标了*,说明他是主节点】
http://192.168.52.130:9200/_cat/health --查看es的健康状况
	1647341114 10:45:14 elasticsearch green 1 1 0 0 0 0 0 0 - 100.0% 【中间的一些数字是集群分片信息】
http://192.168.52.130:9200/_cat/master --查看主节点
	ZeFr4rRZQz-w3ZK80Vuv0Q 127.0.0.1 127.0.0.1 ZeFr4rR
http://192.168.52.130:9200/_cat/indices --查看所有索引 show databases
2、索引一个文档(保存)
保存一个数据,保存在那个索引类型下,指定用哪个唯一索引
在customer索引下的external类型下保存1号数据为
PUT请求方式,必须得带上id
http://192.168.52.130:9200/customer/external/1
body里边的json
{
	"name":"pansd"
}
返回信息:
{
    "_index": "customer",
    "_type": "external",
    "_id": "1",
    "_version": 1,       +1
    "result": "created", --updated,
    "_shards": { --分片,集群环境下介绍;
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "created": true
}
分析返回数据:带_的都是元数据。put请求,第一次是请求时创建操作,以后的请求是更新操作。
如果是post请求方式,不指定id;
{
    "_index": "customer",
    "_type": "external",
    "_id": "AX-NOVshrEj9CP_oy5eV", --自动生成id,多次发送请求,每次都会产生唯一的id;
    "_version": 1,
    "result": "created",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "created": true
}
--如果带上了id,就和put一样了。
es的查询:
Get方式: customer/external/1
http://192.168.52.130:9200/customer/external/1
{
    "_index": "customer",
    "_type": "external",
    "_id": "1",
    "_version": 1,
	"_seq_no":1, -- 此版本的镜像没有,每次更新就会+1,用来做乐观锁。
	"_primary_term":1, -- 此版本的镜像没有,主分片重新分配,如果重启,就会发生变化。
    "found": true,
    "_source": {
        "name": "pansd"
    }
}
并发更新es的的时候,要带上乐观锁,进行并发控制。或者带上版本号,进行并发控制。
比如:
put请求:http://192.168.52.130:9200/customer/external/1?if_seq_no=1&if_primary_term=1

使用update更新:
post请求方式:http://192.168.52.130:9200/customer/external/1_update
{
	"doc":{
		"name":"pshdhx"
	}
}
1、第一次更新,版本号会改变;若在发送相同的请求,版本号和锁序列号不会改变了。【简言之:update会对比原来的数据】
删除文档索引:
delete customer/external/1
{
    "found": true,
    "_index": "customer",
    "_type": "external",
    "_id": "1",
    "_version": 2,
    "result": "deleted",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    }
}
再搜索:
{
    "_index": "customer",
    "_type": "external",
    "_id": "1",
    "found": false
}
delete customer 【删除索引,但是es中是不能单独删除类型的;或者是把索引下所有的数据都给清空了,这样也相当于是删除了类型。】

批量导入API
此时批量操作json格式不对,使用text的换行又不对了,所以得使用kibana了。
1、首先必须post请求
2、customer/external/_bulk
action
body
具体展示为:每两行一个操作;批量插入两行数据;在kibana中的dev tools中添加如下代码;
post /customer/external/_bulk
{"index":{"_id":"1"}}
{"name":"pansd"}
{"index":{"_id":"2"}}
{"name":"pshdhx"}
返回值为:
{
  "took": 62,
  "errors": false,
  "items": [
    {
      "index": {
        "_index": "customer",
        "_type": "external",
        "_id": "1",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "created": true,
        "status": 201
      }
    },
    {
      "index": {
        "_index": "customer",
        "_type": "external",
        "_id": "2",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "created": true,
        "status": 201
      }
    }
  ]
}

复杂DSL语句

复杂操作:
post /_bulk
{"delete":{"_index":"website","_type":"blog","_id":"123"}}
{"create":{"_index":"website","_type":"blog","_id":"123"}}
{"title":"my first blog"}
{"index":{"_index":"website","_type":"blog"}}
{"title":"my second blog"}
{"update":{"_index":"website","_type":"blog","_id":"123"}}
{"doc":{"title":"my updated blog post"}}
返回了:
{
  "took": 24,
  "errors": false,
  "items": [
    {
      "delete": {
        "found": true,
        "_index": "website",
        "_type": "blog",
        "_id": "123",
        "_version": 6,
        "result": "deleted",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "status": 200
      }
    },
    {
      "create": {
        "_index": "website",
        "_type": "blog",
        "_id": "123",
        "_version": 7,
        "result": "created",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "created": true,
        "status": 201
      }
    },
    {
      "index": {
        "_index": "website",
        "_type": "blog",
        "_id": "AX-OHvjg4kOgKKwsJNF9",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "created": true,
        "status": 201
      }
    },
    {
      "update": {
        "_index": "website",
        "_type": "blog",
        "_id": "123",
        "_version": 8,
        "result": "updated",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "status": 200
      }
    }
  ]
}

批量新增的数据地址:https://github.com/elastic/elasticsearch/blob/5.0/docs/src/test/resources/accounts.json
post /bank/account/_bulk
.....

新增成功后:使用高级检索:
docker update ... --restart=always

https://www.elastic.co/guide/index.html 参照官方文档:
https://www.elastic.co/guide/en/elastic-stack-get-started/7.5/index.html
https://www.elastic.co/guide/en/elasticsearch/reference/7.5/getting-started-search.html

GET bank/_search?q=*&sort=account_number:asc
该响应还提供有关搜索请求的以下信息:

took– Elasticsearch 运行查询需要多长时间,以毫秒为单位
timed_out– 搜索请求是否超时
_shards– 搜索了多少分片,以及多少分片成功、失败或被跳过的细分。
max_score– 找到的最相关文档的分数
hits.total.value- 找到了多少匹配的文档
hits.sort- 文档的排序位置(不按相关性分数排序时)
hits._score- 文档的相关性分数(使用时不适用match_all)

total": 1000,但是实际上hits里边只有10条,这是分页的结果。
##match_all的查询;全文检索
GET /bank/_search
{
  "query": { "match_all": {} },
  "sort": [
    { "account_number":{
      "order": "desc"
    }

    }

  ],
  "from": 0,
  "size": 20,
  "_source": ["balance","firstname"]
}

##match查询;按条件模糊查询
GET /bank/_search
{
  "query": {
    "match": {
      "address": "mill lane"  ##凡是有mill或者是lane的,都返回
    }
  }
}

##只返回这样的mill lane;短语查询;
GET /bank/_search
{
  "query": { "match_phrase": { "address": "mill lane" } }
}

must和must_not;满足should的得分高;

GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "age": "40" } }
      ],
      "must_not": [
        { "match": { "state": "ID" } }
      ],
      "should": [
        {
          "match": {
            "address": "MILL"
          }
        }
      ]
    }
  }
}
##filter不会计算相关性得分。must会计算相关性得分。
GET /bank/_search
{
  "query": {
    "bool": {
      "must": { "match_all": {} },
      "filter": {
        "range": {
          "balance": {
            "gte": 20000,
            "lte": 30000
          }
        }
      }
    }
  }
}
##多字段匹配
get bank/_search
{
  "query":{
    "multi_match": {
      "query": "mill",
      "fields": ["state","address"]
    }
  }
}

使用term检索精确字段的值;与match正好相反(match适用于全文检索)

get bank/_search
{
  "query":{
    "term": {
      "age": {
        "age": "20"
      }
    }
  }
}
##查询精确值 这是精确匹配
get bank/_search
{
  "query":{
    "match": {
      "address.keyword": "MILL"
    }
  }
}

聚合函数

众所周知:elasticsearch是一个搜索与分析的引擎,下面是它的分析的用法。
Analyze results with aggregations
搜索address中包含mill的所有人的年龄分布以及平均年龄;
get bank/_search
{
	"query":{
		"match":{
			"address":"mill"
		}
	},
	"aggs":{
	  "ageAgg":{
	    "terms": {
	      "field": "age",
	      "size": 10
	    }
	  },
	  "ageAvg":{
	    "avg": {
	      "field": "age"
	    }
	  },
	  "balanceAvg":{
	    "avg": {
	      "field": "balance"
	    }
	  }
	},
	##不显示hits的结果,只显示个数。
	"size":0
}

  "aggregations": {
    "ageAgg": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": 38,
          "doc_count": 2
        },
        {
          "key": 28,
          "doc_count": 1
        },
        {
          "key": 32,
          "doc_count": 1
        }
      ]
    }
  }

##按照年龄进行聚合,并且请求这些年龄的这些人的平均薪资
get bank/_search
{
  "query":{
    "match_all": {}
  },
  "aggs":{
    "ageAgg":{
      "terms": {
        "field": "age",
        "size": 10
      },
      "aggs":{
        "balanceAvg":{
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  }
}
返回值:
"aggregations": {
    "ageAgg": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 463,
      "buckets": [
        {
          "key": 31,
          "doc_count": 61,
          "balanceAvg": {
            "value": 28312.918032786885
          }
        },
        {
          "key": 39,
          "doc_count": 60,
          "balanceAvg": {
            "value": 25269.583333333332
          }
        },
##查出所有年龄分布,并且这些年龄段中男性的平均薪资和女性的平均薪资,还有总体的平均薪资
get bank/_search
{
  "query":{
    "match_all": {}
  },
  "aggs":{
    "ageAgg":{
      "terms": {
        "field": "age",
        "size": 10
      },
      "aggs": {
        "genderAgg": {
          "terms": {
            "field": "gender.keyword",
            "size": 10
          },
          "aggs": {
            "balanceAgg": {
              "avg": {
                "field": "balance"
              }
            }
          }
        },
        "balanceAvgAll":{
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  }
}
返回值:
"buckets": [ 31岁的人 有 61个;  35个男的,26个女的;  男的的平均薪资是29565.628571428573 女性的平均薪资是26626.576923076922
        {
          "key": 31,
          "doc_count": 61,
          "genderAgg": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "M",
                "doc_count": 35,
                "balanceAgg": {
                  "value": 29565.628571428573
                }
              },
              {
                "key": "F",
                "doc_count": 26,
                "balanceAgg": {
                  "value": 26626.576923076922
                }
              }
            ]
          },
          "balanceAvgAll": {
            "value": 28312.918032786885
          }
        },

mapping映射

elasticsearch的mapping方式:7.x之后,去除了type;预计8.x取消type的支持。为了防止不同的type的字段名称相同。

get bank/_mapping

关于ES中的数据类型:https://www.elastic.co/guide/en/elasticsearch/reference/7.5/mapping-types.html
string
	text and keyword
Numeric
	long, integer, short, byte, double, float, half_float, scaled_float
Date
	date
Date nanoseconds
	date_nanos
Boolean
	boolean
Binary
	binary
Range
	integer_range, float_range, long_range, double_range, date_range

还有复杂数据类型。

关于映射:很恶心,不同的版本不一样,看对应版本的文档都对应不起来。
get bank/_mapping


PUT my_index
{
  "mappings": {
    "user": {
      "_all": {
        "enabled": false
      },
      "properties": {
        "title": {
          "type": "text"
        },
        "name": {
          "type": "text"
        },
        "age": {
          "type": "integer"
        }
      }
    }
  }
}
PUT twitter
{
  "mappings": {
    "user": {
      "properties": {
        "name": { "type": "text" },
        "user_name": { "type": "keyword" },
        "email": { "type": "keyword" }
      }
    },
    "tweet": {
      "properties": {
        "content": { "type": "text" },
        "user_name": { "type": "keyword" },
        "tweeted_at": { "type": "date" }
      }
    }
  }
}
PUT twitter/user/kimchy
{
  "name": "Shay Banon",
  "user_name": "kimchy",
  "email": "[email protected]"
}
PUT twitter/tweet/1
{
  "user_name": "kimchy",
  "tweeted_at": "2017-10-24T09:00:00Z",
  "content": "Types are going away"
}
GET twitter/tweet/_search
{
  "query": {
    "match": {
      "user_name": "kimchy"
    }
  }
}
PUT twitter
{
  "mappings": {
    "doc": {
      "properties": {
        "type": { "type": "keyword" },
        "name": { "type": "text" },
        "user_name": { "type": "keyword" },
        "email": { "type": "keyword" },
        "content": { "type": "text" },
        "tweeted_at": { "type": "date" }
      }
    }
  }

}

 ES的映射修改和数据迁移

##创建一个索引,并指定映射规则
PUT /my_index
{
  "mappings": {
    "properties": {
      "age":{"type": "integer"},
      "email":{"type": "keyword"},
      "name":{"type": "text"}
    }
  }
}
##修改索引下的映射规则,【新增字段】
PUT /my_index/_mapping
{
  "properties":{
    "employee-id":{"type":"keyword","index":false}
  }
}
GET /my_index/_mapping
##对于已经存在的映射字段,我们是不能更新的,只能添加;因为如果修改映射,那么可能存在已有的数据;我们
可以创建一个新的索引,重新reindex原来的数据。【数据迁移】
##创建新的索引,来改变老的索引的映射类型
PUT /newBank
{
  "mappings": {
    "properties": {
      
    }
  }
}
##数据迁移
POST _reindex
{
  "source": {
    "index": "bank",
    "type": "account"
  },
  "dest": {
    "index": "newBank"
  }
}

4、ES的分词器

关于ES的分词:
一个tokenizer(分词器)接收一个字符流,将之分割为独立的tokens(词元,通常是独立的单词),然后输出token流。
例如:whitespace tokenizer遇到空格字符时分割文本。它会将文本"Quick brown fox"分割为 【quick,brown,fox】
该tokenizer(分词器)还负责记录各个term(词条)的顺序或者是position位置(用于phrase短语和word proximity词近邻查询),以及term词条所
代表的原始word的start和end的字符偏移量。(用于高亮显示搜索的内容)
ES提供了很多内置的分词器,可以用来构建custom analyzers(自定义分词器)

4.1、安装ik分词器:

ES的分词器:7.4.2
链接:https://pan.baidu.com/s/1DpWUZEFicNiYOJDCSDidVA 
提取码:pshd 
--来自百度网盘超级会员V2的分享


POST _analyze
{
  "analyzer": "whitespace",
  "text":     "The quick brown fox."
}
安装下中文分词器:ik;github到plugins;
进入容器内部:
docker exec -it elasticsearch /bin/bash
pwd
ls
exit退出容器
先下载wget :用yum下载下载器;
yum install wget
设置root登录:
vi /etc/ssh/sshd_config
修改:passwordAuthentication yes/no
重启服务:service sshd restart
1、必须安装ES对应版本的IK分词器;
2、放入的plugins目录下;
3、重启容器;
4、测试分词:
POST _analyze
{
  "analyzer": "ik_smart", ## ik_max_word
  "text":     "尚硅谷电商项目"
}
返回值:
{
  "tokens": [
    {
      "token": "尚",
      "start_offset": 0,
      "end_offset": 1,
      "type": "CN_CHAR",
      "position": 0
    },
    {
      "token": "硅谷",
      "start_offset": 1,
      "end_offset": 3,
      "type": "CN_WORD",
      "position": 1
    },
    {
      "token": "电",
      "start_offset": 3,
      "end_offset": 4,
      "type": "CN_CHAR",
      "position": 2
    },
    {
      "token": "商",
      "start_offset": 4,
      "end_offset": 5,
      "type": "CN_CHAR",
      "position": 3
    },
    {
      "token": "项目",
      "start_offset": 5,
      "end_offset": 7,
      "type": "CN_WORD",
      "position": 4
    }
  ]
}
有些词语分词器不识别,需要创建自定义分词:
1、先设置网卡:
添加GATEWAY=xxxxx.1
DNS1=114.114.114.114
DNS2=8.8.8.8
使用了match之后,会有一个max_score最大得分;查询数字是精确查询;查询字符串是模糊查询【全文检索】;
关于自定义分词器:

4.2、安装nginx

安装nginx,把词库的地址放到nginx里边;
docker container cp nginx:/etc/nginx .
mv nginx conf #文件夹改名
mv conf nginx/ #把conf挪移到nginx文件夹里边
docker stop nginx;
docker rm nginx;
docker run -p 80:80 --name nginx \
-v /mydata/nginx/conf/html:/usr/share/nginx/html \
-v /mydata/nginx/conf/logs:/var/log/nginx \
-v /mydata/nginx/conf:/etc/nginx \
-d nginx:1.10
docker run -p80:80 --name nginx -v/mydata/nginx/html:/usr/share/nginx/html -v/mydata/nginx/logs:/var/log/nginx -v /mydata/nginx/conf:/etc/nginx -d nginx:1.10 ##【正确】
在nginx里边自定义fenci.txt

配置ik分词器的词库地址http://192.168.52.130/es/fenci.txt

ES的基本使用_第1张图片

 ES的基本使用_第2张图片

5、 java代码交互elasticsearch

5.1、pom.xml

7.4.2
 
            org.elasticsearch.client
            elasticsearch-rest-high-level-client
            7.4.2
        

5.2、配置文件configuration

package com.pshdhx.elasticsearch.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author pshdhx
 * @date 2022-03-28 15:09
 */
@Configuration
public class ElasticSearchConfiguration {

    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
        //addHeader();
        //setHttpAsyncResponseCounsumerFactory
        COMMON_OPTIONS = builder.build();
    }

    @Bean
    public RestHighLevelClient EsRestClient(){
        RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost("82.xx.xx.xxxx", 9200, "http"));
        RestHighLevelClient client = new RestHighLevelClient(restClientBuilder);
        return client;
    }
}

5.3、测试文件 

package com.pshdhx.elasticsearch;


import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RestHighLevelClient;
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 org.springframework.test.context.junit4.SpringRunner;


@SpringBootTest
public class GulimallElasticsearchApplicationTests {

    @Autowired
    private RestHighLevelClient restHighLevelClient;
    
    @Test
    public void contextLoads() {
        System.out.println("哈哈");
        System.out.println(restHighLevelClient);
    }

    @Test
    public void indexData(){
        IndexRequest indexRequest = new IndexRequest("users");
        indexRequest.id("1");
        indexRequest.source("userName","zhangsan","age",18,"gender","男");
        User user = new User("pshdhx",18,"man");
        String jsonString = JSON.toJSONString(user);
        IndexRequest index = indexRequest.source(jsonString, XContentType.JSON);
        System.out.println(index);
    }


    @Data
    @AllArgsConstructor
    class User{
        private String userName;
        private Integer age;
        private String gender;
    }

}

你可能感兴趣的:(分布式应用,elasticsearch,mysql,数据库)