Elasticsearch介绍和安装与使用

叁歲伎倆 2022-05-09 02:52 263阅读 0赞

# 1.Elasticsearch介绍和安装 #

![在这里插入图片描述][70]

## 1.1.简介 ##

### 1.1.1.Elastic ###

Elastic官网：[https://www.elastic.co/cn/][https_www.elastic.co_cn]

![在这里插入图片描述][70 1]

Elastic有一条完整的产品线：Elasticsearch、Kibana、Logstash等，前面说的三个就是大家常说的ELK技术栈。

![在这里插入图片描述][70 2]

### 1.1.2.Elasticsearch ###

Elasticsearch官网：[https://www.elastic.co/cn/products/elasticsearch][https_www.elastic.co_cn_products_elasticsearch]

![在这里插入图片描述][70 3]

如上所述，Elasticsearch具备以下特点：

*  分布式，无需人工搭建集群（solr就需要人为配置，使用Zookeeper作为注册中心）
 *  Restful风格，一切API都遵循Rest原则，容易上手
 *  近实时搜索，数据更新在Elasticsearch中几乎是完全同步的。

### 1.1.3.版本 ###

目前Elasticsearch最新的版本是6.2.4，我们就使用这个版本

需要JDK1.8及以上

## 1.2.安装和配置 ##

\#\#\#1.2.1 下载

![在这里插入图片描述][70 4]

下载地址：[https://www.elastic.co/downloads/past-releases][https_www.elastic.co_downloads_past-releases]

![在这里插入图片描述][70 5]

![在这里插入图片描述][70 6]

### 1.2.2 安装 ###

elasticsearch无需安装，解压即用。

\[外链图片转存失败(img-vQVf2nZn-1562576542887)(assets/1537967155637.png)\]

###  ###

## 1.3.运行 ##

进入elasticsearch/bin目录，可以看到下面的执行文件：

![在这里插入图片描述][70 7]

双击运行

![在这里插入图片描述][70 8]

可以看到绑定了两个端口:

*  9300：java程序访问的断就
 *  9200：浏览器、postman访问接口

我们在浏览器中访问：[http://127.0.0.1:9200][http_127.0.0.1_9200]

![在这里插入图片描述][70 9]

## 1.4.安装Head插件 ##

### 1.4.1.什么是Head ###

ealsticsearch只是后端提供各种api，那么怎么直观的使用它呢？elasticsearch-head将是一款专门针对于elasticsearch的客户端工具

elasticsearch-head配置包，下载地址：[https://github.com/mobz/elasticsearch-head][https_github.com_mobz_elasticsearch-head]

### 1.4.2.安装 ###

*  **es5以上版本安装head需要安装node和grunt**

第一步：**从地址：[https://nodejs.org/en/download/][https_nodejs.org_en_download] 下载相应系统的msi，双击安装。**

![在这里插入图片描述][70 10]

第二步：**安装完成用cmd进入安装目录执行 node -v可查看版本号**

![在这里插入图片描述][70 11]

第三步：**执行 npm install -g grunt-cli 安装grunt ，安装完成后执行grunt -version查看是否安装成功，会显示安装的版本号**

![在这里插入图片描述][70 12]

### 1.4.3.配置运行 ###

第一步：进入es安装目录下的config目录，修改elasticsearch.yml文件.在文件的末尾加入以下代码

http.cors.enabled: true 
    http.cors.allow-origin: "*"
    node.master: true
    node.data: true

然后去掉network.host: 192.168.0.1的注释并改为network.host: 0.0.0.0，[去掉cluster.name][cluster.name]；[node.name][]；http.port的注释（也就是去掉\#）**(!!!如果出现bat闪退的现象，注释就别去掉)**

第二步：双击elasticsearch.bat重启es

第三步：在https://github.com/mobz/elasticsearch-head中下载head插件，选择下载zip

第四步：解压到指定文件夹下，D:\\environment\\elasticsearch-head-master 进入该文件夹，修改D:\\environment\\elasticsearch-head-master\\Gruntfile.js 在对应的位置加上hostname:’\*’、

![在这里插入图片描述][70 13]

第五步：在D:\\environment\\elasticsearch-head-master 下执行npm install 安装完成后执行grunt server 或者npm run start 运行head插件，如果不成功重新安装grunt。成功如下

### 1.4.4.成功 ###

![在这里插入图片描述][70 14]

## 1.5.安装ik分词器 ##

ElasticSearch 默认采用分词器， 单个字分词 ，效果很差

搜索【IK Analyzer 3.0】

[http://www.oschina.net/news/2660][http_www.oschina.net_news_2660]

![在这里插入图片描述][70 15]  
![在这里插入图片描述][70 16]  
Lucene的IK分词器早在2012年已经没有维护了，现在我们要使用的是在其基础上维护升级的版本，并且开发为Elasticsearch的集成插件了，与Elasticsearch一起维护升级，版本也保持一致，最新版本：6.2.4

### 1.5.1. 下载 ###

源码下载地址：[https://github.com/medcl/elasticsearch-analysis-ik/tree/6.2.x][https_github.com_medcl_elasticsearch-analysis-ik_tree_6.2.x]

jar包下载地址：[https://github.com/medcl/elasticsearch-analysis-ik/releases][https_github.com_medcl_elasticsearch-analysis-ik_releases]

![在这里插入图片描述][70 17]  
![在这里插入图片描述][70 18]

### 1.5.1.安装 ###

无需安装，解压即可使用

我们将其改名为`ik`，并复制到elasticsearch的解压目录，如下图所示

![在这里插入图片描述][70 19]

然后重启elasticsearch：

![在这里插入图片描述][70 20]

### 1.5.2.扩展词和停用词 ###

扩展词和停用词文件：

![在这里插入图片描述][70 21]

![在这里插入图片描述][70 22]

\#\#\#1.5.4 测试

![在这里插入图片描述][70 23]

# 2.SprignBoot整合Spring Data Elasticsearch #

Elasticsearch提供的Java客户端有一些不太方便的地方：

*  很多地方需要拼接Json字符串，在java中拼接字符串有多恐怖你应该懂的
 *  需要自己把对象序列化为json存储
 *  查询到结果也需要自己反序列化为对象

因此，我们这里就不讲解原生的Elasticsearch客户端API了。

而是学习Spring提供的套件：Spring Data Elasticsearch

## 2.1.简介 ##

Spring Data Elasticsearch是Spring Data项目下的一个子模块。

查看 Spring Data的官网：[http://projects.spring.io/spring-data/][http_projects.spring.io_spring-data]

![在这里插入图片描述][70 24]

Spring Data 是的使命是给各种数据访问提供统一的编程接口，不管是关系型数据库（如MySQL），还是非关系数据库（如Redis），或者类似Elasticsearch这样的索引数据库。从而简化开发人员的代码，提高开发效率。

包含很多不同数据操作的模块：

![在这里插入图片描述][70 25]

Spring Data Elasticsearch的页面：[https://projects.spring.io/spring-data-elasticsearch/][https_projects.spring.io_spring-data-elasticsearch]

![在这里插入图片描述][70 26]  
特征：

*  支持Spring的基于`@Configuration`的java配置方式，或者XML配置方式
 *  提供了用于操作ES的便捷工具类\*\*`ElasticsearchTemplate`\*\*。包括实现文档到POJO之间的自动智能映射。
 *  利用Spring的数据转换服务实现的功能丰富的对象映射
 *  基于注解的元数据映射方式，而且可扩展以支持更多不同的数据格式
 *  根据持久层接口自动生成对应实现方法，无需人工编写基本操作代码（类似mybatis，根据接口自动得到实现）。当然，也支持人工定制查询

## 2.2.创建Demo工程 ##

我们新建一个demo，学习Elasticsearch

pom依赖：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.czxy</groupId>
        <artifactId>bos-es</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>bos-es</name>
        <description>Demo project for Spring Boot</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.4.RELEASE</version>
            <relativePath/> 
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <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-data-elasticsearch</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    
    </project>

application.properties文件配置：

spring.data.elasticsearch.repositories.enabled = true
    spring.data.elasticsearch.cluster-nodes =127.0.0.1:9300

## 2.3.索引操作 ##

### 2.3.1.创建索引和映射 ###

SpringBoot-data-elasticsearch提供了面向对象的方式操作elasticsearch

业务：创建一个商品对象，有这些属性：

答：id，title，category，brand，price，图片地址
    
    在SpringDataElasticSearch中，只需要操作对象，就可以操作elasticsearch中的数据

> 实体类

首先我们准备好实体类：

public class Item { 
        private Long id;
        private String title; //标题
        private String category;// 分类
        private String brand; // 品牌
        private Double price; // 价格
        private String images; // 图片地址
    }

> 映射—注解

Spring Data通过注解来声明字段的映射属性，有下面的三个注解：

*  `@Document` 作用在类，标记实体类为文档对象，一般有两个属性
    
     *  indexName：对应索引库名称
     *  type：对应在索引库中的类型
     *  shards：分片数量，默认5
     *  replicas：副本数量，默认1
 *  `@Id` 作用在成员变量，标记一个字段作为id主键
 *  `@Field` 作用在成员变量，标记为文档的字段，并指定字段映射属性：
    
     *  type：字段类型，是是枚举：FieldType，可以是text、long、short、date、integer、object等
        
         *  text：存储数据时候，会自动分词，并生成索引
         *  keyword：存储数据时候，不会分词建立索引
         *  Numerical：数值类型，分两类
            
             *  基本数据类型：long、interger、short、byte、double、float、half\_float
             *  浮点数的高精度类型：scaled\_float
                
                 *  需要指定一个精度因子，比如10或100。elasticsearch会把真实值乘以这个因子后存储，取出时再还原。
         *  Date：日期类型
            
             *  elasticsearch可以对日期格式化为字符串存储，但是建议我们存储为毫秒值，存储为long，节省空间。
     *  index：是否索引，布尔类型，默认是true
     *  store：是否存储，布尔类型，默认是false
     *  analyzer：分词器名称，这里的`ik_max_word`即使用ik分词器

示例：

@Document(indexName = "item",type = "docs", shards = 1, replicas = 0)
    public class Item { 
        @Id
        private Long id;
        
        @Field(type = FieldType.Text, analyzer = "ik_max_word")
        private String title; //标题
        
        @Field(type = FieldType.Keyword)
        private String category;// 分类
        
        @Field(type = FieldType.Keyword)
        private String brand; // 品牌
        
        @Field(type = FieldType.Double)
        private Double price; // 价格
        
        @Field(index = false, type = FieldType.Keyword)
        private String images; // 图片地址
    }

> 创建索引

ElasticsearchTemplate中提供了创建索引的API：

![在这里插入图片描述][70 27]

*  可以根据类的信息自动生成，也可以手动指定indexName和Settings

> 映射

映射相关的API：

![在这里插入图片描述][70 28]

*  一样，可以根据类的字节码信息（注解配置）来生成映射，或者手动编写映射

我们这里采用类的字节码信息创建索引并映射：

@Test
    public void createIndex() { 
        // 创建索引，会根据Item类的@Document注解信息来创建
        esTemplate.createIndex(Item.class);
        // 配置映射，会根据Item类中的id、Field等字段来自动完成映射
        esTemplate.putMapping(Item.class);
    }

索引信息：

![在这里插入图片描述][70 29]

### 2.3.2.删除索引 ###

删除索引的API：

![在这里插入图片描述][70 30]

可以根据类名或索引名删除。

示例：

@Test
    public void deleteIndex() { 
        esTemplate.deleteIndex(Item.class);
        // 根据索引名字删除
        //esTemplate.deleteIndex("item1");
    }

结果：OK

## 2.4.新增文档数据 ##

### 2.4.1.Repository接口 ###

Spring Data 的强大之处，就在于你不用写任何DAO处理，自动根据方法名或类的信息进行CRUD操作。只要你定义一个接口，然后继承Repository提供的一些子接口，就能具备各种基本的CRUD功能。

来看下Repository的继承关系：

![在这里插入图片描述][70 31]

我们看到有一个ElasticsearchCrudRepository接口：

![在这里插入图片描述][70 32]

所以，我们只需要定义接口，然后继承它就OK了。

public interface ItemRepository extends ElasticsearchRepository<Item,Long> { 
    }

接下来，我们测试新增数据：

### 2.4.2.新增一个对象 ###

@Autowired
    private ItemRepository itemRepository;
    
    @Test
    public void index() { 
        Item item = new Item(1L, "小米手机7", " 手机",
                             "小米", 3499.00, "http://image.baidu.com/13123.jpg");
        itemRepository.save(item);
    }

去页面查询看看：

![在这里插入图片描述][70 33]

### 2.4.3.批量新增 ###

代码：

@Test
    public void indexList() { 
        List<Item> list = new ArrayList<>();
        list.add(new Item(2L, "坚果手机R1", " 手机", "锤子", 3699.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(3L, "华为META10", " 手机", "华为", 4499.00, "http://image.baidu.com/13123.jpg"));
        // 接收对象集合，实现批量新增
        itemRepository.saveAll(list);
    }

再次去页面查询：

![在这里插入图片描述][70 34]

### 2.4.4.修改 ###

elasticsearch中本没有修改，它的是该是先删除在新增

修改和新增是同一个接口，区分的依据就是id。

@Test
    public void index(){
        Item item = new Item(1L, "苹果XSMax", " 手机",
                "小米", 3499.00, "http://image.baidu.com/13123.jpg");
        itemRepository.save(item);
    }

查看结果：

![在这里插入图片描述][70 35]

## 2.5.查询 ##

### 2.5.1.基本查询 ###

ElasticsearchRepository提供了一些基本的查询方法：

![在这里插入图片描述][70 36]我们来试试查询所有：

@Test
        public void testQueryAll(){ 
            // 查找所有
            //Iterable<Item> list = this.itemRepository.findAll();
            // 对某字段排序查找所有 Sort.by("price").descending() 降序
            // Sort.by("price").ascending():升序
            Iterable<Item> list = this.itemRepository.findAll(Sort.by("price").ascending());
    
            for (Item item:list){ 
                System.out.println(item);
            }
        }

结果：

![在这里插入图片描述][70 37]

### 2.5.2.自定义方法 ###

Spring Data 的另一个强大功能，是根据方法名称自动实现功能。

比如：你的方法名叫做：findByTitle，那么它就知道你是根据title查询，然后自动帮你完成，无需写实现类。

当然，方法名称要符合一定的约定：

<table> 
 <thead> 
  <tr> 
   <th>Keyword</th> 
   <th>Sample</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>And</code></td> 
   <td><code>findByNameAndPrice</code></td> 
  </tr> 
  <tr> 
   <td><code>Or</code></td> 
   <td><code>findByNameOrPrice</code></td> 
  </tr> 
  <tr> 
   <td><code>Is</code></td> 
   <td><code>findByName</code></td> 
  </tr> 
  <tr> 
   <td><code>Not</code></td> 
   <td><code>findByNameNot</code></td> 
  </tr> 
  <tr> 
   <td><code>Between</code></td> 
   <td><code>findByPriceBetween</code></td> 
  </tr> 
  <tr> 
   <td><code>LessThanEqual</code></td> 
   <td><code>findByPriceLessThan</code></td> 
  </tr> 
  <tr> 
   <td><code>GreaterThanEqual</code></td> 
   <td><code>findByPriceGreaterThan</code></td> 
  </tr> 
  <tr> 
   <td><code>Before</code></td> 
   <td><code>findByPriceBefore</code></td> 
  </tr> 
  <tr> 
   <td><code>After</code></td> 
   <td><code>findByPriceAfter</code></td> 
  </tr> 
  <tr> 
   <td><code>Like</code></td> 
   <td><code>findByNameLike</code></td> 
  </tr> 
  <tr> 
   <td><code>StartingWith</code></td> 
   <td><code>findByNameStartingWith</code></td> 
  </tr> 
  <tr> 
   <td><code>EndingWith</code></td> 
   <td><code>findByNameEndingWith</code></td> 
  </tr> 
  <tr> 
   <td><code>Contains/Containing</code></td> 
   <td><code>findByNameContaining</code></td> 
  </tr> 
  <tr> 
   <td><code>In</code></td> 
   <td><code>findByNameIn(Collection&lt;String&gt;names)</code></td> 
  </tr> 
  <tr> 
   <td><code>NotIn</code></td> 
   <td><code>findByNameNotIn(Collection&lt;String&gt;names)</code></td> 
  </tr> 
  <tr> 
   <td><code>Near</code></td> 
   <td><code>findByStoreNear</code></td> 
  </tr> 
  <tr> 
   <td><code>True</code></td> 
   <td><code>findByAvailableTrue</code></td> 
  </tr> 
  <tr> 
   <td><code>False</code></td> 
   <td><code>findByAvailableFalse</code></td> 
  </tr> 
  <tr> 
   <td><code>OrderBy</code></td> 
   <td><code>findByAvailableTrueOrderByNameDesc</code></td> 
  </tr> 
 </tbody> 
</table>

例如，我们来按照价格区间查询，定义这样的一个方法：

public interface ItemRepository extends ElasticsearchRepository<Item,Long> { 
    
        /** * 根据价格区间查询 * @param price1 * @param price2 * @return */
        List<Item> findByPriceBetween(double price1, double price2);
    }

然后添加一些测试数据：

@Test
    public void indexList() { 
        List<Item> list = new ArrayList<>();
        list.add(new Item(1L, "小米手机7", "手机", "小米", 3299.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(2L, "坚果手机R1", "手机", "锤子", 3699.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(3L, "华为META10", "手机", "华为", 4499.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(4L, "小米Mix2S", "手机", "小米", 4299.00, "http://image.baidu.com/13123.jpg"));
        list.add(new Item(5L, "荣耀V10", "手机", "华为", 2799.00, "http://image.baidu.com/13123.jpg"));
        // 接收对象集合，实现批量新增
        itemRepository.saveAll(list);
    }

不需要写实现类，然后我们直接去运行：

@Test
    public void queryByPriceBetween(){ 
        List<Item> list = this.itemRepository.findByPriceBetween(2000.00, 3500.00);
        for (Item item : list) { 
            System.out.println("item = " + item);
        }
    }

结果：

![在这里插入图片描述][70 38]

### 2.5.3.自定义查询 ###

先来看最基本的match query：

@Test
    public void search(){ 
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米手机"));
        // 搜索，获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 总条数
        long total = items.getTotalElements();
        System.out.println("total = " + total);
        for (Item item : items) { 
            System.out.println(item);
        }
    }

*  NativeSearchQueryBuilder：Spring提供的一个查询条件构建器，帮助构建json格式的请求体
 *  QueryBuilders.matchQuery(“title”, “小米手机”)：利用QueryBuilders来生成一个查询。QueryBuilders提供了大量的静态方法，用于生成各种不同类型的查询：
    
    ![在这里插入图片描述][70 39]
 *  `Page<item>`：默认是分页查询，因此返回的是一个分页的结果对象，包含属性：
    
     *  totalElements：总条数
     *  totalPages：总页数
     *  Iterator：迭代器，本身实现了Iterator接口，因此可直接迭代得到当前页的数据
     *  其它属性：
        
        ![在这里插入图片描述][70 40]

结果：

![在这里插入图片描述][70 41]

总的测试代码：

/** * * termQuery * wildcardQuery * fuzzyquery * booleanQuery * numericRangeQuery * */
        @Test
        public void testMathQuery(){ 
            // 创建对象
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            // 在queryBuilder对象中自定义查询
            //matchQuery:底层就是使用的termQuery
            queryBuilder.withQuery(QueryBuilders.matchQuery("title","坚果"));
            //查询，search 默认就是分页查找
            Page<Item> page = this.itemRepository.search(queryBuilder.build());
            //获取数据
            long totalElements = page.getTotalElements();
            System.out.println("获取的总条数:"+totalElements);
    
            for(Item item:page){ 
                System.out.println(item);
            }
    
    
        }
    
    
        /** * termQuery:功能更强大，除了匹配字符串意外，还可以匹配int/long/double/float/.... */
        @Test
        public void testTermQuery(){ 
            NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
            builder.withQuery(QueryBuilders.termQuery("price",998.0));
            // 查找
            Page<Item> page = this.itemRepository.search(builder.build());
    
            for(Item item:page){ 
                System.out.println(item);
            }
        }
    
        @Test
        public void testBooleanQuery(){ 
            NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
    
            builder.withQuery(
                    QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("title","华为"))
                                             .must(QueryBuilders.matchQuery("brand","华为"))
            );
    
            // 查找
            Page<Item> page = this.itemRepository.search(builder.build());
            for(Item item:page){ 
                System.out.println(item);
            }
        }
    
    
        @Test
        public void testFuzzyQuery(){ 
            NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
            builder.withQuery(QueryBuilders.fuzzyQuery("title","faceoooo"));
            Page<Item> page = this.itemRepository.search(builder.build());
            for(Item item:page){ 
                System.out.println(item);
            }
    
        }

### 2.5.4.分页查询 ###

利用`NativeSearchQueryBuilder`可以方便的实现分页：

@Test
    public void searchByPage(){ 
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
        // 分页：
        int page = 0;
        int size = 2;
        queryBuilder.withPageable(PageRequest.of(page,size));
    
        // 搜索，获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 总条数
        long total = items.getTotalElements();
        System.out.println("总条数 = " + total);
        // 总页数
        System.out.println("总页数 = " + items.getTotalPages());
        // 当前页
        System.out.println("当前页：" + items.getNumber());
        // 每页大小
        System.out.println("每页大小：" + items.getSize());
    
        for (Item item : items) { 
            System.out.println(item);
        }
    }

结果：

\[外链图片转存失败(img-4q9Esx9y-1562576542892)(assets/1538083677832.png)\]

可以发现，**Elasticsearch中的分页是从第0页开始**。

### 2.5.5.排序 ###

排序也通用通过`NativeSearchQueryBuilder`完成：

@Test
    public void searchAndSort(){ 
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本分词查询
        queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
    
        // 排序
        queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
    
        // 搜索，获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 总条数
        long total = items.getTotalElements();
        System.out.println("总条数 = " + total);
    
        for (Item item : items) { 
            System.out.println(item);
        }
    }

结果：

![在这里插入图片描述][70 42]

## 2.6.聚合（牛逼！！solr无此功能） ##

聚合可以让我们极其方便的实现对数据的统计、分析。例如：

*  什么品牌的手机最受欢迎？
 *  这些手机的平均价格、最高价格、最低价格？
 *  这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

### 2.6.1 基本概念 ###

Elasticsearch中的聚合，包含多种类型，最常用的两种，一个叫`桶`，一个叫`度量`：

> **桶（bucket）**

桶的作用，是按照某种方式对数据进行分组，每一组数据在ES中称为一个`桶`，例如我们根据国籍对人划分，可以得到`中国桶`、`英国桶`，`日本桶`……或者我们按照年龄段对人进行划分：010,1020,2030,3040等。

Elasticsearch中提供的划分桶的方式有很多：

*  Date Histogram Aggregation：根据日期阶梯分组，例如给定阶梯为周，会自动每周分为一组
 *  Histogram Aggregation：根据数值阶梯分组，与日期类似
 *  Terms Aggregation：根据词条内容分组，词条内容完全匹配的为一组
 *  Range Aggregation：数值和日期的范围分组，指定开始和结束，然后按段分组
 *  ……

综上所述，我们发现bucket aggregations 只负责对数据进行分组，并不进行计算，因此往往bucket中往往会嵌套另一种聚合：metrics aggregations即度量

> **度量（metrics）**

分组完成以后，我们一般会对组中的数据进行聚合运算，例如求平均值、最大、最小、求和等，这些在ES中称为`度量`

比较常用的一些度量聚合方式：

*  Avg Aggregation：求平均值
 *  Max Aggregation：求最大值
 *  Min Aggregation：求最小值
 *  Percentiles Aggregation：求百分比
 *  Stats Aggregation：同时返回avg、max、min、sum、count等
 *  Sum Aggregation：求和
 *  Top hits Aggregation：求前几
 *  Value Count Aggregation：求总数
 *  ……

**注意**：在ES中，需要进行聚合、排序、过滤的字段其处理方式比较特殊，因此不能被分词。这里我们将color和make这两个文字类型的字段设置为keyword类型，这个类型不会被分词，将来就可以参与聚合

### 2.6.2.聚合为桶 ###

桶就是分组，比如这里我们按照品牌brand进行分组：

@Test
    public void testAgg(){ 
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 不查询任何结果
        queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{ ""}, null));
        // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
        queryBuilder.addAggregation(
            AggregationBuilders.terms("brands").field("brand"));
        // 2、查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
        // 3、解析
        // 3.1、从结果中取出名为brands的那个聚合，
        // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
        StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
        // 3.2、获取桶
        List<StringTerms.Bucket> buckets = agg.getBuckets();
        // 3.3、遍历
        for (StringTerms.Bucket bucket : buckets) { 
            // 3.4、获取桶中的key，即品牌名称
            System.out.println(bucket.getKeyAsString());
            // 3.5、获取桶中的文档数量
            System.out.println(bucket.getDocCount());
        }
    
    }

显示的结果：

![在这里插入图片描述][70 43]

关键API：

*  `AggregationBuilders`：聚合的构建工厂类。所有聚合都由这个类来构建，看看他的静态方法：
    
    ![在这里插入图片描述][70 44]

（1）统计某个字段的数量
      ValueCountBuilder vcb=  AggregationBuilders.count("count_uid").field("uid");
    （2）去重统计某个字段的数量（有少量误差）
     CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
    （3）聚合过滤
    FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));
    （4）按某个字段分组
    TermsBuilder tb=  AggregationBuilders.terms("group_name").field("name");
    （5）求和
    SumBuilder  sumBuilder=	AggregationBuilders.sum("sum_price").field("price");
    （6）求平均
    AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
    （7）求最大值
    MaxBuilder mb= AggregationBuilders.max("max_price").field("price"); 
    （8）求最小值
    MinBuilder min=	AggregationBuilders.min("min_price").field("price");
    （9）按日期间隔分组
    DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
    （10）获取聚合里面的结果
    TopHitsBuilder thb=  AggregationBuilders.topHits("top_result");
    （11）嵌套的聚合
    NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
    （12）反转嵌套
    AggregationBuilders.reverseNested("res_negsted").path("kps ");

*  `AggregatedPage`：聚合查询的结果类。它是`Page<T>`的子接口：
    
    ![在这里插入图片描述][70 45]  
    `AggregatedPage`在`Page`功能的基础上，拓展了与聚合相关的功能，它其实就是对聚合结果的一种封装。
    
    ![在这里插入图片描述][70 46]
    
    而返回的结果都是Aggregation类型对象，不过根据字段类型不同，又有不同的子类表示

![在这里插入图片描述][70 47]

### 2.6.2.嵌套聚合，求平均值 ###

代码：

@Test
    public void testSubAgg(){ 
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 不查询任何结果
        queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{ ""}, null));
        // 1、添加一个新的聚合，聚合类型为terms，聚合名称为brands，聚合字段为brand
        queryBuilder.addAggregation(
            AggregationBuilders.terms("brands").field("brand")
            .subAggregation(AggregationBuilders.avg("priceAvg").field("price")) // 在品牌聚合桶内进行嵌套聚合，求平均值
        );
        // 2、查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
        // 3、解析
        // 3.1、从结果中取出名为brands的那个聚合，
        // 因为是利用String类型字段来进行的term聚合，所以结果要强转为StringTerm类型
        StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
        // 3.2、获取桶
        List<StringTerms.Bucket> buckets = agg.getBuckets();
        // 3.3、遍历
        for (StringTerms.Bucket bucket : buckets) { 
            // 3.4、获取桶中的key，即品牌名称 3.5、获取桶中的文档数量
            System.out.println(bucket.getKeyAsString() + "，共" + bucket.getDocCount() + "台");
    
            // 3.6.获取子聚合结果：
            InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
            System.out.println("平均售价：" + avg.getValue());
        }
    
    }

结果：

![在这里插入图片描述][70 48]

## 2.7.基本概念 ##

Elasticsearch也是基于Lucene的全文检索库，本质也是存储数据，很多概念与MySQL类似的。

对比关系：

索引库（indices）--------------------------------Databases 数据库

类型（type）-----------------------------Table 数据表
    
         文档（Document）----------------Row 行
    
    	   字段（Field）-------------------Columns 列

详细说明：

<table> 
 <thead> 
  <tr> 
   <th>概念</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>索引库（indices)</td> 
   <td>indices是index的复数，代表许多的索引，</td> 
  </tr> 
  <tr> 
   <td>类型（type）</td> 
   <td>类型是模拟mysql中的table概念，一个索引库下可以有不同类型的索引，比如商品索引，订单索引，其数据格式不同。不过这会导致索引库混乱，因此未来版本中会移除这个概念</td> 
  </tr> 
  <tr> 
   <td>文档（document）</td> 
   <td>存入索引库原始的数据。比如每一条商品信息，就是一个文档</td> 
  </tr> 
  <tr> 
   <td>字段（field）</td> 
   <td>文档中的属性</td> 
  </tr> 
  <tr> 
   <td>映射配置（mappings）</td> 
   <td>字段的数据类型、属性、是否索引、是否存储等特性</td> 
  </tr> 
 </tbody> 
</table>

是不是与Lucene中的概念类似。

另外，在Elasticsearch有一些集群相关的概念：

*  索引集（Indices，index的复数）：逻辑上的完整索引
 *  分片（shard）：数据拆分后的各个部分
 *  副本（replica）：每个分片的复制

要注意的是：Elasticsearch本身就是分布式的，因此即便你只有一个节点，Elasticsearch默认也会对你的数据进行分片和副本操作，当你向集群添加新数据时，数据也会在新加入的节点中进行平衡。

\#\#2.8bug1：Must be in the format host:port!

![在这里插入图片描述][70 49]

![在这里插入图片描述][70 50]

## **(一个综合查询方法)** ##

![在这里插入图片描述][70 51]

@Override
        public DatagridResult conditionQuery(WayBill wayBill, Integer page, Integer rows) { 
            NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    
            //判断订单号
            if (StringUtils.isNotBlank(wayBill.getWayBillNum())){ 
                WildcardQueryBuilder wayBillNum = QueryBuilders.wildcardQuery("wayBillNum", "*" + wayBill.getWayBillNum() + "*");
                boolQuery.must(wayBillNum);
            }
            // 2 发货地 分词
            if (StringUtils.isNotBlank(wayBill.getSendAddress())){ 
                // 2 改进的第一个问题：北京市顺义区 北 京 市 北京 顺义 义区 这种方式允许查吗？
                WildcardQueryBuilder sendAddressequeryBuilder1 = QueryBuilders.wildcardQuery("sendAddress", "*" + wayBill.getSendAddress() + "*");
                // 3 改进的第二个问题：北京顺义 这种方式要被允许-->这种方式需要对 查询词条进行分词后 再进行查询
                // QueryStringQueryBuilder此对象会对查询的词条分词后的各种情况进行分词查找
                // 参数：就是前台传过来的查询内容
                // QueryStringQueryBuilder queryStringQueryBuilder = new QueryStringQueryBuilder(wayBill.getSendAddress());
    // queryStringQueryBuilder.field("sendAddress").defaultOperator(Operator.AND);
                QueryStringQueryBuilder queryStringQueryBuilder = new QueryStringQueryBuilder(wayBill.getSendAddress()).field("sendAddress").defaultOperator(Operator.AND);
                BoolQueryBuilder should = QueryBuilders.boolQuery().should(sendAddressequeryBuilder1).should(queryStringQueryBuilder);
                boolQuery.must(should);
            }
            //收货地址
            if (StringUtils.isNotBlank(wayBill.getRecAddress())){ 
                WildcardQueryBuilder recAddressQuery = QueryBuilders.wildcardQuery("recAddress", "*" + wayBill.getRecAddress() + "*");
    
                //改进 允许对词条分词后 在查询
                QueryStringQueryBuilder recAddressQueryString = new QueryStringQueryBuilder(wayBill.getRecAddress()).field("recAddress").defaultOperator(Operator.AND);
    
                //取并集
                BoolQueryBuilder should = QueryBuilders.boolQuery().should(recAddressQuery).should(recAddressQueryString);
                boolQuery.must(should);
            }
            //4 速运当日、速运次日、速运隔日 sds
            if (StringUtils.isNotBlank(wayBill.getSendProNum())){ 
                TermQueryBuilder sendProNumQuery = QueryBuilders.termQuery("sendProNum", wayBill.getSendProNum());
                boolQuery.must(sendProNumQuery);
            }
            //5 运单状态： 1 待发货、 2 派送中、3 已签收、4 异常
            if (wayBill.getSignStatus()!=null&& wayBill.getSignStatus()!=0){ 
                TermQueryBuilder signStatus = QueryBuilders.termQuery("signStatus", wayBill.getSignStatus());
                boolQuery.must(signStatus);
            }
            // 执行分页
            queryBuilder.withPageable(PageRequest.of(page-1,rows));
            // 执行查询
            queryBuilder.withQuery(boolQuery);
            Page<ESWayBill> list = wayBillRepository.search(queryBuilder.build());
            //拼接结果
            DatagridResult result = new DatagridResult();
            result.setTotal(list.getTotalElements());
            result.setRows(list.getContent());
            return result;
        }

--------------------

##### 扶贫！！ 帮助一下孩子吧。感谢♥： #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjYzMzEzMQ_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjYzMzEzMQ_size_16_color_FFFFFF_t_70 1]

[70]: /images/20220509/3f612f4c79c74270873f2605c3916ec1.png
[https_www.elastic.co_cn]: https://www.elastic.co/cn/
[70 1]: /images/20220509/2c96489446b449339285ad6e33d9cec0.png
[70 2]: /images/20220509/2fd627e2a72049098b7698de163e992a.png
[https_www.elastic.co_cn_products_elasticsearch]: https://www.elastic.co/cn/products/elasticsearch
[70 3]: /images/20220509/2aca3657daa44c319c46849aa6f8cf18.png
[70 4]: /images/20220509/6df211ffb09d45378ad07bb96a73d3d9.png
[https_www.elastic.co_downloads_past-releases]: https://www.elastic.co/downloads/past-releases
[70 5]: /images/20220509/67093e55db4242149f6c4bec7a50512b.png
[70 6]: /images/20220509/44e03cd90708406daecf18db9112a03f.png
[70 7]: /images/20220509/71369f0bb47747d59eeba9b8282313d8.png
[70 8]: /images/20220509/4690d689635d4dc0bd30e3f8be99438b.png
[http_127.0.0.1_9200]: http://127.0.0.1:9200
[70 9]: /images/20220509/9747a3f215ce454f85b662abd8d4ced5.png
[https_github.com_mobz_elasticsearch-head]: https://github.com/mobz/elasticsearch-head
[https_nodejs.org_en_download]: https://nodejs.org/en/download/
[70 10]: /images/20220509/8a0251b2d803484a9cda4636104d09c1.png
[70 11]: /images/20220509/355fd4bc403b4674826da7b487cd3116.png
[70 12]: /images/20220509/5303e974a0494326b530064a6367db45.png
[cluster.name]: http://xn--cluster-gf3lu88i.name
[node.name]: http://node.name
[70 13]: /images/20220509/ba7b348e8cec478097fdc56439a7ebe8.png
[70 14]: /images/20220509/fa79288be6e04302bdceab5151136cca.png
[http_www.oschina.net_news_2660]: http://www.oschina.net/news/2660
[70 15]: /images/20220509/af2d5aba7a68454aa555b74be66a1ec4.png
[70 16]: /images/20220509/ad89fab132f2492cbcd0dd35f5a7aaee.png
[https_github.com_medcl_elasticsearch-analysis-ik_tree_6.2.x]: https://github.com/medcl/elasticsearch-analysis-ik/tree/6.2.x
[https_github.com_medcl_elasticsearch-analysis-ik_releases]: https://github.com/medcl/elasticsearch-analysis-ik/releases
[70 17]: /images/20220509/3d27352074cf4c398dbc07e7609f9744.png
[70 18]: /images/20220509/3af1521e58a44e488d069d61e9d3b909.png
[70 19]: /images/20220509/06f00b27561844b1b66e4a92d4c415c2.png
[70 20]: /images/20220509/d3323ece4acb4890ad2f06442b102931.png
[70 21]: /images/20220509/321af3c1cbe14bbba39e83af52608a54.png
[70 22]: /images/20220509/6588c81b103244a8b223b80548faf673.png
[70 23]: /images/20220509/74da490cbc6f41f5b35f5fe83ffc63ca.png
[http_projects.spring.io_spring-data]: http://projects.spring.io/spring-data/
[70 24]: /images/20220509/74ef95a5b2af431bbdb0d70c64065148.png
[70 25]: /images/20220509/a6da06650eb44967ae8cbd1649ba00c1.png
[https_projects.spring.io_spring-data-elasticsearch]: https://projects.spring.io/spring-data-elasticsearch/
[70 26]: /images/20220509/7a216778a1ac49dbb3904cab947b07e6.png
[70 27]: /images/20220509/a9ed55a47cdd44a79badf2f0169b1d2b.png
[70 28]: /images/20220509/1015f7f7fb774cf69b43f51a1669e053.png
[70 29]: /images/20220509/6cba2e0fd37043aa876cbf7c05a6a913.png
[70 30]: /images/20220509/d5a9537fb9304cf98aba2581b1c60d38.png
[70 31]: /images/20220509/b13b9b069542451d8d32264bf6239852.png
[70 32]: /images/20220509/cee4a6dcafe84ee080c523984fa10100.png
[70 33]: /images/20220509/747c500a612f47efac855c6d4193b688.png
[70 34]: /images/20220509/a83b35429cb34fa3aee9c3c591f9d2f0.png
[70 35]: /images/20220509/f4564392f810498eb8f823bd811adc26.png
[70 36]: /images/20220509/da63c029d5d04b708bfd72aa0f4d6069.png
[70 37]: /images/20220509/5df64131bd5a43ca804fcb3605187f42.png
[70 38]: /images/20220509/306fc5f2b59d4ed49dccfef7156bd345.png
[70 39]: /images/20220509/ee5e4f0a50314df7a0123d68b330c4cd.png
[70 40]: /images/20220509/cc543ffb2307493e96a457811f343f52.png
[70 41]: /images/20220509/bfa0f16a582e4213b3fdff6c32885bd7.png
[70 42]: /images/20220509/7586f37bc4204a9fbe91cb392435a724.png
[70 43]: /images/20220509/1037f31ab1aa4f919de34e50507188aa.png
[70 44]: /images/20220509/a49c5674629941609106d3dc50a98f5c.png
[70 45]: /images/20220509/cd10639a30df4a43b7594ba8c1a2d08a.png
[70 46]: /images/20220509/385cc4c4aa2e407c8a77ddcd23de806e.png
[70 47]: /images/20220509/90c2f981fda34397a6f14069385ceee9.png
[70 48]: /images/20220509/a883b118db2447d08e14a552effb5ed8.png
[70 49]: /images/20220509/04468fae90324dc4b5605998fe2fa5c9.png
[70 50]: /images/20220509/34a774392d1f4f1d8676d4b7899b4f25.png
[70 51]: /images/20220509/efb2f42234f54ebcbb5cb6bc07365985.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjYzMzEzMQ_size_16_color_FFFFFF_t_70]: /images/20220509/5b8e57bb5c1c4682b118af2bd507be5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjYzMzEzMQ_size_16_color_FFFFFF_t_70 1]: /images/20220509/2bf8c4b465554562b37e8d56336b8c76.png