SpringData ElasticSearch入门案例

最新推荐文章于 2024-04-29 12:25:48 发布

YXWik6

最新推荐文章于 2024-04-29 12:25:48 发布

阅读量2k

点赞数 1

分类专栏： SpringData Elasticsearch 文章标签： SpringData Elasticsearch

本文链接：https://blog.csdn.net/YXWik/article/details/89643855

版权

SpringData 同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

Elasticsearch

2 篇文章 0 订阅

订阅专栏

导入需要的依赖坐标

 <dependencies>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>5.6.8</version>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>transport</artifactId>
        <version>5.6.8</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-to-slf4j</artifactId>
        <version>2.9.1</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.24</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.21</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.8.1</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.8.1</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.8.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-elasticsearch</artifactId>
        <version>3.0.5.RELEASE</version>
        <exclusions>
            <exclusion>
                <groupId>org.elasticsearch.plugin</groupId>
                <artifactId>transport-netty4-client</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.4.RELEASE</version>
    </dependency> </dependencies>

创建applicationContext.xml配置文件，引入elasticsearch命名空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
   xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/data/elasticsearch
	http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
<!-- 扫描Dao包，自动创建实例 -->
<elasticsearch:repositories base-package="com.itheima.repository"/>

<!-- 扫描Service包，创建Service的实体 -->
<context:component-scan base-package="com.itheima.service"/>

<!-- 配置elasticSearch的连接 -->
<!-- 配置elasticSearch的连接 -->
<elasticsearch:transport-client id="client" cluster-nodes="127.0.0.1:9300" cluster-name="elasticsearch"/>


<!-- ElasticSearch模版对象 -->
<bean id="elasticsearchTemplate" class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
	<constructor-arg name="client" ref="client"></constructor-arg>
</bean>
</beans>

编写实体Article
基于spring data elasticsearch注解配置索引、映射和实体的关系
配置映射
@Document文档对象（索引信息、文档类型）
@Id文档主键，是唯一标识
@Field每个文档的字段配置（类型、是否分词、是否存储、分词器）

package com.itheima.domain;
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 文档对象 （索引信息、文档类型 ）
@Document(indexName = "blog6",type = "article")
public class Article {

//@Id 文档主键 唯一标识
@Id
private Integer id;

 //@Field 每个文档的字段配置（类型、是否分词、是否存储、分词器 ）
@Field(type = FieldType.text,index = true,analyzer = "ik_smart",searchAnalyzer = "ik_smart",store = true)
private String title;

@Field(type = FieldType.text,index = true,analyzer = "ik_smart",searchAnalyzer = "ik_smart",store = true)
private String content;


public Integer getId() {
    return id;
}
public void setId(Integer id) {
    this.id = id;
}
public String getTitle() {
    return title;
}
public void setTitle(String title) {
    this.title = title;
}
public String getContent() {
    return content;
}
public void setContent(String content) {
    this.content = content;
}
@Override
public String toString() {
    return "Article [id=" + id + ", title=" + title + ", content=" + content + "]";
}

}

其中，注解解释如下：
@Document(indexName=“blog6”,type=“article”)：
indexName：索引的名称（必填项）
type：索引的类型
@Id：主键的唯一标识
@Field(index=true,analyzer=“ik_smart”,store=true,searchAnalyzer=“ik_smart”,type = FieldType.text)
index：是否设置分词
analyzer：存储时使用的分词器
searchAnalyze：搜索时使用的分词器
store：是否存储
type: 数据类型

=======================================

编写Dao

package com.itheima.repository;
import com.itheima.domain.Article;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;


@Repository
public interface ArticleRepository extends ElasticsearchRepository<Article, Integer> {

}

编写Service接口 CRUD操作

 package com.itheima.service;
 
import com.itheima.domain.Article;

import java.util.List;

