SpringBoot整合ElasticSearch

最新推荐文章于 2022-09-18 18:06:04 发布
最新推荐文章于 2022-09-18 18:06:04 发布
阅读量750 收藏
点赞数 4
文章标签： elasticsearch spring boot jpa lucene 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52210557/article/details/122401534
版权

因为es用的是6.8版本，对应springboot2.2.x版本，创建项目后修改pom文件

 <version>2.2.4.RELEASE</version>

引入es依赖

  <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>6.8.18</version>
    </dependency>

在配置文件中添加

# es服务地址
elasticsearch.host=127.0.0.1
# es服务端口
elasticsearch.port=9200
# 配置日志级别,开启debug日志
logging.level.com.atguigu.es=debug

编写es配置类

package com.lzq.config;
​
import lombok.Data;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
​
@Configuration   //配置类，启动就会加载
@ConfigurationProperties(prefix = "elasticsearch") //读取配置文件中带前缀的值
@Component
@Data //安装Lombok插件
public class ElasticSearchConfig {
    private String host ;
    private Integer port ;
​
    @Bean
    public RestHighLevelClient client(){
        RestClientBuilder builder = RestClient.builder(new HttpHost(host, port));
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(builder);
        return restHighLevelClient;
    }
​
}

测试

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private RestHighLevelClient client;
    /**
     * 目标：创建索引库
     * 1.创建请求对象 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应对象中的返回结果
     * 4.关闭客户端，释放连接资源
     */
    @Test
    public void create() throws IOException {
        //1.创建请求对象，创建索引的请求
        CreateIndexRequest request = new CreateIndexRequest("shopping1");
        //2.客户端发送请求，获取响应对象
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        //3.打印响应对象中的返回结果
        //返回index信息
        System.out.println("index:" + response.index());
        //acknowledged代表创建成功
        System.out.println("acknowledged:" + response.isAcknowledged());
        //4.关闭客户端，释放连接资源
        client.close();
    }
​
​
    //查看索引库
    @Test
    public void getIndex() throws IOException {
        //1.创建请求对象：查询索引库
        GetIndexRequest request = new GetIndexRequest("shopping1");
        //2.客户端执行请求发送，返回响应对象
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        //3.打印结果信息
        System.out.println("aliases:"+response.getAliases());
        System.out.println("mappings:"+response.getMappings());
        System.out.println("settings:"+response.getSettings());
        //4.关闭客户端，释放连接资源
        client.close();
    }
​
    //删除索引库
    @Test
    public void deleteIndex() throws IOException {
        //1.创建请求对象
        DeleteIndexRequest request = new DeleteIndexRequest("shopping1");
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
        //3.打印结果信息
        System.out.println("ack:" + response.isAcknowledged());
        //4.关闭客户端，释放连接资源
        client.close();
    }
    
}

配置映射

1.配置映射，一共2种方式：

第一种：使用XContentBuilder,构建请求体

第二种：使用JSON字符串

