SpringBoot整合ES集群

本文整合基于Springboot2.0+，es版本6.2.2，使用spring-boot-starter-data-elasticsearch来做的整合demo

项目结构

pom.xml 引入依赖

<?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.aulton</groupId>
<artifactId>springbootES</artifactId>
<version>1.0.0</version>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
</parent>
<properties>
    <java.version>1.8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
    <!-- springboot依赖包 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
    <!-- spring-boot-starter-data-elasticsearch -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
    <!-- fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.39</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.4</version>
    </dependency>
    <!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.20</version>
    </dependency>
    <dependency>
        <groupId>commons-httpclient</groupId>
        <artifactId>commons-httpclient</artifactId>
        <version>3.1</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>8</source>
                <target>8</target>
            </configuration>
        </plugin>
    </plugins>
</build></project>

application.yml配置文件

server:
    port: 8181
spring:
    data:
      elasticsearch:
        cluster-nodes: ip1:9300,203.ip2:9300,ip3:9300
        cluster-name: my-application

配置文件的配置要根据自己的实际es集群信息填写

配置类

@Configuration
@Slf4j
public class ElasticSearchConfig {

/**
 * 解决netty引起的issue
 */
@PostConstruct
void init() {
    System.setProperty("es.set.netty.runtime.available.processors", "false");
  }
}

实体类

@Data
@ToString
@NoArgsConstructor
public class Author implements Serializable {
private String id;
private String userName;
private String nickName;
private Integer age;
private String slogan;
private Date createTi;
}

分页实体

@Data
@ToString
public class EsPage implements Serializable {

/**
 * 当前页
 */
private int currentPage;
/**
 * 每页显示多少条
 */
private int pageSize;

/**
 * 总记录数
 */
private int recordCount;
/**
 * 本页的数据列表
 */
private List<Map<String, Object>> recordList;

/**
 * 总页数
 */
private int pageCount;
/**
 * 页码列表的开始索引（包含）
 */
private int beginPageIndex;
/**
 * 页码列表的结束索引（包含）
 */
private int endPageIndex;

/**
 * 只接受前4个必要的属性，会自动的计算出其他3个属性的值
 *
 * @param currentPage
 * @param pageSize
 * @param recordCount
 * @param recordList
 */
public EsPage(int currentPage, int pageSize, int recordCount, List<Map<String, Object>> recordList) {
    this.currentPage = currentPage;
    this.pageSize = pageSize;
    this.recordCount = recordCount;
    this.recordList = recordList;

    // 计算总页码
    pageCount = (recordCount + pageSize - 1) / pageSize;

    // 计算 beginPageIndex 和 endPageIndex
    // >> 总页数不多于10页，则全部显示
    if (pageCount <= 10) {
        beginPageIndex = 1;
        endPageIndex = pageCount;
    }
    // 总页数多于10页，则显示当前页附近的共10个页码
    else {
        // 当前页附近的共10个页码（前4个 + 当前页 + 后5个）
        beginPageIndex = currentPage - 4;
        endPageIndex = currentPage + 5;
        // 当前面的页码不足4个时，则显示前10个页码
        if (beginPageIndex < 1) {
            beginPageIndex = 1;
            endPageIndex = 10;
        }
        // 当后面的页码不足5个时，则显示后10个页码
        if (endPageIndex > pageCount) {
            endPageIndex = pageCount;
            beginPageIndex = pageCount - 10 + 1;
        }
    }
 }
}

ES操作工具类