public interface ArticleService {
//	添加索引
 void save(Article article);
//删除索引
void delete(Article article);
//修改索引
void update(Article article);
//查询所有
Iterable<Article> findAll();
//分页查询
Iterable<Article> findByPage(int page, int size);
//添加多个
void saveAll(List<Article> articles);

}

编写service实现类

package com.itheima.service.impl;
import com.itheima.domain.Article;
import com.itheima.repository.ArticleRepository;
import com.itheima.service.ArticleService;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ArticleServiceImpl implements ArticleService {

@Autowired
private ArticleRepository articleRepository;
//增
public void save(Article article) {
    articleRepository.save(article);
}
//删
public void delete(Article article) {
    articleRepository.delete(article);
}
//改
public void update(Article article) {
    articleRepository.save(article);
}
//添加所有
public void saveAll(List<Article> articles) {
    articleRepository.saveAll(articles);
}
//查询所有
public Iterable<Article> findAll() {
    return  articleRepository.findAll();
}
//分页查询
public Iterable<Article> findByPage(int page, int size) {
        PageRequest pageRequest = PageRequest.of(page, size);
        return articleRepository.findAll(pageRequest);
    }
}

创建测试类SpringDataESTest

package com.itheima;
import com.itheima.domain.Article;
import com.itheima.service.ArticleService;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.ArrayList;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
	public class SpringDataESTest {
    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;
    @Autowired
 	   private ArticleService articleService;
    /**
     * 创建索引
     * 配置映射
     */
    @Test
    public  void createIndex(){
        elasticsearchTemplate.createIndex(Article.class);
        elasticsearchTemplate.putMapping(Article.class);

}

/**
 * 删除索引
 * 配置映射
 */
@Test
public  void deleteIndex(){

    elasticsearchTemplate.deleteIndex(Article.class);

    

}
/**
 * 创建文档
 */
@Test
public void createDocument(){
    Article article = new Article();
    article.setId(1);
    article.setTitle("nihao");
    article.setContent("wohao");

    articleService.save(article);

}

/**
 * 删除文档
 */
public void deleteDoc(){
    Article article = new Article();
    article.setId(1);
    articleService.delete(article);
}
/**
 * 更新文档
 */
@Test
public void UpdateDocument(){
    Article article = new Article();
    article.setId(1);
    article.setTitle("hi");
    article.setContent("hello");

    articleService.update(article);
}

/**
 * 添加所有
 */
@Test
public  void saveAll(){
    List<Article> articles =  new ArrayList<Article>();
    for (int i = 0; i < 100; i++) {
        Article article = new Article();
        article.setId(i);
        article.setTitle(i+"标题");
        article.setContent(i+"内容");
        articles.add(article);
    }
    articleService.saveAll(articles);


}
/**
 * 查询所有
 */
@Test
public  void findAll(){

    Iterable<Article> articles =  articleService.findAll();
    for (Article article : articles) {
        System.out.println(article);
    }


}
/**
 * 分页查询
 */
@Test
public  void findByPage(){

    int page = 1;
    int size = 5;
    Iterable<Article> articles =  articleService.findByPage(page,size);
    for (Article article : articles) {
        System.out.println(article);
    }
}

/**
 * 原生查询
 */
@Test
public  void termNativequery(){

    NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
    nativeSearchQueryBuilder.withQuery(QueryBuilders.termQuery("title","搜索"));
    nativeSearchQueryBuilder.withPageable(PageRequest.of(1,5));
    NativeSearchQuery build = nativeSearchQueryBuilder.build();
    List<Article> articles = elasticsearchTemplate.queryForList(build, Article.class);
    for (Article article : articles) {
        System.out.println(article);
    }

}
/**
 * 原生查询
 */
@Test
public  void queryStringQuery(){

    NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
    nativeSearchQueryBuilder.withQuery(QueryBuilders.queryStringQuery("搜索"));
    NativeSearchQuery build = nativeSearchQueryBuilder.build();

    List<Article> articles = elasticsearchTemplate.queryForList(build, Article.class);
    for (Article article : articles) {
        System.out.println(article);
    }
	}
}