import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.GetMappingsRequest;
import org.elasticsearch.client.indices.GetMappingsResponse;
import org.elasticsearch.client.indices.PutMappingRequest;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
​
import java.io.IOException;
​
@SpringBootTest
class EsDemo2 {
​
    @Autowired
    private RestHighLevelClient client;
​
    /**
     * 目标：配置映射。第一种方式，使用XContentBuilder,构建请求体
     * 1.创建请求对象：配置映射
     * 设置索引库name
     * 设置配置映射请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void putMapping01() throws IOException {
        //1.创建请求对象：配置映射
        PutMappingRequest request = new PutMappingRequest("shopping1");
        //构建请求体
        XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
        jsonBuilder.startObject()
                .startObject("properties")
                .startObject("title")
                .field("type", "text").field("analyzer", "ik_max_word")
                .endObject()
                .startObject("subtitle")
                .field("type", "text").field("analyzer", "ik_max_word")
                .endObject()
                .startObject("images")
                .field("type", "keyword").field("index", false)
                .endObject()
                .startObject("price")
                .field("type", "float")
                .endObject()
                .endObject()
                .endObject();
        //设置请求体，source("请求体json构建器对象");
        request.source(jsonBuilder);
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("acknowledged：：" + response.isAcknowledged());
    }
​
    /**
     * 目标：配置映射。第二种方式，使用JSON字符串
     * 1.创建请求对象：配置映射
     * 设置索引库name
     * 设置配置映射请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void putMapping02() throws IOException {
        //1.创建请求对象：配置映射
        PutMappingRequest request = new PutMappingRequest("shopping1");
        //设置请求体，source("请求体json字符串"，"请求体的数据类型");
        request.source("{\"properties\":{\"title\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"subtitle\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"price\":{\"type\":\"float\"},\"images\":{\"type\":\"keyword\",\"index\":false}}}", XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("acknowledged::" + response.isAcknowledged());
    }
​
    /**
     * 查看映射
     * 1.创建请求对象：查看映射
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void getMapping() throws IOException {
        //1.创建请求对象：查看映射
        GetMappingsRequest request = new GetMappingsRequest();
        //设置索引库name
        request.indices("shopping1");
        //2.客户端发送请求，获取响应对象
        GetMappingsResponse response = client.indices().getMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("mappings::" + response.mappings());
        System.out.println("Source::" + response.mappings().get("shopping1").getSourceAsMap());
    }
​
}

文档操作

   
 //新增文档
    @Test
    public void saveDoc() throws IOException {
        //1.创建请求对象(创建索引库CreateIndexRequest)，索引库名称、类型名称、主键id
        IndexRequest request = new IndexRequest().index("shopping").type("_doc").id("2");
        //方式1：写一个Product对象将对象转为json字符串
//        Product product = Product.builder().id(1L).title("小米手机").price(1999.0).build();
//        ObjectMapper objectMapper = new ObjectMapper();
//        String productJson = objectMapper.writeValueAsString(product);
//        request.source(productJson,XContentType.JSON);
​
        //方式2：直接在source中写入key-value参数
        request.source(XContentType.JSON, "id", "2","title", "小米手机",  "price", "3999");
​
        //2.客户端发送请求，获取响应对象
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        3.打印结果信息
        System.out.println("_index:" + response.getIndex());
        System.out.println("_type:" + response.getType());
        System.out.println("_id:" + response.getId());
        System.out.println("_result:" + response.getResult());
    }

修改文档*


    public void update() throws IOException {
        //1.创建请求对象(创建索引库CreateIndexRequest)，索引库名称、类型名称、主键id
        UpdateRequest request = new UpdateRequest().index("shopping").type("_doc").id("2");
        //设置请求体
        request.doc(XContentType.JSON, "id", "2", "title", "小米手机", "price", "2999");
​
        //2.客户端发送请求，获取响应对象
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        3.打印结果信息
        System.out.println("_index:" + response.getIndex());
        System.out.println("_type:" + response.getType());
        System.out.println("_id:" + response.getId());
        System.out.println("_result:" + response.getResult());
    }
​
​
    //查询文档
    @Test
    public void getDoc() throws IOException {
        //1.创建请求对象
        GetRequest request = new GetRequest().index("shopping").type("_doc").id("2");
        //2.客户端发送请求，获取响应对象
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        3.打印结果信息
        System.out.println("_index:" + response.getIndex());
        System.out.println("_type:" + response.getType());
        System.out.println("_id:" + response.getId());
        System.out.println("source:" + response.getSourceAsString());
    }
​
​
    //删除文档
    @Test
    public void deleteDoc() throws IOException {
        //创建请求对象
        DeleteRequest request = new DeleteRequest().index("shopping").type("_doc").id("2");
        //客户端发送请求，获取响应对象
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        //打印信息
        System.out.println(response.toString());
    }
​
​
    //批量新增操作
    @Test
    public void bulkSave() throws IOException {
        //创建请求对象
        BulkRequest request = new BulkRequest();
        request.add(new IndexRequest().index("shopping").type("_doc").id("1").source(XContentType.JSON, "title", "小米手机"));
        request.add(new IndexRequest().index("shopping").type("_doc").id("2").source(XContentType.JSON, "title", "苹果手机"));
        request.add(new IndexRequest().index("shopping").type("_doc").id("3").source(XContentType.JSON, "title", "华为手机"));
        //客户端发送请求，获取响应对象
        BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
        //打印结果信息
        System.out.println("took:" + responses.getTook());
        System.out.println("items:" + responses.getItems());
    }
​
​
    //批量删除操作
    @Test
    public void bulkDelete() throws IOException {
        //创建请求对象
        BulkRequest request = new BulkRequest();
        request.add(new DeleteRequest().index("shopping").type("_doc").id("1"));
        request.add(new DeleteRequest().index("shopping").type("_doc").id("2"));
        request.add(new DeleteRequest().index("shopping").type("_doc").id("3"));
        //客户端发送请求，获取响应对象
        BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
        //打印结果信息
        System.out.println("took:" + responses.getTook());
        System.out.println("items:" + responses.getItems());
    }
​
}

请求体查询

@SpringBootTest
class EsDemo3 {
​
    @Autowired
    private RestHighLevelClient client;
​
    /**
     * 初始化查询数据
     */
    @Test
    public void initData() throws IOException {
        //批量新增操作
        BulkRequest request = new BulkRequest();
        request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "小米手机", "images", "http://www.gulixueyuan.com/xm.jpg", "price", 1999.0));
        request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "小米电视", "images", "http://www.gulixueyuan.com/xmds.jpg", "price", 2999.0));
        request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "华为手机", "images", "http://www.gulixueyuan.com/hw.jpg", "price", 4999.0, "subtitle", "小米"));
        request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "apple手机", "images", "http://www.gulixueyuan.com/appletl.jpg", "price", 5999.00));
        request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "apple", "images", "http://www.gulixueyuan.com/apple.jpg", "price", 3999.00));
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        System.out.println("took::" + response.getTook());
        System.out.println("Items::" + response.getItems());
    }