@Component
@Slf4j
public class ElasticsearchUtil {


@Autowired
private TransportClient transportClient;

private static TransportClient client;

/**
 * @PostContruct是spring框架的注解 spring容器初始化的时候执行该方法
 */
@PostConstruct
public void init() {
    client = this.transportClient;
}

/**
 * 创建索引
 *
 * @param index
 * @return
 */
public static boolean createIndex(String index) {
    if (!isIndexExist(index)) {
        log.info("Index is not exits!");
    }
    CreateIndexResponse indexresponse = client.admin().indices().prepareCreate(index).execute().actionGet();
    log.info("执行建立成功？" + indexresponse.isAcknowledged());
    return indexresponse.isAcknowledged();
}

/**
 * 删除索引
 *
 * @param index
 * @return
 */
public static boolean deleteIndex(String index) {
    if (!isIndexExist(index)) {
        log.info("Index is not exits!");
    }
    DeleteIndexResponse dResponse = client.admin().indices().prepareDelete(index).execute().actionGet();
    if (dResponse.isAcknowledged()) {
        log.info("delete index " + index + "  successfully!");
    } else {
        log.info("Fail to delete index " + index);
    }
    return dResponse.isAcknowledged();
}

/**
 * 判断索引是否存在
 *
 * @param index
 * @return
 */
public static boolean isIndexExist(String index) {
    IndicesExistsResponse inExistsResponse = client.admin().indices().exists(new IndicesExistsRequest(index)).actionGet();
    if (inExistsResponse.isExists()) {
        log.info("Index [" + index + "] is exist!");
    } else {
        log.info("Index [" + index + "] is not exist!");
    }
    return inExistsResponse.isExists();
}

/**
 * @Description: 判断inde下指定type是否存在
 */
public boolean isTypeExist(String index, String type) {
    return isIndexExist(index)
            ? client.admin().indices().prepareTypesExists(index).setTypes(type).execute().actionGet().isExists()
            : false;
}

/**
 * 数据添加，正定ID
 *
 * @param jsonObject 要增加的数据
 * @param index      索引，类似数据库
 * @param type       类型，类似表
 * @param id         数据ID
 * @return
 */
public static String addData(JSONObject jsonObject, String index, String type, String id) {
    IndexResponse response = client.prepareIndex(index, type, id).setSource(jsonObject).get();
    log.info("addData response status:{},id:{}", response.status().getStatus(), response.getId());
    return response.getId();
}

/**
 * 数据添加
 *
 * @param jsonObject 要增加的数据
 * @param index      索引，类似数据库
 * @param type       类型，类似表
 * @return
 */
public static String addData(JSONObject jsonObject, String index, String type) {
    return addData(jsonObject, index, type, UUID.randomUUID().toString().replaceAll("-", "").toUpperCase());
}

/**
 * 通过ID删除数据
 *
 * @param index 索引，类似数据库
 * @param type  类型，类似表
 * @param id    数据ID
 */
public static void deleteDataById(String index, String type, String id) {

    DeleteResponse response = client.prepareDelete(index, type, id).execute().actionGet();

    log.info("deleteDataById response status:{},id:{}", response.status().getStatus(), response.getId());
}

/**
 * 通过ID 更新数据
 *
 * @param jsonObject 要增加的数据
 * @param index      索引，类似数据库
 * @param type       类型，类似表
 * @param id         数据ID
 * @return
 */
public static void updateDataById(JSONObject jsonObject, String index, String type, String id) {

    UpdateRequest updateRequest = new UpdateRequest();

    updateRequest.index(index).type(type).id(id).doc(jsonObject);

    client.update(updateRequest);

}

/**
 * 通过ID获取数据
 *
 * @param index  索引，类似数据库
 * @param type   类型，类似表
 * @param id     数据ID
 * @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
 * @return
 */
public static Map<String, Object> searchDataById(String index, String type, String id, String fields) {

    GetRequestBuilder getRequestBuilder = client.prepareGet(index, type, id);

    if (StringUtils.isNotEmpty(fields)) {
        getRequestBuilder.setFetchSource(fields.split(","), null);
    }

    GetResponse getResponse = getRequestBuilder.execute().actionGet();

    return getResponse.getSource();
}


/**
 * 使用分词查询,并分页
 *
 * @param index          索引名称
 * @param type           类型名称,可传入多个type逗号分隔
 * @param startPage      当前页
 * @param pageSize       每页显示条数
 * @param query          查询条件
 * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
 * @param sortField      排序字段
 * @param highlightField 高亮字段
 * @return
 */
public static EsPage searchDataPage(String index, String type, int startPage, int pageSize, QueryBuilder query, String fields, String sortField, String highlightField) {
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
    if (StringUtils.isNotEmpty(type)) {
        searchRequestBuilder.setTypes(type.split(","));
    }
    searchRequestBuilder.setSearchType(SearchType.QUERY_THEN_FETCH);

    // 需要显示的字段，逗号分隔（缺省为全部字段）
    if (StringUtils.isNotEmpty(fields)) {
        searchRequestBuilder.setFetchSource(fields.split(","), null);
    }

    //排序字段
    if (StringUtils.isNotEmpty(sortField)) {
        searchRequestBuilder.addSort(sortField, SortOrder.DESC);
    }

    // 高亮（xxx=111,aaa=222）
    if (StringUtils.isNotEmpty(highlightField)) {
        HighlightBuilder highlightBuilder = new HighlightBuilder();

        //highlightBuilder.preTags("<span style='color:red' >");//设置前缀
        //highlightBuilder.postTags("</span>");//设置后缀

        // 设置高亮字段
        highlightBuilder.field(highlightField);
        searchRequestBuilder.highlighter(highlightBuilder);
    }

    //searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());
    searchRequestBuilder.setQuery(query);

    // 分页应用
    searchRequestBuilder.setFrom(startPage).setSize(pageSize);

    // 设置是否按查询匹配度排序
    searchRequestBuilder.setExplain(true);

    //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
    log.info("\n{}", searchRequestBuilder);

    // 执行搜索,返回搜索响应信息
    SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();

    long totalHits = searchResponse.getHits().totalHits;
    long length = searchResponse.getHits().getHits().length;

    log.debug("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);

    if (searchResponse.status().getStatus() == 200) {
        // 解析对象
        List<Map<String, Object>> sourceList = setSearchResponse(searchResponse, highlightField);

        return new EsPage(startPage, pageSize, (int) totalHits, sourceList);
    }

    return null;

}


/**
 * 使用分词查询
 *
 * @param index          索引名称
 * @param type           类型名称,可传入多个type逗号分隔
 * @param query          查询条件
 * @param size           文档大小限制
 * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
 * @param sortField      排序字段
 * @param highlightField 高亮字段
 * @return
 */
public static List<Map<String, Object>> searchListData(
        String index, String type, QueryBuilder query, Integer size,
        String fields, String sortField, String highlightField) {

    SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
    if (StringUtils.isNotEmpty(type)) {
        searchRequestBuilder.setTypes(type.split(","));
    }

    if (StringUtils.isNotEmpty(highlightField)) {
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        // 设置高亮字段
        highlightBuilder.field(highlightField);
        searchRequestBuilder.highlighter(highlightBuilder);
    }

    searchRequestBuilder.setQuery(query);

    if (StringUtils.isNotEmpty(fields)) {
        searchRequestBuilder.setFetchSource(fields.split(","), null);
    }
    searchRequestBuilder.setFetchSource(true);

    if (StringUtils.isNotEmpty(sortField)) {
        searchRequestBuilder.addSort(sortField, SortOrder.DESC);
    }

    if (size != null && size > 0) {
        searchRequestBuilder.setSize(size);
    }

    //打印的内容 可以在 Elasticsearch head 和 Kibana  上执行查询
    log.info("\n{}", searchRequestBuilder);

    SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();

    long totalHits = searchResponse.getHits().totalHits;
    long length = searchResponse.getHits().getHits().length;

    log.info("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);

    if (searchResponse.status().getStatus() == 200) {
        // 解析对象
        return setSearchResponse(searchResponse, highlightField);
    }
    return null;

}


/**
 * 高亮结果集 特殊处理
 *
 * @param searchResponse
 * @param highlightField
 */
private static List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
    List<Map<String, Object>> sourceList = new ArrayList<Map<String, Object>>();
    StringBuffer stringBuffer = new StringBuffer();

    for (SearchHit searchHit : searchResponse.getHits().getHits()) {
        searchHit.getSourceAsMap().put("id", searchHit.getId());

        if (StringUtils.isNotEmpty(highlightField)) {

            System.out.println("遍历 高亮结果集，覆盖 正常结果集" + searchHit.getSourceAsMap());
            Text[] text = searchHit.getHighlightFields().get(highlightField).getFragments();

            if (text != null) {
                for (Text str : text) {
                    stringBuffer.append(str.string());
                }
                //遍历 高亮结果集，覆盖 正常结果集
                searchHit.getSourceAsMap().put(highlightField, stringBuffer.toString());
            }
        }
        sourceList.add(searchHit.getSourceAsMap());
    }
    return sourceList;
  }
}

ES测试接口

@RestController
@RequestMapping("/es")
public class EsController {

/**
 * 索引名称
 */
private String indexName = "author_index";

/**
 * 类型
 */
private String esType = "author";


/**
 * 创建索引
 *
 * @return
 */
@RequestMapping("/createIndex")
public String createIndex() {
    if (!ElasticsearchUtil.isIndexExist(indexName)) {
        ElasticsearchUtil.createIndex(indexName);
    } else {
        return "索引已经存在";
    }
    return "索引创建成功";
}

/**
 * 插入记录
 *
 * @return
 */
@RequestMapping("/insertJsonObject")
public String insertJson() {
    JSONObject jsonObject = new JSONObject();
    jsonObject.put("id", UUID.randomUUID().toString());
    jsonObject.put("age", new Random(10).nextInt());
    jsonObject.put("userName", "Coder" + new Random(100).nextInt());
    jsonObject.put("nickName", "Z了个S" + new Random(8).nextInt());
    jsonObject.put("slogan", "welcome follow CoderZS in 简书" + new Random(1000).nextInt());
    jsonObject.put("createTi", new Date());
    String id = ElasticsearchUtil.addData(jsonObject, indexName, esType, jsonObject.getString("id"));
    return id;
}

/**
 * 插入记录
 *
 * @return
 */
@RequestMapping("/insertModel")
public String insertModel() {
    Author author = new Author();
    author.setId(UUID.randomUUID().toString());
    author.setUserName("Coder" + new Random(100).nextInt());
    author.setNickName("ZS" + new Random(1000).nextInt());
    author.setAge(new Random(18).nextInt());
    author.setSlogan("welcome follow CoderZS in 简书" + new Random(1000).nextInt());
    author.setCreateTi(new Date());
    JSONObject jsonObject = (JSONObject) JSONObject.toJSON(author);
    String id = ElasticsearchUtil.addData(jsonObject, indexName, esType, jsonObject.getString("id"));
    return id;
}

/**
 * 删除记录
 *
 * @return
 */
@RequestMapping("/delete")
public String delete(String id) {
    if (StringUtils.isNotBlank(id)) {
        ElasticsearchUtil.deleteDataById(indexName, esType, id);
        return "删除id=" + id;
    } else {
        return "id为空";
    }
}

/**
 * 更新数据
 *
 * @return
 */
@RequestMapping("/update")
public String update(String id) {
    if (StringUtils.isNotBlank(id)) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("id", id);
        jsonObject.put("age", 31);
        jsonObject.put("userNsme", "Coder新名字");
        jsonObject.put("createTi", new Date());
        ElasticsearchUtil.updateDataById(jsonObject, indexName, esType, id);
        return "id=" + id;
    } else {
        return "id为空";
    }
}

/**
 * 获取数据
 *
 * @param id
 * @return
 */
@RequestMapping("/getData")
public String getData(String id) {
    if (StringUtils.isNotBlank(id)) {
        Map<String, Object> map = ElasticsearchUtil.searchDataById(indexName, esType, id, null);
        return JSONObject.toJSONString(map);
    } else {
        return "id为空";
    }
}

/**
 * 查询数据
 * 模糊查询
 *
 * @return
 */
@RequestMapping("/queryMatchData")
public String queryMatchData() {
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    boolean matchPhrase = false;
    if (matchPhrase == Boolean.TRUE) {
        //不进行分词搜索
        boolQuery.must(QueryBuilders.matchPhraseQuery("userName", "CoderZS"));
    } else {
        boolQuery.must(QueryBuilders.matchQuery("nickNname", "ZS"));
    }
    List<Map<String, Object>> list = ElasticsearchUtil.
            searchListData(indexName, esType, boolQuery, 10, "first_name", null, "last_name");
    return JSONObject.toJSONString(list);
}

/**
 * 通配符查询数据
 * 通配符查询 ?用来匹配1个任意字符，*用来匹配零个或者多个字符
 *
 * @return
 */
@RequestMapping("/queryWildcardData")
public String queryWildcardData() {
    QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("userName.keyword", "coder");
    List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, queryBuilder, 10, null, null, null);
    return JSONObject.toJSONString(list);
}

