ElasticSearcher的部署和使用

最新推荐文章于 2023-04-06 19:37:55 发布

冰烬之沫

最新推荐文章于 2023-04-06 19:37:55 发布

阅读量326

点赞数

分类专栏：中间件 # java 文章标签： elasticsearch java

本文链接：https://blog.csdn.net/BingJin_mo/article/details/115314467

版权

java 同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

中间件

4 篇文章 0 订阅

订阅专栏

ElasticSearcher的部署和使用

1.ElasticSearcher的部署

1.1 CentOS7.x下的直接部署

安装java环境（jdk1.8+）

# 下在jdk1.8的包
wget https://repo.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.tar.gz
或
curl -O https://repo.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.tar.gz

# 将包移动到指定目录并解压
mkdir /usr/local/java
mv jdk-8u202-linux-x64.tar.gz /usr/local/java/
cd /usr/local/java
tar -zxvf jdk-8u202-linux-x64.tar.gz

# 配置环境变量
vim /etc/profile
# 在末尾添加以下内容
export JAVA_HOME=/usr/local/java/jdk1.8.0_202
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib:$CLASSPATH
export JAVA_PATH=${JAVA_HOME}/bin:${JRE_HOME}/bin
export PATH=$PATH:${JAVA_PATH}

# 加载环境变量配置文件
source /etc/profile

# 查看是否安装成功
java -version

创建普通用户（ElasticSearcher服务必须以普通用户身份启动）

# 创建新的组
groupadd es

# 创建新的用户并添加到组中
useradd es -g es

# 修改用户密码
passwd es

使用普通用户登录，下载ElasticSearcher源码包

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.8.0.tar.gz
或
curl -O https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.8.0.tar.gz

解压源码包

tar -zxvf elasticsearch-6.8.0.tar.gz

开启远程连接

# 修改配置文件
vim elasticsearch-6.8.0/config/elasticsearch.yml
# 修改配置如下
network.host: 0.0.0.0

使用root用户修改系统配置的limits.conf配置文件

# 修改limits.conf配置文件
vim /etc/security/limits.conf
# 在文件末尾追加以下内容
*               soft    nofile             65536
*               hard    nofile             65536
*               soft    nproc              4096
*               hard    nproc              4096

重新登录查看配置是否生效

ulimit -Hn
ulimit -Sn
ulimit -Hu
ulimit -Su

使用root用户修改系统配置的20-nproc.conf配置文件

# 修改20-nproc.conf配置文件
vim /etc/security/limits.d/20-nproc.conf
# 修改配置如下(将*改为启动ElasticSearcher服务的普通用户名)
es         soft    nproc     4096

使用root用户修改系统配置的sysctl.conf配置文件

# 修改sysctl.conf配置文件
vim /etc/sysctl.conf
# 在文件末尾追加以下内容
vm.max_map_count=655360

查看配置是否生效

sysctl -p

使用普通用户重新登录，开启ElasticSearcher服务

# 进入ElasticSearcher的bin目录
cd elasticsearch-6.8.0/bin

# 开启ElasticSearcher服务
./elasticsearch

1.2 CentOS7.x下通过Docker的安装部署

设置max_map_count

# 修改sysctl.conf配置文件
vim /etc/sysctl.conf
# 在文件末尾追加以下内容
vm.max_map_count=655360

# 查看配置是否生效
sysctl -p

安装部署命令

docker run --name elasticsearch -d -e ES_JAVA_OPTS="-Xms512m -Xmx512m" -e "discovery.type=single-node" -p 9200:9200 -p 9300:9300 elasticsearch:6.8.0

进入容器命令

docker exec -it elasticsearch /bin/bash

1.3 安装IK分词器

在线安装

# 进入ElasticSearch的bin目录
cd elasticsearch-6.8.0/bin

# 使用插件在线安装
./elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.0/elasticsearch-analysis-ik-6.8.0.zip

