京东搜索:手机11苹果
mysql 单表的数据量达到500w条以后,检索效率就大幅度的下降了。
ES本身就支持海量数据的检索
mysql的模糊查询,只能进行关键字上的“%xxx%”这种模糊查询,但是不能进行分词检索
ES:本身就支持按照用户输入的关键词进行拆分的查询,并且可以容错(输入错别字的时候,依然可以查询。)
ES是一个使用Java语言并且基于Lucene编写的搜索引擎框架,他提供了分布式的全文搜索功能,提供了一个统一的基于RESTful风格的WEB接口,官方客户端也对多种语言都提供了相应的API。
Lucene:https://lucene.apache.org/ 是apche的顶级项目,提供搜索的基础类库。
全文检索:区别与关系数据库里的模糊查询,可以把用户输入的内容切词后,去分词库比对,然后把匹配的结果进行返回。
RESTful风格的WEB接口:GET,POST,PUT,DELETE
应用广泛:github, wiki , jingdong
ES回忆时光 |
---|
![]() |
yml文件
# 注意:先执行如下修改,在运行 docker-compose up -d
Docker安装 elasticsearch 报错max virtual memory areas vm.max_map_count [65530] is too low
使用下面命令解决:
cat /etc/sysctl.conf
vi /etc/sysctl.conf
添加 一行
vm.max_map_count=655360
加载参数
sysctl -p
version: "3.1"
services:
elasticsearch:
image: daocloud.io/library/elasticsearch:6.8.12
restart: always
container_name: elasticsearch
environment:
- "ES_JAVA_OPTS=-Xms512m -Xmx512m" #设置使用jvm内存大小
ports:
- 9200:9200
kibana:
image: daocloud.io/library/kibana:6.8.12
restart: always
container_name: kibana
ports:
- 5601:5601
environment:
- elasticsearch_url=http://elasticsearch:9200
depends_on:
- elasticsearch
下载离线安装包
- 下载IK分词器的地址:https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.12/elasticsearch-analysis-ik-6.8.12.zip
- 上传文件到虚拟机
- 解压文件
- 在es容器内创建目录:/usr/share/elasticsearch/plugins/ik
- 将解压好的所有文件放入es容器内的目录:/usr/share/elasticsearch/plugins/ik
- 重启ES容器
直接在线安装(github网络限制,可能连接失败)
- 进去到ES容器内部,跳转到bin目录下,执行bin目录下的脚本文件:
- ./elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.12/elasticsearch-analysis-ik-6.8.12.zip
- 或者使用如下地址:
- ./elasticsearch-plugin install http://39.98.95.55/down/elasticsearch-analysis-ik-6.8.12.zip
- 重启ES的容器,让IK分词器生效。
- docker-compose restart
校验IK分词器 |
---|
![]() |
ES的服务中,可以创建多个索引。
每一个索引默认被分成5片存储。
每一个分片都会存在至少一个备份分片。
备份的分片应该放在不同的服务器中。
ES5 : 一个索引下,可以创建多个类型。
ES6: 一个索引下,只能创建一个类型(type)。
ES7:取消了type的概念
Ps:根据版本不同,类型的创建也不同。
ES里的文档(Doc),本质上就是一条json字符传数据。
一个类型下,可以有多个文档。这个文档就类似于MySQL表中的行数据。
一个文档中,可以包含多个属性。类似于MySQL表中的一行数据存在多个列。
- GET请求:
- http://ip:port/index:查询索引信息
- http://ip:port/index/type/doc_id:查询指定的文档信息
- POST请求:
- http://ip:port/index/type/_search:查询文档,可以在请求体中添加json字符串来代表查询条件
- http://ip:port/index/type/doc_id/_update:修改文档,在请求体中指定json字符串代表修改的具体信息
- PUT请求:
- http://ip:port/index:创建一个索引,需要在请求体中指定索引的信息,类型,结构
- http://ip:port/index/type/_mappings:代表创建索引时,指定索引文档存储的属性的信息
- DELETE请求:
- http://ip:port/index:删除索引
- http://ip:port/index/type/doc_id:删除指定的文档
https://www.elastic.co/guide/en/elasticsearch/reference/6.8/index.html
语法如下
# 创建一个索引
PUT /person
{
"settings": {
"number_of_shards": 5,
"number_of_replicas": 1
}
}
语法如下
# 查看索引信息
GET /person
查看信息 |
---|
![]() |
语法如下
# 删除索引
DELETE /person
字符串类型:
- text:一般被用于全文检索。 将当前Field进行分词。
- keyword:当前Field不会被分词。
数值类型:
- long:取值范围为-9223372036854774808~922337203685477480(-2的63次方到2的63次方-1),占用8个字节
- integer:取值范围为-2147483648~2147483647(-2的31次方到2的31次方-1),占用4个字节
- short:取值范围为-32768~32767(-2的15次方到2的15次方-1),占用2个字节
- byte:取值范围为-128~127(-2的7次方到2的7次方-1),占用1个字节
- double:1.797693e+308~ 4.9000000e-324 (e+308表示是乘以10的308次方,e-324表示乘以10的负324次方)占用8个字节
- float:3.402823e+38 ~ 1.401298e-45(e+38表示是乘以10的38次方,e-45表示乘以10的负45次方),占用4个字节
时间类型:
date类型,针对时间类型指定具体的格式
布尔类型:
- boolean类型,表达true和false
其他的数据类型参考官网:https://www.elastic.co/guide/en/elasticsearch/reference/6.5/mapping-types.html
语法如下
https://www.elastic.co/guide/en/elasticsearch/reference/6.5/index.html
# 创建索引,指定数据结构
PUT /book
{
"settings": {
# 分片数
"number_of_shards": 5,
# 备份数
"number_of_replicas": 1
},
"mappings": {
# type 的名称
"novel": {
# 从这里开始指定 field
"properties": {
"name": {
# 字段的类型 ,text ,可以全文检索
"type": "text",
# text类型使用的分词器
"analyzer": "ik_max_word"
},
"author": {
"type": "keyword"
},
"count": {
"type": "long"
},
"on-sale": {
"type": "date",
"format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
},
"descr": {
"type": "text",
"analyzer": "ik_max_word"
}
}
}
}
}
文档在ES服务中的唯一标识,
_index
,_type
,_id
三个内容为组合,锁定一个文档,操作是添加还是修改。
自动生成_id
# 添加文档,自动生成id
POST /book/novel
{
"name": "盘龙",
"author": "我吃西红柿",
"count": 100000,
"on-sale": "2000-01-01",
"descr": "山重水复疑无路,柳暗花明又一村"
}
手动指定_id
# 添加文档,手动指定id
PUT /book/novel/1
{
"name": "红楼梦",
"author": "曹雪芹",
"count": 10000000,
"on-sale": "1985-01-01",
"descr": "一个是阆苑仙葩,一个是美玉无瑕"
}
查询当前索引下的全部文档数据
POST /book/novel/_search
# 根据id查询文档信息
GET /book/novel/4AZze4IBTWJVgBPuWRch
覆盖式修改
# 添加文档,手动指定id
PUT /book/novel/1
{
"name": "红楼梦",
"author": "曹雪芹",
"count": 4353453,
"on-sale": "1985-01-01",
"descr": "一个是阆苑仙葩,一个是美玉无瑕"
}
doc修改方式
# 修改文档,基于doc方式
POST /book/novel/1/_update
{
"doc": {
# 指定上需要修改的field和对应的值
"count": "1234565"
}
}
根据id删除
# 根据id删除文档
DELETE /book/novel/_id
重点
】https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/#repositories
导入依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-elasticsearchartifactId>
dependency>
yml配置
spring:
elasticsearch:
rest:
uris: http://192.168.57.190:9200
代码如下
@Data
@AllArgsConstructor
@NoArgsConstructor
// createIndex 是否随IOC容器启动自动创建索引
@Document(indexName = "user_info",shards = 1,replicas = 1,createIndex = false)
public class UserInfo {
@Id
@Field(type = FieldType.Long)
private Long id;
@Field(type = FieldType.Keyword)
private String name;
@Field(type = FieldType.Text,analyzer = "ik_max_word",searchAnalyzer = "ik_max_word")
private String remark;
@Field(type = FieldType.Date)
private Date jobday;
}
@SpringBootTest
public class AppTest {
@Autowired
ElasticsearchRestTemplate elasticsearchRestTemplate;
@Test
public void createIndex() {
elasticsearchRestTemplate.createIndex(UserInfo.class);
elasticsearchRestTemplate.putMapping(UserInfo.class);
}
}
代码如下
@Test
void queryIndex() {
final boolean b = elasticsearchRestTemplate.indexExists(UserInfo.class);
System.out.println(b);
}
代码如下
@Test
public void deleteIndex() {
elasticsearchRestTemplate.deleteIndex("user_info");
}
代码如下
@Test
void save() {
UserInfo userInfo = new UserInfo();
userInfo.setId(1l);
userInfo.setName("张三");
userInfo.setRemark("这是一个测试用户,用的手机是小米手机,没用苹果手机");
userInfo.setJobday(new Date());
IndexQuery indexQuery = new IndexQueryBuilder()
.withId(userInfo.getId().toString())
.withObject(userInfo)
.build();
//返回值是索引
String index = elasticsearchRestTemplate.index(indexQuery);
System.out.println(index);
}
简化方式
public interface UserRepository extends ElasticsearchRepository<UserInfo, Long> {
}
@Autowired
UserRepository userRepository;
@Test
void indexDoc() {
final UserInfo userInfo = new UserInfo();
userInfo.setId(100l);
userInfo.setName("张三");
userInfo.setJobday(new Date());
userInfo.setRemark("张三是法外狂徒");
userRepository.save(userInfo);
}
代码如下
@Test
void updateDoc() {
final UserInfo userInfo = new UserInfo();
userInfo.setId(100l);
userInfo.setName("张三1");
userInfo.setJobday(new Date());
userInfo.setRemark("张三是法外狂徒111");
userRepository.index(userInfo);
}
代码如下
@Test
void deleteDoc() {
userRepository.deleteById(100l);
}
代码如下
@Test
void bulkIndex() {
List<IndexQuery> list = new ArrayList<>();
UserInfo userInfo1 = new UserInfo();
userInfo1.setId(2l);
userInfo1.setName("李四");
userInfo1.setRemark("这是一个用户,用的手机是苹果手机");
userInfo1.setJobday(new Date());
IndexQuery indexQuery1 = new IndexQueryBuilder()
.withId(userInfo1.getId().toString())
.withObject(userInfo1)
.build();
list.add(indexQuery1);
UserInfo userInfo2 = new UserInfo();
userInfo2.setId(3l);
userInfo2.setName("王五");
userInfo2.setRemark("这是一个用户wangwu,用的手机是小米手机");
userInfo2.setJobday(new Date());
IndexQuery indexQuery2 = new IndexQueryBuilder()
.withId(userInfo2.getId().toString())
.withObject(userInfo2)
.build();
list.add(indexQuery2);
list.add(indexQuery2);
elasticsearchRestTemplate.bulkIndex(list);
}
@Test
void testSaveAll() {
List<UserInfo> list = new ArrayList<>();
UserInfo userInfo1 = new UserInfo();
userInfo1.setId(5l);
userInfo1.setName("李四");
userInfo1.setRemark("这是一个用户,用的手机是苹果手机");
userInfo1.setJobday(new Date());
list.add(userInfo1);
UserInfo userInfo2 = new UserInfo();
userInfo2.setId(6l);
userInfo2.setName("王五");
userInfo2.setRemark("这是一个用户wangwu,用的手机是小米手机");
userInfo2.setJobday(new Date());
list.add(userInfo2);
userRepository.saveAll(list);
}
代码如下
@Test
void testDeleteBatch() {
List<UserInfo> list = new ArrayList<>();
UserInfo userInfo1 = new UserInfo();
userInfo1.setId(5l);
list.add(userInfo1);
UserInfo userInfo2 = new UserInfo();
userInfo2.setId(6l);
list.add(userInfo2);
userRepository.deleteAll(list);
}
创建索引,指定数据结构
索引名:sms-logs-index
类型名:sms-logs-type
结构如下:
索引结构图 |
---|
![]() |
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(indexName = "sms-logs-index",type = "sms-logs-type",shards = 1,replicas = 1,createIndex = false)
public class SmsLogs {
@Id
@Field(type = FieldType.Long)
private Long id;// 唯一ID 1
@Field(type = FieldType.Date)
private Date createDate;// 创建时间
@Field(type = FieldType.Date)
private Date sendDate; // 发送时间
@Field(type = FieldType.Keyword)
private String longCode;// 发送的长号码
@Field(type = FieldType.Keyword)
private String mobile;// 下发手机号
@Field(type = FieldType.Keyword)
private String corpName;// 发送公司名称
@Field(type = FieldType.Text,analyzer = "ik_max_word",searchAnalyzer = "ik_max_word")
private String smsContent; // 下发短信内容
@Field(type = FieldType.Integer)
private Integer state; // 短信下发状态 0 成功 1 失败
@Field(type = FieldType.Integer)
private Integer operatorId; // '运营商编号 1 移动 2 联通 3 电信
@Field(type = FieldType.Keyword)
private String province;// 省份
@Field(type = FieldType.Ip)
private String ipAddr; //下发服务器IP地址
@Field(type = FieldType.Integer)
private Integer replyTotal; //短信状态报告返回时长(秒)
@Field(type = FieldType.Long)
private Integer fee; // 费用
}
public interface SmsLogsRepository extends ElasticsearchRepository<SmsLogs, Long> {
}
@SpringBootTest
public class SmsLogsRepositoryTest {
@Autowired
ElasticsearchRestTemplate elasticsearchRestTemplate;
@Autowired
SmsLogsRepository smsLogsRepository;
@Test
void createIndex() {
elasticsearchRestTemplate.createIndex(SmsLogs.class);
elasticsearchRestTemplate.putMapping(SmsLogs.class);
}
@Test
void deleteIndxe() {
elasticsearchRestTemplate.deleteIndex(SmsLogs.class);
}
@Test
void genData() {
final ArrayList<SmsLogs> list = new ArrayList<>();
SmsLogs smsLogs1 = new SmsLogs();
smsLogs1.setMobile("13800000000");
smsLogs1.setCorpName("途虎养车");
smsLogs1.setCreateDate(new Date());
smsLogs1.setSendDate(new Date());
smsLogs1.setIpAddr("10.126.2.9");
smsLogs1.setLongCode("10690000988");
smsLogs1.setReplyTotal(10);
smsLogs1.setState(0);
smsLogs1.setSmsContent("【途虎养车】亲爱的张三先生/女士,您在途虎购买的货品(单号TH123456)已 到指定安装店多日," + "现需与您确认订单的安装情况,请点击链接按实际情况选择(此链接有效期为72H)。您也可以登录途 虎APP进入" + "“我的-待安装订单”进行预约安装。若您在服务过程中有任何疑问,请致电400-111-8868向途虎咨 询。");
smsLogs1.setProvince("北京");
smsLogs1.setOperatorId(1);
smsLogs1.setFee(3);
smsLogs1.setId(1l);
list.add(smsLogs1);
SmsLogs smsLogs2 = new SmsLogs();
smsLogs2.setMobile("13100000000");
smsLogs2.setCorpName("盒马鲜生");
smsLogs2.setCreateDate(new Date());
smsLogs2.setSendDate(new Date());
smsLogs2.setIpAddr("10.126.2.9");
smsLogs2.setLongCode("10660000988");
smsLogs2.setReplyTotal(15);
smsLogs2.setState(0);
smsLogs2.setSmsContent("【盒马】您尾号12345678的订单已开始配送,请在您指定的时间收货不要走开 哦~配送员:" + "刘三,电话:13800000000");
smsLogs2.setProvince("北京");
smsLogs2.setOperatorId(2);
smsLogs2.setFee(5);
smsLogs2.setId(2l);
list.add(smsLogs2);
SmsLogs smsLogs3 = new SmsLogs();
smsLogs3.setMobile("15300000000");
smsLogs3.setCorpName("滴滴打车");
smsLogs3.setCreateDate(new Date());
smsLogs3.setSendDate(new Date());
smsLogs3.setIpAddr("10.126.2.8");
smsLogs3.setLongCode("10660000988");
smsLogs3.setReplyTotal(50);
smsLogs3.setState(1);
smsLogs3.setSmsContent("【滴滴单车平台】专属限时福利!青桔/小蓝月卡立享5折,特惠畅骑30天。" + "戳 https://xxxxxx退订TD");
smsLogs3.setProvince("上海");
smsLogs3.setOperatorId(3);
smsLogs3.setFee(7);
smsLogs3.setId(3l);
list.add(smsLogs3);
SmsLogs smsLogs4 = new SmsLogs();
smsLogs4.setMobile("13900000000");
smsLogs4.setCorpName("招商银行");
smsLogs4.setCreateDate(new Date());
smsLogs4.setSendDate(new Date());
smsLogs4.setIpAddr("10.126.2.8");
smsLogs4.setLongCode("10690000988");
smsLogs4.setReplyTotal(50);
smsLogs4.setState(0);
smsLogs4.setSmsContent("【招商银行】尊贵的李四先生,恭喜您获得华为P30 Pro抽奖资格,还可领100 元打" + "车红包,仅限1天");
smsLogs4.setProvince("上海");
smsLogs4.setOperatorId(1);
smsLogs4.setFee(8);
smsLogs4.setId(4l);
list.add(smsLogs4);
SmsLogs smsLogs5 = new SmsLogs();
smsLogs5.setMobile("13700000000");
smsLogs5.setCorpName("中国平安保险有限公司");
smsLogs5.setCreateDate(new Date());
smsLogs5.setSendDate(new Date());
smsLogs5.setIpAddr("10.126.2.8");
smsLogs5.setLongCode("10690000998");
smsLogs5.setReplyTotal(18);
smsLogs5.setState(0);
smsLogs5.setSmsContent("【中国平安】奋斗的时代,更需要健康的身体。中国平安为您提供多重健康保 障,在奋斗之路上为您保驾护航。退订请回复TD");
smsLogs5.setProvince("武汉");
smsLogs5.setOperatorId(1);
smsLogs5.setFee(5);
smsLogs5.setId(5l);
list.add(smsLogs5);
SmsLogs smsLogs6 = new SmsLogs();
smsLogs6.setMobile("13600000000");
smsLogs6.setCorpName("中国移动");
smsLogs6.setCreateDate(new Date());
smsLogs6.setSendDate(new Date());
smsLogs6.setIpAddr("10.126.2.8");
smsLogs6.setLongCode("10650000998");
smsLogs6.setReplyTotal(60);
smsLogs6.setState(0);
smsLogs6.setSmsContent("【北京移动】尊敬的客户137****0000,5月话费账单已送达您的139邮箱," + "点击查看账单详情 http://y.10086.cn/; " + " 回Q关闭通知,关注“中国移动139邮箱”微信随时查账单【中国移动 139邮箱】");
smsLogs6.setProvince("武汉");
smsLogs6.setOperatorId(1);
smsLogs6.setFee(4);
smsLogs6.setId(6l);
list.add(smsLogs6);
smsLogsRepository.saveAll(list);
}
}
重点
】term的查询是代表完全匹配,搜索之前不会对你搜索的关键字进行分词,对你的关键字去文档分词库中去匹配内容。
必须是等于,是与分词库比对,不是与值。,若是没有分词库的,就比较值
select * from sms_logs where provinc = ‘北京’ limit 0,2
# term查询
POST /sms-logs-index/sms-logs-type/_search
{
"from": 0, # limit ?
"size": 5, # limit x,?
"query": {
"term": {
"province": {
"value": "北京"
}
}
}
}
代码实现方式
@SpringBootTest
public class SmsLogsQueryTest {
@Autowired
ElasticsearchRestTemplate elasticsearchRestTemplate;
@Autowired
SmsLogsRepository smsLogsRepository;
@Test
void term() {
final TermQueryBuilder termQueryBuilder = new TermQueryBuilder("province","北京");
final SearchQuery searchQuery = new NativeSearchQuery(termQueryBuilder);
// index and type
searchQuery.addIndices("sms-logs-index");
searchQuery.addTypes("sms-logs-type");
// 分页参数
PageRequest pageRequest = PageRequest.of(0,1);
searchQuery.setPageable(pageRequest);
// 通用查询方法
elasticsearchRestTemplate.query(searchQuery, new ResultsExtractor<Void>() {
@Override
public Void extract(SearchResponse response) {
final SearchHits searchHits = response.getHits();
final SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
final Map<String, Object> sourceAsMap = hit.getSourceAsMap();
System.out.println(sourceAsMap);
}
return null;
}
});
}
@Test
void term1() {
final TermQueryBuilder termQueryBuilder = new TermQueryBuilder("province","北京");
final SearchQuery searchQuery = new NativeSearchQuery(termQueryBuilder);
searchQuery.addIndices("sms-logs-index");
searchQuery.addTypes("sms-logs-type");
// 分页参数
PageRequest pageRequest = PageRequest.of(0,1);
searchQuery.setPageable(pageRequest);
final List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(searchQuery, SmsLogs.class);
System.out.println(smsLogs.size());
System.out.println(smsLogs);
}
@Test
void term2() {
// 分页参数
PageRequest pageRequest = PageRequest.of(0,1);
final List<SmsLogs> data = smsLogsRepository.findByProvince("北京",pageRequest);
System.out.println(data.size());
System.out.println(data);
}
}
terms和term的查询机制是一样,都不会将指定的查询关键字进行分词,直接去分词库中匹配,找到相应文档内容。
terms是在针对一个字段包含多个值的时候使用。
term:where province = 北京;
terms:where province = 北京 or province = ?or province = ?
where province in (‘北京’,‘山西’,‘武汉’)
# terms查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"terms": {
"province": [
"北京",
"山西",
"武汉"
]
}
}
}
代码实现方式
@Test
void terms() {
StringQuery query = new StringQuery("{\n" +
" \"terms\": {\n" +
" \"province\": [\n" +
" \"北京\",\n" +
" \"山西\",\n" +
" \"武汉\"\n" +
" ]\n" +
" }\n" +
" }");
// 分页参数
PageRequest pageRequest = PageRequest.of(0,1);
query.setPageable(pageRequest);
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
重点
】match查询属于高层查询,他会根据你查询的字段类型不一样,采用不同的查询方式。
- 查询的是日期或者是数值的话,他会将你基于的字符串查询内容转换为日期或者数值对待。
- 如果查询的内容是一个不能被分词的内容(keyword),match查询不会对你指定的查询关键字进行分词。
- 如果查询的内容时一个可以被分词的内容(text),match会将你指定的查询内容根据一定的方式去分词,去分词库中匹配指定的内容。
查询全部内容,不指定任何查询条件。
# match_all查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"match_all": {}
}
}
代码实现方式
@Test
void matchAll() {
StringQuery query = new StringQuery("{\n" +
" \"match_all\": {}\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
指定一个Field作为筛选的条件
查询关键词分词,有一个关键词匹配上内容的分词库,就返回json文档的json
# match查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"match": {
"smsContent": "收货安装"
}
}
}
代码实现方式
@Test
void match() {
StringQuery query = new StringQuery("{\n" +
" \"match\": {\n" +
" \"smsContent\": \"收货安装\"\n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
基于一个Field匹配的内容,采用and或者or的方式连接
select * from sms_logs where smsContent like ‘%中国%’ and smsContent like ‘%健康%’
# 布尔match查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"match": {
"smsContent": {
"query": "中国 健康",
"operator": "and" # 内容既包含中国也包含健康
}
}
}
}
# 布尔match查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"match": {
"smsContent": {
"query": "中国 健康",
"operator": "or" # 内容包括健康或者包括中国
}
}
}
}
代码实现方式
@Test
void booleanMatchQuery() {
StringQuery query = new StringQuery("{\n" +
" \"match\": {\n" +
" \"smsContent\": {\n" +
" \"query\": \"中国 健康\",\n" +
" \"operator\": \"or\" "+
" }\n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
match针对一个field做检索,multi_match针对多个field进行检索,多个field对应一个text。
select * from sms_logs where province = ‘北京’ or smsContent like ‘%北京%’
# multi_match 查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"multi_match": {
"query": "北京", # 指定text
"fields": ["province","smsContent"] # 指定field们
}
}
}
代码实现方式
@Test
void multiMatchQuery() {
StringQuery query = new StringQuery("{\n" +
" \"multi_match\": {\n" +
" \"query\": \"北京\",\t\t\t\t\t\n" +
" \"fields\": [\"province\",\"smsContent\"] \n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
根据id查询 where id = ?
# id查询
GET /sms-logs-index/sms-logs-type/1
代码实现方式
@Test
void byID() {
final SmsLogs smsLogs = elasticsearchRestTemplate.queryForObject(GetQuery.getById("1"), SmsLogs.class);
System.out.println(smsLogs);
}
根据多个id查询,类似MySQL中的where id in(id1,id2,id2…)
# ids查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"ids": {
"values": ["1","2","3"]
}
}
}
代码实现方式
@Test
void byIds() {
StringQuery query = new StringQuery("{\n" +
" \"ids\": {\n" +
" \"values\": [\"1\",\"2\",\"3\"]\n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
前缀查询,可以通过一个关键字去指定一个Field的前缀,从而查询到指定的文档。
在这些其他查询,是不会对查询关键词进行分词的
例如:亲爱的王五 就不会拆,只会在词库里找 亲爱的王五为前缀的词汇所对应的json文档
where name like ‘途虎%’
#prefix 查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"prefix": {
"corpName": {
"value": "途虎"
}
}
}
}
代码实现方式
@Test
void findByPrefix() {
StringQuery query = new StringQuery("{\n" +
" \"prefix\": {\n" +
" \"corpName\": {\n" +
" \"value\": \"途虎\"\n" +
" }\n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
模糊查询,我们输入字符的大概,ES就可以去根据输入的内容大概去匹配一下结果。score
# fuzzy查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"fuzzy": {
"corpName": {
"value": "盒马先生",
"prefix_length": 2 # 指定前面几个字符是不允许出现错误的
}
}
}
}
代码实现方式
@Test
void fuzzy() {
StringQuery query = new StringQuery("{\n" +
" \"fuzzy\": {\n" +
" \"corpName\": {\n" +
" \"value\": \"盒马先生\",\n" +
" \"prefix_length\": 2\t\t\t\n" +
" }\n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
通配查询,和MySQL中的like是一个套路,可以在查询时,在字符串中指定通配符*和占位符?
where name like ‘%中国%’
# wildcard 查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"wildcard": {
"corpName": {
"value": "中国*" # 可以使用*和?指定通配符和占位符
}
}
}
}
代码实现方式
@Test
void wildCard() {
StringQuery query = new StringQuery("{\n" +
" \"wildcard\": {\n" +
" \"corpName\": {\n" +
" \"value\": \"中国*\" " +
" }\n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
范围查询,只针对数值类型,对某一个Field进行大于或者小于的范围指定
# range 查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"range": {
"fee": {
"gt": 5,
"lte": 10
# 可以使用 gt:> gte:>= lt:< lte:<=
}
}
}
}
代码实现方式
正则查询,通过你编写的正则表达式去匹配内容。
regexp 里 这里例子 mobile它是 keywords类型 所以不会拆词,用正则规定匹配词库,匹配上就成功,返回json文档
Ps:prefix,fuzzy,wildcard和regexp查询效率相对比较低,要求效率比较高时,避免去使用
# regexp 查询
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"regexp": {
"mobile": "180[0-9]{8}" # 编写正则
}
}
}
代码实现方式
复合过滤器,将你的多个查询条件,以一定的逻辑组合在一起。
- must: 所有的条件,用must组合在一起,表示And的意思
- must_not:将must_not中的条件,全部都不能匹配,标识Not的意思
- should:所有的条件,用should组合在一起,表示Or的意思
# smsContent必须中包含中国和平安
# 运营商必须不是联通
# 省份可以为武汉或者北京,但不强求(给结果加分)
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"smsContent": "中国"
}
},
{
"match": {
"smsContent": "平安"
}
}
],
"should": [
{
"term": {
"province": {
"value": "北京"
}
}
},
{
"term": {
"province": {
"value": "武汉"
}
}
}
],
"must_not": [
{
"term": {
"operatorId": {
"value": "2"
}
}
}
]
}
}
}
代码实现方式
@Test
void BoolQuery() {
StringQuery query = new StringQuery("{\n" +
" \"bool\": {\n" +
" \"must\": [\n" +
" {\n" +
" \"match\": {\n" +
" \"smsContent\": \"中国\"\n" +
" }\n" +
" },\n" +
" {\n" +
" \"match\": {\n" +
" \"smsContent\": \"平安\"\n" +
" }\n" +
" }\n" +
" ],\n" +
" \"should\": [\n" +
" {\n" +
" \"term\": {\n" +
" \"province\": {\n" +
" \"value\": \"北京\"\n" +
" }\n" +
" }\n" +
" },\n" +
" {\n" +
" \"term\": {\n" +
" \"province\": {\n" +
" \"value\": \"武汉\"\n" +
" }\n" +
" }\n" +
" }\n" +
" ],\n" +
" \"must_not\": [\n" +
" {\n" +
" \"term\": {\n" +
" \"operatorId\": {\n" +
" \"value\": \"2\"\n" +
" }\n" +
" }\n" +
" }\n" +
" ]\n" +
"\n" +
" }\n" +
" }");
List<SmsLogs> smsLogs = elasticsearchRestTemplate.queryForList(query, SmsLogs.class);
smsLogs.forEach(System.out::println);
}
boosting查询可以帮助我们去影响查询后的score。
- positive:只有匹配上positive的查询的内容,才会被放到返回的结果集中。
- negative:如果匹配上和positive并且也匹配上了negative,就可以降低这样的文档score。
- negative_boost:指定系数,必须小于1.0
关于查询时,分数是如何计算的:
- 搜索的关键字在文档中出现的频次越高,分数就越高
- 指定的文档内容越短,分数就越高
- 我们在搜索时,指定的关键字也会被分词,这个被分词的内容,被分词库匹配的个数越多,分数越高
# boosting查询 收货安装
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"boosting": {
"positive": {
"match": {
"smsContent": "收货安装"
}
},
"negative": {
"match": {
"smsContent": "王五"
}
},
"negative_boost": 0.5
}
}
}
# 把包含指定的关键字的文档的分数提高
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"bool": {
"should": [
{
"term": {
"province": {
"value": "北京"
}
}
},
{
"term": {
"province": {
"value": "武汉",
#这是乘法,乘以原来的分数 1.1631508*3=3.4894524
"boost": 3
}
}
}
]
}
}
}
代码实现方式
让京东自营和小米得分增加
POST /user_info/_search
{
"query": {
"bool": {
"must": [
{"match": {
"remark": "手机"
}}
],
"should": [
{"match": {
"producttype": "京东自营"
}},
{
"match": {
"producttype": {
"query": "小米",
"boost": 20
}
}
}
]
}
}
}
将存放的数据,以一定的方式进行分词,并且将分词的内容存放到一个单独的分词库中。
当用户去查询数据时,会将用户的查询关键字进行分词。
然后去分词库中匹配内容,最终得到数据的id标识。
根据id标识去存放数据的位置拉取到指定的数据。
举例:对如下数据建立倒排索引。
ES中存储数据,没一条数据,都是一个JSON字符串,{“id”:“1”,“content”:“xxxxxadfaaf”}
把content字段指定为text类型
当向ES中写入一条json数据时,如果某个字段的类型为text,则ES会自动构建该字段内容的倒排索引
每个字段都有词库,keywords就是本身不分词的词库,text 是分词的词库,每个字段分分隔离。
重复的词,不添加地址进词库。
原理:就是拿词去与 所对应字段 的 词库 进行对比,有对应的就返回 json 文档。