/**
 * 正则查询
 *
 * @return
 */
@RequestMapping("/queryRegexpData")
public String queryRegexpData() {
    QueryBuilder queryBuilder = QueryBuilders.regexpQuery("userName.keyword", "m--[0-9]{1,11}");
    List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, queryBuilder, 10, null, null, null);
    return JSONObject.toJSONString(list);
}

/**
 * 查询数字范围数据
 *
 * @return
 */
@RequestMapping("/queryIntRangeData")
public String queryIntRangeData() {
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    boolQuery.must(QueryBuilders.rangeQuery("age").from(24)
            .to(25));
    List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, boolQuery, 10, null, null, null);
    return JSONObject.toJSONString(list);
}

/**
 * 查询日期范围数据
 *
 * @return
 */
@RequestMapping("/queryDateRangeData")
public String queryDateRangeData() {
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    boolQuery.must(QueryBuilders.rangeQuery("age").from("20")
            .to("50"));
    List<Map<String, Object>> list = ElasticsearchUtil.searchListData(indexName, esType, boolQuery, 10, null, null, null);
    return JSONObject.toJSONString(list);
}

/**
 * 查询分页
 *
 * @param startPage 第几条记录开始
 *                  从0开始
 *                  第1页 ：http://127.0.0.1:8080/es/queryPage?startPage=0&pageSize=2
 *                  第2页 ：http://127.0.0.1:8080/es/queryPage?startPage=2&pageSize=2
 * @param pageSize  每页大小
 * @return
 */
@RequestMapping("/queryPage")
public String queryPage(String startPage, String pageSize) {
    if (StringUtils.isNotBlank(startPage) && StringUtils.isNotBlank(pageSize)) {
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.must(QueryBuilders.rangeQuery("age").from("20")
                .to("100"));
        EsPage list = ElasticsearchUtil.searchDataPage(indexName, esType, Integer.parseInt(startPage), Integer.parseInt(pageSize), boolQuery, null, null, null);
        return JSONObject.toJSONString(list);
    } else {
        return "startPage或者pageSize缺失";
    }
  }
}

启动类

@ComponentScan(value = {"com.aulton.*"})
@SpringBootApplication
public class Application {
public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

我们可以接口请求验证数据的正确性也可以通过一些工具验证我们接口的正确性