常用查询命名规则
在这里插入图片描述
查询方法测试
dao层实现
package com.itheima.dao;

import com.itheima.domain.Article;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import java.util.List;

public interface ArticleRepository extends ElasticsearchRepository<Article, Integer> {
    //根据标题查询
    List<Article> findByTitle(String condition);
    //根据标题查询(含分页)
    Page<Article> findByTitle(String condition, Pageable pageable);
}

service层实现

public interface ArticleService {
    //根据标题查询
    List<Article> findByTitle(String condition);
    //根据标题查询(含分页)
    Page<Article> findByTitle(String condition, Pageable pageable);
}

service实现类

package com.itheima.service.impl;
import com.itheima.dao.ArticleRepository;
import com.itheima.domain.Article;
import com.itheima.service.ArticleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ArticleServiceImpl implements ArticleService {

    @Autowired
    private ArticleRepository articleRepository;

    public List<Article> findByTitle(String condition) {
        return articleRepository.findByTitle(condition);
    }
    public Page<Article> findByTitle(String condition, Pageable pageable) {
        return articleRepository.findByTitle(condition,pageable);
    }

}

测试代码

package com.itheima.test;
import com.itheima.domain.Article;
import com.itheima.service.ArticleService;
import org.elasticsearch.client.transport.TransportClient;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class SpringDataESTest {

@Autowired
private ArticleService articleService;

@Autowired
private TransportClient client;

@Autowired
private ElasticsearchTemplate elasticsearchTemplate;

/**条件查询*/
@Test
public void findByTitle(){
    String condition = "版本";
    List<Article> articleList = articleService.findByTitle(condition);
    for(Article article:articleList){
        System.out.println(article);
    }
}

/**条件分页查询*/
@Test
public void findByTitlePage(){
    String condition = "版本";
    Pageable pageable = PageRequest.of(2,10);
    Page<Article> page = articleService.findByTitle(condition,pageable);
    for(Article article:page.getContent()){
        System.out.println(article);
    }
}

}

带高亮显示查询

@Test
    public void findByNativeQueryWithHighlighting() {
        //创建一个SearchQuery对象
        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                //设置查询条件，此处可以使用QueryBuilders创建多种查询
                .withQuery(QueryBuilders.queryStringQuery("备份节点上没有数据").defaultField("title"))
                //还可以设置分页信息
                .withPageable(PageRequest.of(1, 5))
                //设置高亮条件
                .withHighlightFields(new HighlightBuilder.Field("title")
                        .preTags("<span>")
                        .postTags("</span>")
                )
                //创建SearchQuery对象
                .build();


    //使用模板对象执行查询
    elasticsearchTemplate.queryForPage(searchQuery, Article.class, new SearchResultMapper() {
        @Override
        public <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {
            List<Article> articles = new ArrayList<>();
            //取查询结果
            SearchHits hits = searchResponse.getHits();
            Iterator<SearchHit> iterator = hits.iterator();
            //遍历结果集，包括取高亮结果
            while (iterator.hasNext()) {
                SearchHit searchHit = iterator.next();
                Article article = new Article();
                //取id
                article.setId(Integer.parseInt(searchHit.getSource().get("id").toString()));
                //取title，高亮结果
                String title = "";
                HighlightField highlightField = searchHit.getHighlightFields().get("title");
                //如果有高亮结果就取高亮
                if (highlightField != null) {
                    title = highlightField.getFragments()[0].toString();
                //如果没有高亮就取原文档中的field
                } else {
                    title = searchHit.getSource().get("title").toString();
                }
                article.setTitle(title);
                //取content
                article.setContent(searchHit.getSource().get("content").toString());
                //将结果添加到列表
                articles.add(article);
            }
            //创建返回结果对象
            AggregatedPage result = new AggregatedPageImpl(articles, pageable, hits.getTotalHits());

            return result;
        }
    }).forEach(a-> System.out.println(a));

}