​
    //请求体查询-基本查询
    //1.创建请求对象
    //2.客户端发送请求，获取响应对象
    //3.打印结果信息
    @Test
    public void basicQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest().indices("shopping01").types("_doc");
        //构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //查询所有
        //sourceBuilder.query(QueryBuilders.matchAllQuery());//
        //match查询，带分词器的查询
        //sourceBuilder.query(QueryBuilders.matchQuery("title","小米手机").operator(Operator.AND));
        //term查询：不带分词器，查询条件作为关键词
        sourceBuilder.query(QueryBuilders.termQuery("price", "1999"));
        //TODO ...multi_match：多个字段的match查询
        //TODO ...terms查询：多个关键词去匹配
        request.source(sourceBuilder);
        //2.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //3.打印结果信息
        printResult(response);
    }
​
    /**
     * 打印结果信息
     */
    private void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());
        System.out.println("hits========>>");
        for (SearchHit hit : hits) {
            //输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("<<========");
    }
​
​
    /**
     * 目标：查询的字段过滤，分页，排序
     *
     * @throws IOException
     */
    @Test
    public void fetchSourceAndSortAndByPage() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest().indices("shopping01").types("_doc");
        //构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //查询所有
        sourceBuilder.query(QueryBuilders.matchAllQuery());
​
        //分页信息
        //当前页其实索引(第一条数据的顺序号)，from
        sourceBuilder.from(2);
        //每页显示多少条size
        sourceBuilder.size(2);
​
        //排序信息,参数一：排序的字段，参数二：顺序ASC升序，降序DESC
        sourceBuilder.sort("price", SortOrder.ASC);
​
        //查询字段过滤
        String[] excludes = {};
        String[] includes = {"title", "subtitle", "price"};
        sourceBuilder.fetchSource(includes, excludes);
​
        request.source(sourceBuilder);
        //2.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //3.打印结果信息
        printResult(response);
    }
​
​
    /**
     * 高级查询
     */
    @Test
    public void boolAndRangeAndFuzzyQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest().indices("shopping01").types("_doc");
        //构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //高级查询的三种方式：
        //-----------------------------------------------------------------------------
//        //bool查询：查询title中必须包含小米，一定不含有电视，应该含有手机的所有商品
//        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
//        //must
//        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "小米"));
//        //must not
//        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("title", "电视"));
//        //should
//        boolQueryBuilder.should(QueryBuilders.matchQuery("title", "手机"));
//        sourceBuilder.query(boolQueryBuilder);
        //-----------------------------------------------------------------------------
        //范围查询：查询价格大于3千，小于5千的所有商品