# 删除ElasticSearch的data数据目录
rm -rf elasticsearch-6.8.0/data
# 重启ElasticSearch服务生效

本地安装

# 下载ik源码包
wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.0/elasticsearch-analysis-ik-6.8.0.zip
或
curl -O https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.0/elasticsearch-analysis-ik-6.8.0.zip

# 解压
unzip elasticsearch-analysis-ik-6.8.0.zip -d elasticsearch-analysis-ik-6.8.0

# 将解压文件移动到ElasticSearch的plugins目录中
mv elasticsearch-analysis-ik-6.8.0 ./elasticsearch-6.8.0/plugins/

# 删除ElasticSearch的data数据目录
rm -rf elasticsearch-6.8.0/data
# 重启ElasticSearch服务生效

配置扩展、停用词典

# 添加以.dic结尾的文件
touch elasticsearch-6.8.0/plugins/elasticsearch-analysis-ik-6.8.0/config/ext.dic
touch elasticsearch-6.8.0/plugins/elasticsearch-analysis-ik-6.8.0/config/stop.dic

# 编辑扩展词典文件(每行存放一个扩展或停用词)
vim elasticsearch-6.8.0/plugins/elasticsearch-analysis-ik-6.8.0/config/ext.dic
vim elasticsearch-6.8.0/plugins/elasticsearch-analysis-ik-6.8.0/config/stop.dic

# 修改IK配置文件
vim elasticsearch-6.8.0/plugins/elasticsearch-analysis-ik-6.8.0/config/IKAnalyzer.cfg.xml
# 修改配置如下
<entry key="ext_dict">ext.dic<entry>			# 扩展词典
<entry key="ext_stopwords">stop.dic</entry>		# 停用词典

# 删除ElasticSearch的data数据目录
rm -rf elasticsearch-6.8.0/data
# 重启ElasticSearch服务生效

配置远程扩展、停用词典

# 修改IK配置文件
vim elasticsearch-6.8.0/plugins/elasticsearch-analysis-ik-6.8.0/config/IKAnalyzer.cfg.xml
# 修改配置如下
<entry key="remote_ext_dict">http://ip:port/ext.txt</entry>			# 扩展词典
<entry key="remote_ext_stopwords">http://ip:port/stop.txt</entry>	# 停用词典

# 删除ElasticSearch的data数据目录
rm -rf elasticsearch-6.8.0/data
# 重启ElasticSearch服务生效

1.4 跨域配置

修改ElasticSearch的配置文件

# 修改elasticsearch.yml文件
vim elasticsearch-6.8.0/config/elasticsearch.yml
# 在文件末尾追加以下内容
http.cors.enabled: true 
http.cors.allow-origin: "*"

# 重启ElasticSearch服务生效

1.5 集群

设置启动内存

# 修改jvm.options文件
vim elasticsearch-6.8.0/config/jvm.options
# 修改配置如下（根据实际情况修改）
-Xms512m
-Xmx512m

修改ElasticSearch的配置文件

# 修改elasticsearch.yml文件
vim elasticsearch-6.8.0/config/elasticsearch.yml
# 修改配置如下
cluster.name: es-cluster		# 集群名称
node.name: es-01				# 集群当前节点名称
network.host: 0.0.0.0			# 开启远程连接
http.port: 9200					# 监听端口
discovery.zen.ping.unicast.hosts: ["192.168.1.2:9200", "192.168.1.2:9300"]	# 其他节点地址
gateway.recover_after_nodes: 3	# 集群可做master的最小节点数
transport.tcp.port: 9300		# 集群TCP端口

查看集群健康状态：访问http://ip:port/_cat/health?v

2. ElasticSearch的使用

2.1 SpringBoot集成ElasticSearch

新建SpringBoot项目
pom.xml依赖

<dependencies>

        <!--web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--ElasticSearcher依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

        <!--lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!--测试依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

application.yml配置

# 服务器端口
server:
  port: 8080

ElasticSearcher配置类

