SpringBoot整合Elasticsearch详细步骤以及代码示例(附源码)

准备工作

环境准备

JAVA版本

java version "1.8.0_121"
Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

ES版本

{
  "name": "pYaFJhZ",
  "cluster_name": "my-cluster",
  "cluster_uuid": "oC28y-cNQduGItC7qq5W8w",
  "version": {
    "number": "6.8.2",
    "build_flavor": "oss",
    "build_type": "tar",
    "build_hash": "b506955",
    "build_date": "2019-07-24T15:24:41.545295Z",
    "build_snapshot": false,
    "lucene_version": "7.7.0",
    "minimum_wire_compatibility_version": "5.6.0",
    "minimum_index_compatibility_version": "5.0.0"
  },
  "tagline": "You Know, for Search"
}

SpringBoot版本

2.1.7.RELEASE

开发工具使用的是IDEA

安装ES

Elasticsearch介绍以及安装:ElasticSearch入门-基本概念介绍以及安装

开始

创建SpringBoot项目

  1. 打开IDEA,在菜单中点击
    File > New > Project...
    在弹框中选择Spring Initializr
    [外链图片转存失败(img-LDUSzHZ3-1568942392244)(https://www.lifengdi.com/wp-content/uploads/2019/09/2019091810411464.jpg ‘图1’)]
    然后Next

  2. 填写项目名等,然后Next
    [外链图片转存失败(img-O6XWn6Qj-1568942392277)(https://www.lifengdi.com/wp-content/uploads/2019/09/2019091810433646.jpg ‘图2’)]

  3. 选择依赖的jar包(一般我只选Lombok,其他的自己手动加),然后Next
    [外链图片转存失败(img-9uHbllmT-1568942392281)(https://www.lifengdi.com/2019091810541514 ‘图3’)]

  4. 最后选择项目所在路径,点击Finish
    [外链图片转存失败(img-gC8wNUNN-1568942392288)(https://www.lifengdi.com/2019091810515396 ‘图3’)]

搞定收工。至此,一个新的SpringBoot项目就新鲜出炉了。

POM文件

当然,具体依赖的jar包肯定不止第2步选择的那些,其中SpringBoot提供的操作ES的jar包spring-boot-starter-data-elasticsearch当然也是必不可少的。

这里贴出最终的pom文件:


<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.7.RELEASEversion>
        <relativePath/> 
    parent>
    <groupId>com.lifengdigroupId>
    <artifactId>searchartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>searchname>
    <description>elasticsearchdescription>

    <properties>
        <java.version>1.8java.version>
        <testng.version>6.14.2testng.version>
        <spring-cloud-dependencies.version>Greenwich.RELEASEspring-cloud-dependencies.version>
        <kibana-logging-spring-boot-starter.version>1.2.4kibana-logging-spring-boot-starter.version>
        <fastjson.version>1.2.47fastjson.version>
        <alarm-spring-boot-starter.version>1.0.15-SNAPSHOTalarm-spring-boot-starter.version>
    properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>${spring-cloud-dependencies.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-elasticsearchartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-configuration-processorartifactId>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.testnggroupId>
            <artifactId>testngartifactId>
            <version>${testng.version}version>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>joda-timegroupId>
            <artifactId>joda-timeartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>fastjsonartifactId>
            <version>${fastjson.version}version>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-openfeignartifactId>
        dependency>

        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-lang3artifactId>
        dependency>

    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>

application.yml文件

application.yml文件配置如下:

server:
  port: 8080
  servlet:
    context-path: /search
spring:
  application:
    name: search
  data:
    elasticsearch:
      cluster-name: my-cluster
      cluster-nodes: localhost:9300
  jackson:
    default-property-inclusion: non_null

logging:
  file: application.log
  path: .
  level:
    root: info
    com.lifengdi.store.client: DEBUG

index-entity:
  configs:
    - docCode: store
      indexName: store
      type: base
      documentPath: com.lifengdi.document.StoreDocument

spring.data.elasticsearch.cluster-name:集群名称

spring.data.elasticsearch.cluster-nodes:集群节点地址列表,多个节点用英文逗号(,)分隔

创建ES文档和映射

首先创建一个JAVA对象,然后通过注解来声明字段的映射属性。
spring提供的注解有@Document@Id@Field,其中@Document作用在类,@Id@Field作用在成员变量,@Id标记一个字段作为id主键。

package com.lifengdi.document;

import com.lifengdi.document.store.*;
import com.lifengdi.search.annotation.DefinitionQuery;
import com.lifengdi.search.enums.QueryTypeEnum;
import lombok.Data;
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;

import java.util.List;

/**
 * 门店Document
 *
 * @author 李锋镝
 * @date Create at 19:31 2019/8/22
 */
@Document(indexName = "store", type = "base")
@Data
@DefinitionQuery(key = "page", type = QueryTypeEnum.IGNORE)
@DefinitionQuery(key = "size", type = QueryTypeEnum.IGNORE)
@DefinitionQuery(key = "q", type = QueryTypeEnum.FULLTEXT)
public class StoreDocument {

    @Id
    @DefinitionQuery(type = QueryTypeEnum.IN)
    @DefinitionQuery(key = "id", type = QueryTypeEnum.IN)
    @Field(type = FieldType.Keyword)
    private String id;

    /**
     * 基础信息
     */
    @Field(type = FieldType.Object)
    private StoreBaseInfo baseInfo;

    /**
     * 标签
     */
    @Field(type = FieldType.Nested)
    @DefinitionQuery(key = "tagCode", mapped = "tags.key", type = QueryTypeEnum.IN)
    @DefinitionQuery(key = "tagValue", mapped = "tags.value", type = QueryTypeEnum.AND)
    @DefinitionQuery(key = "_tagValue", mapped = "tags.value", type = QueryTypeEnum.IN)
    private List<StoreTags> tags;

}

创建索引

ElasticsearchTemplate提供了四个createIndex()方法来创建索引,可以根据类的信息自动生成,也可以手动指定indexName和Settings

@Override
public <T> boolean createIndex(Class<T> clazz) {
	return createIndexIfNotCreated(clazz);
}

@Override
public boolean createIndex(String indexName) {
	Assert.notNull(indexName, "No index defined for Query");
	return client.admin().indices().create(Requests.createIndexRequest(indexName)).actionGet().isAcknowledged();
}
@Override
public boolean createIndex(String indexName, Object settings) {
	CreateIndexRequestBuilder createIndexRequestBuilder = client.admin().indices().prepareCreate(indexName);
	if (settings instanceof String) {
		createIndexRequestBuilder.setSettings(String.valueOf(settings), Requests.INDEX_CONTENT_TYPE);
	} else if (settings instanceof Map) {
		createIndexRequestBuilder.setSettings((Map) settings);
	} else if (settings instanceof XContentBuilder) {
		createIndexRequestBuilder.setSettings((XContentBuilder) settings);
	}
	return createIndexRequestBuilder.execute().actionGet().isAcknowledged();
}

@Override
public <T> boolean createIndex(Class<T> clazz, Object settings) {
	return createIndex(getPersistentEntityFor(clazz).getIndexName(), settings);
}

创建映射

ElasticsearchTemplate提供了三个putMapping()方法来创建映射

@Override
public <T> boolean putMapping(Class<T> clazz) {
	if (clazz.isAnnotationPresent(Mapping.class)) {
		String mappingPath = clazz.getAnnotation(Mapping.class).mappingPath();
		if (!StringUtils.isEmpty(mappingPath)) {
			String mappings = readFileFromClasspath(mappingPath);
			if (!StringUtils.isEmpty(mappings)) {
				return putMapping(clazz, mappings);
			}
		} else {
			LOGGER.info("mappingPath in @Mapping has to be defined. Building mappings using @Field");
		}
	}
	ElasticsearchPersistentEntity<T> persistentEntity = getPersistentEntityFor(clazz);
	XContentBuilder xContentBuilder = null;
	try {

		ElasticsearchPersistentProperty property = persistentEntity.getRequiredIdProperty();

		xContentBuilder = buildMapping(clazz, persistentEntity.getIndexType(),
				property.getFieldName(), persistentEntity.getParentType());
	} catch (Exception e) {
		throw new ElasticsearchException("Failed to build mapping for " + clazz.getSimpleName(), e);
	}
	return putMapping(clazz, xContentBuilder);
}

@Override
public <T> boolean putMapping(Class<T> clazz, Object mapping) {
	return putMapping(getPersistentEntityFor(clazz).getIndexName(), getPersistentEntityFor(clazz).getIndexType(),
			mapping);
}

@Override
public boolean putMapping(String indexName, String type, Object mapping) {
	Assert.notNull(indexName, "No index defined for putMapping()");
	Assert.notNull(type, "No type defined for putMapping()");
	PutMappingRequestBuilder requestBuilder = client.admin().indices().preparePutMapping(indexName).setType(type);
	if (mapping instanceof String) {
		requestBuilder.setSource(String.valueOf(mapping), XContentType.JSON);
	} else if (mapping instanceof Map) {
		requestBuilder.setSource((Map) mapping);
	} else if (mapping instanceof XContentBuilder) {
		requestBuilder.setSource((XContentBuilder) mapping);
	}
	return requestBuilder.execute().actionGet().isAcknowledged();
}

测试代码如下

@Test
public void testCreate() {
    System.out.println(elasticsearchTemplate.createIndex(StoreDocument.class));
    System.out.println(elasticsearchTemplate.putMapping(StoreDocument.class));
}

删除索引

ElasticsearchTemplate提供了2个deleteIndex()方法来删除索引

@Override
public <T> boolean deleteIndex(Class<T> clazz) {
	return deleteIndex(getPersistentEntityFor(clazz).getIndexName());
}

@Override
public boolean deleteIndex(String indexName) {
	Assert.notNull(indexName, "No index defined for delete operation");
	if (indexExists(indexName)) {
		return client.admin().indices().delete(new DeleteIndexRequest(indexName)).actionGet().isAcknowledged();
	}
	return false;
}

新增&修改文档

在Elasticsearch中文档是不可改变的,不能修改它们。相反,如果想要更新现有的文档,需要重建索引或者进行替换。

所以可以使用和新增同样的接口来对文档进行修改操作。区分的依据就是id。

下面提供新增&修改文档的其中两种方法,一种是通过ElasticsearchTemplate提供的index()方法:

@Override
public String index(IndexQuery query) {
	String documentId = prepareIndex(query).execute().actionGet().getId();
	// We should call this because we are not going through a mapper.
	if (query.getObject() != null) {
		setPersistentEntityId(query.getObject(), documentId);
	}
	return documentId;
}

示例代码如下:

/**
 * 更新索引
 * @param indexName 索引名称
 * @param type 索引类型
 * @param id ID
 * @param jsonDoc JSON格式的文档
 * @param refresh 是否刷新索引
 * @return ID
 */
public String index(String indexName, String type, String id, JsonNode jsonDoc, boolean refresh)
            throws JsonProcessingException {

        log.info("AbstractDocumentIndexService更新索引.indexName:{},type:{},id:{},jsonDoc:{}", indexName, type, id, jsonDoc);
        IndexQuery indexQuery = new IndexQueryBuilder()
                .withIndexName(indexName)
                .withType(type)
                .withId(id)
                .withSource(objectMapper.writeValueAsString(jsonDoc))
                .build();
        try {
            if (elasticsearchTemplate.indexExists(indexName)) {
                String index = elasticsearchTemplate.index(indexQuery);
                if (refresh) {
                    elasticsearchTemplate.refresh(indexName);
                }
                return index;
            }
        } catch (Exception e) {
            log.error("更新索引失败,刷新ES重试", e);
            elasticsearchTemplate.refresh(indexName);
            return elasticsearchTemplate.index(indexQuery);
        }
        throw BaseException.INDEX_NOT_EXISTS_EXCEPTION.build();
    }

另一种则是通过Repository接口。Spring提供的ES的Repository接口为ElasticsearchCrudRepository,所以我们就可以直接定义额新的接口,然后实现ElasticsearchCrudRepository即可:

package com.taoche.docindex.repo;

import com.taoche.document.StoreDocument;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

/**
 * 门店Repository
 * @author 李锋镝
 * @date Create at 09:30 2019/8/23
 */
public interface StoreRepository extends ElasticsearchRepository<StoreDocument, String> { }

示例代码如下:

@Test
public void testSave() {

    StoreDocument storeDocument = new StoreDocument();
    storeDocument.setId("1");
    StoreBaseInfo baseInfo = new StoreBaseInfo();
    baseInfo.setStoreId("1");
    baseInfo.setCreatedTime(DateTime.now());
    storeDocument.setBaseInfo(baseInfo);

    storeRepository.save(storeDocument);
}

查询

ES的主要功能就是查询,ElasticsearchRepository也提供了基本的查询接口,比如findById()findAll()findAllById()search()等方法;当然也可以使用Spring Data提供的另外一个功能:Spring Data JPA——通过方法名创建查询,当然需要遵循一定的规则,比如你的方法名叫做findByTitle(),那么它就知道你是根据title查询,然后自动帮你完成,这里就不仔细说了。

上边说的基本能满足一般的查询,复杂一点的查询就无能为力了,这就需要用到自定义查询,这里可以查看我的另一篇博客SpringBoot使用注解的方式构建Elasticsearch查询语句,实现多条件的复杂查询,这里边有详细的说明。

另外还有一个比较厉害的功能,Elasticsearch的聚合;聚合主要实现的是对数据的统计、分析。这个暂时没有用到的,所以要看聚合功能的小伙伴们可能要失望了~ 哈哈哈~~~

聚合功能以后有时间会再单独说的~都会有的。

至此,SpringBoot整合Elasticsearch基本结束,有什么不明白的地方请留言~

源码

Git项目地址:search

如果觉得有帮助的话,请帮忙点赞、点星小小的支持一下~

谢谢~~

原文链接:https://www.lifengdi.com/archives/article/945

你可能感兴趣的:(Elasticsearch,Java-开发之路,SpringBoot)