//        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
//        //#### gt 大于(greater than)
//        rangeQuery.gt("3000");
//        //#### lt 小于(less than)
//        rangeQuery.lt("5000");
//        //#### gte 大于等于(greater than equals)
//        //#### lte 小于等于(less than equals)
//        sourceBuilder.query(rangeQuery);
        //-----------------------------------------------------------------------------
        //模糊查询：查询包含apple关键词的所有商品，完成模糊查询cpple
        sourceBuilder.query(QueryBuilders.fuzzyQuery("title","cpple").fuzziness(Fuzziness.ONE));
        //-----------------------------------------------------------------------------
​
        request.source(sourceBuilder);
        //2.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //3.打印结果信息
        printResult(response);
    }
}

高亮查询

/**
 * 高亮查询，对查询关键词进行高亮
 * 1.创建请求对象：高亮查询
 *    设置索引库name
 *    设置类型type
 * 2.创建查询请求体构建器
 *    设置请求体
 * 3.客户端发送请求，获取响应对象
 * 4.打印响应结果
 */
@Test
public void highLighterQuery() throws IOException {
    //1.创建请求对象
    SearchRequest request = new SearchRequest().types("_doc").indices("shopping01");
    //2.创建查询请求体构建器
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    //构建查询方式：高亮查询
    TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("title","apple");
    //设置查询方式
    sourceBuilder.query(termsQueryBuilder);
    //构建高亮字段
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.preTags("<font color='red'>");//设置标签前缀
    highlightBuilder.postTags("</font>");//设置标签后缀
    highlightBuilder.field("title");//设置高亮字段
    //设置高亮构建对象
    sourceBuilder.highlighter(highlightBuilder);
    //设置请求体
    request.source(sourceBuilder);
    //3.客户端发送请求，获取响应对象
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
​
    //4.打印响应结果
    SearchHits hits = response.getHits();
    System.out.println("took::"+response.getTook());
    System.out.println("time_out::"+response.isTimedOut());
    System.out.println("total::"+hits.getTotalHits());
    System.out.println("max_score::"+hits.getMaxScore());
    System.out.println("hits::::>>");
    for (SearchHit hit : hits) {
        String sourceAsString = hit.getSourceAsString();
        System.out.println(sourceAsString);
        //打印高亮结果
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        System.out.println(highlightFields);
    }
    System.out.println("<<::::");
}

SpringData整合ES

创建项目加入依赖

 <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
​
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
​

编写配置文件

# es服务地址
elasticsearch.host=127.0.0.1
# es服务端口
elasticsearch.port=9200
# 配置日志级别,开启debug日志
logging.level.com.atguigu.es=debug
 

创建实体类
 

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
 
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Product {
    private Long id;//商品唯一标识
    private String title;//商品名称
    private String category;//分类名称
    private Double price;//商品价格
    private String images;//图片地址
}
 

创建配置类
 

import lombok.Data;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.RestClients;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;
import org.springframework.data.elasticsearch.core.ElasticsearchEntityMapper;
import org.springframework.data.elasticsearch.core.EntityMapper;
 
@ConfigurationProperties(prefix = "elasticsearch")
@Configuration
@Data
public class ElasticsearchConfig extends AbstractElasticsearchConfiguration {
    private String host ;
    private Integer port ;
 
    //重写父类方法
    @Override
    public RestHighLevelClient elasticsearchClient() {
        RestClientBuilder builder = RestClient.builder(new HttpHost(host, port));
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(builder);
        return restHighLevelClient;
}
}
 

dao层
 

import com.lzq.pojo.Product;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;
​
@Repository
public interface ProductDao extends ElasticsearchRepository<Product,Long> {
​
}
 

修改实体类对应
 