import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.RestClients;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;

/**
 * ElasticSearcher配置类
 */
@Configuration
public class ElasticSearcherRestClientConfiguration extends AbstractElasticsearchConfiguration {

    /**
     * 创建RestHighLevelClient对象
     */
    @Override
    @Bean
    public RestHighLevelClient elasticsearchClient() {

        // 定义客户端配置对象
        final ClientConfiguration clientConfiguration = ClientConfiguration
                .builder()
                .connectedTo("192.168.150.128:9200")
                .build();

        // 通过RestClients对象创建RestHighLevelClient对象
        return RestClients.create(clientConfiguration).rest();
    }

}

2.2 使用高级客户端RestHighLevelClient操作ElasticSearcher

操作索引

import org.elasticsearch.ElasticsearchStatusException;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
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.settings.Settings;
import org.elasticsearch.rest.RestStatus;
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;
import java.util.Set;

/**
 * 有关索引操作的测试
 */
@SpringBootTest
class IndexTests {

    @SuppressWarnings("all")
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 创建索引
     */
    @Test
    void createIndex() throws IOException {

        int INDEX_NUMBER_OF_SHARDS = 1;     // 索引分片数量
        int INDEX_NUMBER_OF_REPLICAS = 1;   // 索引副本数量
        String CREATE_INDEX_NAME = "person2";   // 要创建的索引名
        Map<String, String> FIELDS = new HashMap<>();   // 要创建的索引类型下的字段（名称，类型）

        FIELDS.put("name", "keyword");
        FIELDS.put("age", "integer");
        FIELDS.put("info", "text");

        // 创建索引请求对象
        CreateIndexRequest createIndexRequest = new CreateIndexRequest(CREATE_INDEX_NAME);

        // 设置索引请求对象
        createIndexRequest.settings(Settings
                .builder()
                .put("index.number_of_shards", INDEX_NUMBER_OF_SHARDS)   // 分片数量
                .put("index.number_of_replicas", INDEX_NUMBER_OF_REPLICAS) // 分片副本数量
        );

        // 设置映射字段及类型
        Map<String, Object> fields = new HashMap<>();
        Set<String> fieldNameSet = FIELDS.keySet();
        for (String fieldName : fieldNameSet) {
            Map<String, Object> field = new HashMap<>();
            field.put("type", FIELDS.get(fieldName));   // 设置属性字段类型
            if ("text".equals(FIELDS.get(fieldName))) {
                field.put("analyzer", "ik_max_word");   // 设置IK分词器
            }
            fields.put(fieldName, field);
        }

        Map<String, Object> properties = new HashMap<>();
        properties.put("properties", fields);
        createIndexRequest.mapping(properties);

        // 通过索引请求对象创建索引
        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);

        if (createIndexResponse.isAcknowledged()){
            System.out.println("创建索引成功");
        } else {
            System.out.println("创建索引失败");
        }

    }

    /**
     * 删除索引
     */
    @Test
    void deleteIndex() throws IOException {

        String[] DELETE_INDEX_NAMES = {"person"};  // 要删除的索引名数组

        // 删除索引请求对象
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(DELETE_INDEX_NAMES);

        AcknowledgedResponse acknowledgedResponse = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);

        if (acknowledgedResponse.isAcknowledged()) {
            System.out.println("删除索引成功");
        } else {
            System.out.println("删除索引失败");
        }
    }

    /**
     * 查询索引
     */
    @Test
    void getIndexAll() throws IOException {

        String[] GET_INDEX_NAMES = {"_all"};  // 要查询的索引名数组（"_all"表示所有索引）

        // 查询索引请求对象
        GetIndexRequest getIndexRequest = new GetIndexRequest(GET_INDEX_NAMES);

        try {
            // 获取所有索引的返回对象
            GetIndexResponse getIndexResponse = restHighLevelClient.indices().get(getIndexRequest, RequestOptions.DEFAULT);
            Map<String, MappingMetaData> mappings = getIndexResponse.getMappings();

            Set<String> indexNameSet = mappings.keySet();
            for (String indexName : indexNameSet) {
                System.out.println("++++++++++++++++++++++++++++++++++++");
                System.out.println("索引名：" + indexName);
                System.out.println("类型名：" + mappings.get(indexName).type());

                Map<String, Object> properties = mappings.get(indexName).sourceAsMap();
                Map<String, Object> fields = (Map<String, Object>) properties.get("properties");

                System.out.println("属性字段：");
                Set<String> fieldNameSet = fields.keySet();
                for (String fieldName : fieldNameSet) {
                    Map<String, Object> field = (Map<String, Object>) fields.get(fieldName);
                    System.out.println("\t" + fieldName + ": " + field.get("type"));
                }
            }
        } catch (ElasticsearchStatusException e) {
            if (RestStatus.NOT_FOUND.equals(e.status())) {
                System.out.println("没有索引");
            } else {
                e.printStackTrace();
            }
        }
    }

}