@Document(indexName = "shopping", type = "product", shards = 5, replicas = 1)
public class Product implements Serializable {
    //必须有id,这里的id是全局唯一的标识，等同于es中的"—id"
    @Id
    private Long id;//商品唯一标识
​
    /**
     * type : 字段数据类型
     * analyzer : 分词器类型
     * index : 是否索引(默认:true)
     * Keyword : 短语,不进行分词
     */
    @Field(type = FieldType.Text, analyzer = "ik_max_word")
    private String title;//商品名称
​
    @Field(type = FieldType.Keyword)
    private String category;//分类名称
​
    @Field(type = FieldType.Double)
    private Double price;//商品价格
​
    @Field(type = FieldType.Keyword, index = false)
    private String images;//图片地址
}
 

测试
 

//注入ElasticsearchRestTemplate
    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;
    //创建索引并增加映射配置
    @Test
    public void createIndex(){
        //创建索引
        boolean index = elasticsearchRestTemplate.createIndex(Product.class);
        System.out.println("index = " + index);
        index = elasticsearchRestTemplate.putMapping(Product.class);
        System.out.println("index = " + index);
    }
​
    //删除索引
    @Test
    public void deleteIndex(){
        boolean index = elasticsearchRestTemplate.deleteIndex(Product.class);
        System.out.println("index = " + index);
    }
 

测试：文档操作
 

注入dao层
 

   @Autowired
    private ProductDao productDao;
 /**
     * 新增
     */
    @Test
    public void save(){
        Product product = new Product();
        product.setId(1L);
        product.setTitle("小米手机");
        product.setCategory("手机");
        product.setPrice(1999.0);
        product.setImages("http://www.gulixueyuan/xm.jpg");
        productDao.save(product);
    }
 
    //修改
    @Test
    public void update(){
        Product product = new Product();
        product.setId(1L);
        product.setTitle("小米2手机");
        product.setCategory("手机");
        product.setPrice(9999.0);
        product.setImages("http://www.gulixueyuan/xm.jpg");
        productDao.save(product);
    }
//根据id查询
    @Test
    public void findById(){
        Product product = productDao.findById(1L).get();
        System.out.println(product);
}
​
    //查询所有
    @Test
    public void findAll(){
        Iterable<Product> products = productDao.findAll();
        for (Product product : products) {
            System.out.println(product);
        }
    }
 
    //删除
    @Test
    public void delete(){
        Product product = new Product();
        product.setId(1L);
        productDao.delete(product);
    }
 
    //批量新增
    @Test
    public void saveAll(){
        List<Product> productList = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            Product product = new Product();
            product.setId(Long.valueOf(i));
            product.setTitle("["+i+"]小米手机");
            product.setCategory("手机");
            product.setPrice(1999.0+i);
            product.setImages("http://www.gulixueyuan/xm.jpg");
            productList.add(product);
        }
        productDao.saveAll(productList);
}
​
    //分页查询
    @Test
    public void findByPageable(){
        //设置排序(排序方式，正序还是倒序，排序的id)
        Sort sort = Sort.by(Sort.Direction.DESC,"id");
        int currentPage=1;//当前页，第一页从0开始，1表示第二页
        int pageSize = 20;//每页显示多少条
        //设置查询分页
        PageRequest pageRequest = PageRequest.of(currentPage, pageSize,sort);
        //分页查询
        Page<Product> productPage = productDao.findAll(pageRequest);
        System.out.println(productPage);
    }
 

  
​
 

自定义DAO查询
 

关键字命名规则解释示例
andfindByField1AndField2根据Field1和Field2获得数据findByTitleAndPrice
orfindByField1OrField2根据Field1或Field2获得数据findByTitleOrPrice
isfindByField根据Field获得数据findByTitle
notfindByFieldNot根据Field获得补集数据findByTitleNot
betweenfindByFieldBetween获得指定范围的数据findByPriceBetween
lessThanEqualfindByFieldLessThan获得小于等于指定值的数据findByPriceLessThan
 

  /**
     * 根据标题及价格查询
     * 要求价格等于2050且标题的内容包含小米关键词
     */
    @Test
    public void findAllByTitleAndPrice(){
        String title = "小米";
        Double price = 2050.0;
        List<Product> products = productDao.findByTitleAndPrice(title, price);
        for (Product product : products) {
            System.out.println(product);
        }
    }
    /**
     * 根据价格范围查询，包含最低和最高的价格。
     * 要求商品价格再2000，到2005之间
     */
    @Test
    public void findPriceBetween(){
        double lowPrice = 2000.0;//最低价
        double highPrice = 2005.0;//最高价
        List<Product> products = productDao.findByPriceBetween(lowPrice, highPrice);
        for (Product product : products) {
            System.out.println(product);
        }
    }
​
 

只需要在dao层实现就行，不用自己写逻辑

                

        

        

    




    

      

        

            

              
                
                  远走与梦游
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    4
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
Spring Data ElasticSearch 使用

				
			

			

				

					fxbar的博客
				

				

					07-03
					
					1179
					
				

			

		

		

			
				
Spring Data ElasticSearch 使用

Spring Data ElasticSearch入门
1）导入Spring Data ElasticSearch坐标

<?xml version="1.0" encoding="UTF-8"?>

4.0.0
<groupId>com.itheima</groupId>
<artifactId...

			
		

	



                

              
                



	

		

			

				
					
springboot整合es-springboot-elasticsearch.zip

					
最新发布

				
			

			

				

					11-07
				

			

		

		

			
				
SpringBoot整合Elasticsearch是现代Java开发中常见的一项任务，因为SpringBoot的便捷性和Elasticsearch的高效搜索能力，使得这种结合在数据检索、分析和日志存储等领域广泛应用。本项目"springboot-elasticsearch-...

			
		

	



                


  
              

                


	

		

			

				
					
org.springframework.data.elasticsearch.ElasticsearchException: Bulk indexing has failures.

				
			

			

				

					qq_31443213的博客
				

				

					04-29
					
					7054
					
				

			

		

		

			
				
ES新节点的数据目录data存储空间不足



1.提供足够的存储空间供数据写入，如需在配置文件中更改ES数据存储目录，注意重启ES
2.放开索引只读设置，在Kibana的开发工具Dev Tools中执行







PUT _settings
{
 "index.blocks.read_only_allow_delete": null

}
...

			
		

	





	

		

			

				
					
Spring Data集成Elasticsearch

				
			

			

				

					花&败
				

				

					06-26
					
					967
					
				

			

		

		

			
				
1、简介


Spring Data Elasticsearch基于Spring Data API简化 Elasticsearch 操作，将原始操作Elasticsearch 的客户端API进行封装。Spring Data为Elasticsearch 项目提供集成搜索引擎。Spring Data Elasticsearch POJO的关键功能区域为中心的模型与Elastichsearch交互文档和轻松地编写一个存储索引库数据访问层。


2、框架集成-SpringData-代码功能集成


一、创建Mav.

			
		

	



		

			
		



	

		

			

				
					
Elasticsearch基本用法(2)--Spring Data Elasticsearch

				
			

			

				

					
				

				

					01-15
					
					191
					
				

			

		

		

			
				
Spring Data Elasticsearch是Spring Data项目下的一个子模块。
查看 Spring Data的官网：http://projects.spring.io/spring-data/

Spring Data的使命是为数据访问提供熟悉且一致的基于Spring的编程模型，同时仍保留底层数据存储的特殊特性。
它使得使用数据访问技术，关系数据库和非关系数据库，map-...

			
		

	





	

		

			

				
					
ELK SpringData框架 Springboot集成elasticSearch (六)

				
			

			

				

					qq_50909707的博客
				

				

					09-18
					
					1498
					
				

			

		

		

			
				
ELK SpringData框架 Springboot集成elasticSearch (六)

			
		

	





	

		

			

				
					
SpringBoot整合Elasticsearch7.2.0的实现方法

				
			

			

				

					08-25
				

			

		

		

			
				
SpringBoot整合Elasticsearch7.2.0的实现方法  在本篇文章中，我们将详细介绍如何将 Spring Boot 与 Elasticsearch 7.2.0 整合的实现方法。该方法主要通过示例代码进行详细的介绍，对大家的学习或者工作具有一定的...

			
		

	





	

		

			

				
					
SpringBoot整合Elasticsearch完整源码

				
			

			

				

					02-16
				

			

		

		

			
				