操作文档

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
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.*;

/**
 * 有关文档数据数据操作的测试
 */
@SpringBootTest
class DocumentTests {

    @SuppressWarnings("all")
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 创建文档
     */
    @Test
    void createDocument() throws IOException {

        String INDEX_NAME = "person";   // 索引名
        String TYPE = "_doc";   // 索引类型

        // 创建索引文档请求操作对象
        IndexRequest indexRequest = new IndexRequest(INDEX_NAME, TYPE);

        // 设置文档值
        Map<String, Object> fieldValues = new HashMap<>();
        fieldValues.put("name", "张三");
        fieldValues.put("age", 19);
        fieldValues.put("info", "张三是个好人！");

        indexRequest.source(fieldValues);

        // 创建索引文档
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);

        if (RestStatus.CREATED.equals(indexResponse.status())) {
            System.out.println("创建文档成功");
        } else {
            System.out.println("创建文档失败");
        }
    }

    /**
     * 删除文档
     */
    @Test
    void deleteDocument() throws IOException {

        String INDEX_NAME = "person";   // 索引名
        String TYPE = "_doc";   // 索引类型
        String DOCUMENT_ID = "e4uAf3gB_a05_96F39MM";    // 文档ID

        // 删除索引文档请求操作对象
        DeleteRequest deleteRequest = new DeleteRequest(INDEX_NAME, TYPE, DOCUMENT_ID);

        // 删除索引文档
        DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);

        if (RestStatus.OK.equals(deleteResponse.status())) {
            System.out.println("删除文档成功");
        } else {
            System.out.println("删除文档失败");
        }
    }

    /**
     * 修改文档
     */
    @Test
    void updateDocument() throws IOException {

        String INDEX_NAME = "person";   // 索引名
        String TYPE = "_doc";   // 索引类型
        String DOCUMENT_ID = "fYsMgHgB_a05_96FytPb";    // 文档ID

        // 更新索引文档请求操作对象
        UpdateRequest updateRequest = new UpdateRequest(INDEX_NAME, TYPE, DOCUMENT_ID);

        // 设置文档要更新的值
        Map<String, Object> updateFieldValues = new HashMap<>();
        updateFieldValues.put("name", "李四");
        updateFieldValues.put("age", 20);

        updateRequest.doc(updateFieldValues);

        // 更新索引文档
        UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);

        if (RestStatus.OK.equals(updateResponse.status())) {
            System.out.println("删除文档成功");
        } else {
            System.out.println("删除文档失败");
        }
    }

    /**
     * 查询文档
     */
    @Test
    void searcherDocument() throws IOException {

        String INDEX_NAME = "person";   // 索引名
        String TYPE = "_doc";   // 索引类型

        // 查询索引文档请求操作对象
        SearchRequest searchRequest = new SearchRequest(INDEX_NAME);

        // 查询条件对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder
                .query(QueryBuilders.termQuery("info", "张"))   // 查询条件
                .from(0)    // 从第几条文档开始获取
                .size(20)   // 每次获取多少条文档
                .postFilter(QueryBuilders.matchAllQuery())  // 过滤条件
                .sort("age", SortOrder.DESC)    // 排序
                .highlighter(new HighlightBuilder()     // 高亮
                        .field("*")     // 高亮的字段
                        .requireFieldMatch(false)   // 关闭仅匹配字段高亮
                        .preTags("<span style='color: red;'>")  // 高亮字段前缀
                        .postTags("</span>")    // 高亮字段后缀
                );

        searchRequest.types(TYPE).source(searchSourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        System.out.println("+++++++++++++++++++++++++++++++++++++++++++\n");

        System.out.println("符合条件的文档总数：" + searchResponse.getHits().getTotalHits() + "\n");
        System.out.println("符合条件的文档得分最大值：" + searchResponse.getHits().getMaxScore() + "\n");

        SearchHit[] documents = searchResponse.getHits().getHits();

        System.out.println("文档：\n");
        int count = 1;
        for (SearchHit document : documents) {

            // 文档ID
            System.out.println(count + ":\t_id: " + document.getId());

            // 文档数据
            Map<String, Object> documentMap = document.getSourceAsMap();
            Set<String> fieldNames = documentMap.keySet();
            if (!fieldNames.isEmpty()) {
                System.out.println("\t_source: ");
                for (String fieldName : fieldNames) {
                    if ("id".equals(fieldName)) {
                        continue;
                    }
                    System.out.println("\t\t" + fieldName + ": " + documentMap.get(fieldName));
                }
            }

            // 高亮数据
            Map<String, HighlightField> highlightDocumentMap = document.getHighlightFields();
            Set<String> highlightFieldNames = highlightDocumentMap.keySet();
            if (!highlightFieldNames.isEmpty()) {
                System.out.println("\t_highlight: ");
                for (String highlightFieldName : highlightFieldNames) {
                    System.out.println("\t\t" + highlightFieldName + ": " + highlightDocumentMap.get(highlightFieldName).fragments()[0]);
                }
            }

            System.out.println();

            count++;
        }

        System.out.println("+++++++++++++++++++++++++++++++++++++++++++");
    }

    /**
     * 批量操作
     */
    @Test
    void bulkDocument() throws IOException {

        String INDEX_NAME = "person";   // 索引名
        String TYPE = "_doc";   // 索引类型
        String DOCUMENT_ID = "fYsMgHgB_a05_96FytPb";    // 文档ID

        // 批量操作索引文档请求操作对象
        BulkRequest bulkRequest = new BulkRequest();

        // 创建索引文档请求操作对象
        IndexRequest indexRequest = new IndexRequest(INDEX_NAME, TYPE);

        // 设置文档值
        Map<String, Object> fieldValues = new HashMap<>();
        fieldValues.put("name", "小明");
        fieldValues.put("age", 12);
        fieldValues.put("info", "小明是个好学生！");

        indexRequest.source(fieldValues);

        // 更新索引文档请求操作对象
        UpdateRequest updateRequest = new UpdateRequest(INDEX_NAME, TYPE, DOCUMENT_ID);

        // 设置文档要更新的值
        Map<String, Object> updateFieldValues = new HashMap<>();
        updateFieldValues.put("name", "王五");
        updateFieldValues.put("age", 21);

        updateRequest.doc(updateFieldValues);

        bulkRequest.add(indexRequest, updateRequest);

        // 批量操作
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

        if (RestStatus.OK.equals(bulkResponse.status())) {
            System.out.println("批量操作文档成功");
        } else {
            System.out.println("批量操作文档失败");
        }

    }

}