这个"SpringBoot整合Elasticsearch完整源码"提供了实现这一目标的详细步骤和代码实例。以下是对相关知识点的详细说明：  1. **Spring Boot**：  Spring Boot是由Pivotal Team创建的，旨在简化Spring应用的初始搭建...

			
		

	





	

		

			

				
					
SpringBoot整合elasticsearch集群

				
			

			

				

					01-07
				

			

		

		

			
				
8.2.8 SpringBoot整合elasticsearch集群 Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。Spring Boot是由Pivotal团队...

			
		

	





	

		

			

				
					
springboot整合ElasticSearch集群

				
			

			

				

					03-29
				

			

		

		

			
				
springboot 2.0.2集成elasticsearch5.5.1，并使用集群模式，亲测可用！！！

			
		

	





	

		

			

				
					
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。

				
			

			

				

					03-31
				

			

		

		

			
				
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。

			
		

	





	

		

			

				
					
SpringBoot整合ElasticSearch实践

				
			

			

				

					08-30
				

			

		

		

			
				
SpringBoot 整合 Elasticsearch 实践  本篇文章主要介绍了 SpringBoot 整合 Elasticsearch 实践，通过一个发表文章的案例来说明 SpringBoot 如何与 Elasticsearch 集成。Elasticsearch 本身可以是一个独立的服务，也...

			
		

	





	

		

			

				
					
springboot整合Elasticsearch

				
			

			

				

					12-05
				

			

		

		

			
				
通过以上步骤，你可以轻松地在Spring Boot应用中整合Elasticsearch，实现高效的全文搜索、数据分析和存储功能。随着项目的深入，还可以探索更高级的功能，如聚合分析、地理位置搜索、多租户支持等，进一步提升应用的...

			
		

	





	

		

			

				
					
SpringBoot整合ElasticSearch的示例代码

				
			

			

				

					08-29
				

			

		

		

			
				
SpringBoot整合ElasticSearch的示例代码  本篇文章主要介绍了SpringBoot整合ElasticSearch的示例代码，通过示例代码讲解了如何将ElasticSearch与SpringBoot整合，实现搜索功能。  知识点1：ElasticSearch简介 ...

			
		

	





	

		

			

				
					
springboot整合elasticsearch

				
			

			

				

					01-20
				

			

		

		

			
				
此篇文章为springboot整合elasticsearch的demo,以此做一下记录 文章目录环境准备运行elasticsearchdemo代码展示代码结构图pom.xmlapplication.ymlmodelservicecontroller启动类postman请求连接插入数据查询数据...

			
		

	





	

		

			

				
					
SpringBoot 集成Elasticsearch简单八步

				
			

			

				

					程序人生
				

				

					07-21
					
					1831
					
				

			

		

		

			
				
Elasticsearch是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据

			
		

	





	

		

			

				
					
Spring管理Elasticsearch客户端

				
			

			

				

					Vampierty的专栏
				

				

					01-21
					
					717
					
				

			

		

		

			
				
遇到2个问题：

1.我的Elasticsearch安装了X-pack插件，现有的Spring-data-elasticsearch不支持x-pack。

2.我的Elasticsearch开启了SSL验证，在连接时需要设置。

 

ElasticsearchTemplate是Spring-data-elasticsearch包封装好的Elasticsearch客户端对象，里面包含了Elasti...

			
		

	





	

		

			

				
					
Spring 整合 ElasticSearch(全文检索服务)

				
			

			

				

					cn_yaojin
				

				

					01-16
					
					2823
					
				

			

		

		

			
				
原文地址：  https://blog.csdn.net/Orangesss_/article/details/82260749

https://blog.csdn.net/chinabestchina/article/details/80753879

 

Spring 整合 ElasticSearch(全文检索服务)


1.为什么要使用ES?


数据库查询有缺点? 数据越大, 查询效率...

			
		

	





	

		

			

				
					
SpringBoot整合elasticsearch

				
			

			

				

					04-27
				

			

		

		

			
				
好的，下面是SpringBoot整合elasticsearch的步骤：  1. 引入elasticsearch和spring-boot-starter-data-elasticsearch的依赖：  ```   <groupId>org.elasticsearch  <artifactId>elasticsearch  <version>7.12.1     ...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
远走与梦游

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值