2.3 使用Repository接口操作ElasticSearcher

实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

@Document(indexName = "person", type = "_doc")  // 通过该注解会自动创建索引，但索引创建前不能存在
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    @Id
    private String id;

    @Field(type = FieldType.Keyword)
    private String name;

    @Field(type = FieldType.Integer)
    private Integer age;

    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String info;

}

自定义Repository接口

import java.util.List;

/**
 * 自定义Repository接口
 * <Person, String> Person为实体类，String为实体类中主键ID的类型
 */
public interface PersonRepository extends ElasticsearchRepository<Person, String> {

    // 自定义查询
    List<Person> findByAge(Integer age);    // 通过age查询
    List<Person> findByAgeAndName(Integer age, String name);    // 通过age和name查询
    List<Person> findByAgeOrName(Integer age, String name); // 通过age或name查询
    List<Person> findByAgeBetween(Integer low, Integer high);   // 查询age在low和high范围内的
    List<Person> findByAgeGreaterThan(Integer value);   // 查询age大于value的
    List<Person> findByAgeGreaterThanEqual(Integer value);  // 查询age大于等于value的
    List<Person> findByNameStartingWith(String name);   // 查询以name开头的

}

测试

import com.mo.elasticsearcher.elasticsearcher.dao.PersonRepository;
import com.mo.elasticsearcher.model.entity.Person;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;

import java.util.List;
import java.util.Optional;

@SpringBootTest
public class RepositoryTests {

    @Autowired
    private PersonRepository personRepository;

    /**
     * 添加文档
     */
    @Test
    void saveDocument() {

        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        person.setInfo("张三是个好人");

        personRepository.save(person);
    }

    /**
     * 删除文档
     */
    @Test
    void deleteDocument() {
        personRepository.deleteById("f4tPgHgB_a05_96FBNOQ");
    }

    /**
     * 删除所有文档
     */
    @Test
    void deleteDocumentAll() {
        personRepository.deleteAll();
    }

    /**
     * 查询文档
     */
    @Test
    void searcherDocument() {
        Optional<Person> optional = personRepository.findById("f4tPgHgB_a05_96FBNOQ");
        Person person = optional.get();
        System.out.println(person);
    }

    /**
     * 查询所有文档
     */
    @Test
    void searcherDocumentAll() {
        Sort sort = Sort.by(Sort.Order.desc("age"));    // 排序
        Iterable<Person> persons = personRepository.findAll(sort);
        persons.forEach(System.out::println);
    }

    /**
     * 分页
     */
    @Test
    void searcherDocumentLimit() {
        Page<Person> personPage = personRepository.search(QueryBuilders.matchAllQuery(), PageRequest.of(0, 20));
        personPage.forEach(System.out::println);
    }

    /**
     * 自定义查询
     */
    @Test
    void searcherDocumentMore() {

        List<Person> byAge = personRepository.findByAge(18);
        byAge.forEach(System.out::println);

        List<Person> byAgeAndName = personRepository.findByAgeAndName(18, "张三");
        byAgeAndName.forEach(System.out::println);

        List<Person> byAgeOrName = personRepository.findByAgeOrName(18, "张三");
        byAgeOrName.forEach(System.out::println);

        List<Person> byAgeBetween = personRepository.findByAgeBetween(18, 25);
        byAgeBetween.forEach(System.out::println);

        List<Person> byAgeGreaterThan = personRepository.findByAgeGreaterThan(18);
        byAgeGreaterThan.forEach(System.out::println);

        List<Person> byAgeGreaterThanEqual = personRepository.findByAgeGreaterThanEqual(18);
        byAgeGreaterThanEqual.forEach(System.out::println);

        List<Person> byNameStartingWith = personRepository.findByNameStartingWith("张");
        byNameStartingWith.forEach(System.out::println);

    }

}

冰烬之沫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ElasticSearcher的部署和使用

ElasticSearcher的部署和使用1.ElasticSearcher的部署1.1 CentOS7.x下的直接部署安装java环境（jdk1.8+）# 下在jdk1.8的包wget https://repo.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.tar.gz或curl -O https://repo.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.ta
复制链接

扫一扫