springtboot 操作es

最新推荐文章于 2024-01-04 14:32:29 发布
最新推荐文章于 2024-01-04 14:32:29 发布
阅读量317 收藏
点赞数
分类专栏： Elasticsearch 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_21349635/article/details/120104935
版权

文章目录


本文章看了下
在这里插入图片描述
使用的是6.8的包，但是我本地安装的是7.13.4.居然也能操作，如果是7.x的包的话，就好了，暂时不影响使用。

三大块

rest操作api

package com.tjx.elasticsearch;

import org.apache.http.HttpHost;
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.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
public class TestRest {

    @Test
    void testRestInsert() throws IOException {
        //1.连接rest接口
        HttpHost http = new HttpHost("127.0.0.1", 9200, "http");
        RestClientBuilder restClientBuilder = RestClient.builder(http);//rest构建器
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);//获取高级客户端对象

        //2.封装请求对象
        //BulkRequest bulkRequest = new BulkRequest(); //用于批量操作
        IndexRequest indexRequest = new IndexRequest("test_rest", "_doc", "1");
        HashMap skuMap = new HashMap();
        skuMap.put("name","法拉利 LaFerrari Aperta");
        skuMap.put("brandName","法拉利");
        skuMap.put("categoryName","超级跑车");
        HashMap spec = new HashMap();
        spec.put("动力","963匹");
        spec.put("扭矩","880N/m");
        spec.put("车长","4975mm");
        spec.put("重量","1250kg");
        skuMap.put("spec",spec);
        skuMap.put("createTime","2017-08-10");
        skuMap.put("price",43000000);
        skuMap.put("saleNum",209);
        skuMap.put("commentNum",6128746);
        indexRequest.source(skuMap);
        //bulkRequest.add(indexRequest); //用于批量操作
        //3.获取响应结果
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        //BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT); //用于批量操作
        int status = indexResponse.status().getStatus();
        System.out.println(status);
        restHighLevelClient.close();
    }

    @Test
    void testRestQueryMatch() throws IOException {
        //1.连接rest接口
        HttpHost http = new HttpHost("127.0.0.1", 9200, "http");
        RestClientBuilder restClientBuilder = RestClient.builder(http);//rest构建器
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);//获取高级客户端对象

        //2.封装查询请求
        SearchRequest searchRequest = new SearchRequest("test_rest");
        searchRequest.types("_doc"); //设置查询的类型
        //创建查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); //查询源构建器
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("categoryName", "超级跑车");
        searchSourceBuilder.query(matchQueryBuilder);
        searchRequest.source(searchSourceBuilder);

        //3.获取查询结果
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        long totalHits = searchHits.getTotalHits();
        System.out.println("记录数:"+totalHits);
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
        restHighLevelClient.close();
    }



    @Test
    void testRestQueryBool() throws IOException {
        //1.连接rest接口
        HttpHost http = new HttpHost("127.0.0.1", 9200, "http");
        RestClientBuilder restClientBuilder = RestClient.builder(http);//rest构建器
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);//获取高级客户端对象

        //2.封装查询请求
        SearchRequest searchRequest = new SearchRequest("test_rest");
        searchRequest.types("_doc"); //设置查询的类型
        //创建查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); //查询源构建器
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery(); //布尔查询构建器
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("name", "LaFerrari");
        boolQueryBuilder.must(matchQueryBuilder);
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("brandName", "法拉利");
        boolQueryBuilder.must(termQueryBuilder);
        searchSourceBuilder.query(boolQueryBuilder);
        searchRequest.source(searchSourceBuilder);

        //3.获取查询结果
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        long totalHits = searchHits.getTotalHits();
        System.out.println("记录数:" + totalHits);
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
        restHighLevelClient.close();
    }


    @Test
    void testRestQueryfilter() throws IOException {
        //1.连接rest接口
        HttpHost http = new HttpHost("127.0.0.1", 9200, "http");
        RestClientBuilder restClientBuilder = RestClient.builder(http);//rest构建器
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);//获取高级客户端对象

        //2.封装查询请求
        SearchRequest searchRequest = new SearchRequest("test_rest");
        searchRequest.types("_doc"); //设置查询的类型
        //创建查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); //查询源构建器
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery(); //布尔查询构建器
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("brandName", "法拉利");
        boolQueryBuilder.filter(termQueryBuilder);
        searchSourceBuilder.query(boolQueryBuilder);
        searchRequest.source(searchSourceBuilder);

        //3.获取查询结果
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        long totalHits = searchHits.getTotalHits();
        System.out.println("记录数:" + totalHits);
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
        restHighLevelClient.close();
    }

    @Test
    void testRestQueryAggregation() throws IOException {
        //连接rest接口
        HttpHost http = new HttpHost("127.0.0.1", 9200, "http");
        RestClientBuilder restClientBuilder = RestClient.builder(http);//rest构建器
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);//获取高级客户端对象
        //封装查询请求
        SearchRequest searchRequest = new SearchRequest("test_rest");
        searchRequest.types("_doc"); //设置查询的类型
        //创建查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); //查询源构建器
        TermsAggregationBuilder aggregation = AggregationBuilders.terms("类型名称").field("categoryName");
        searchSourceBuilder.aggregation(aggregation);
        searchSourceBuilder.size(0);
        searchRequest.source(searchSourceBuilder);
        //获取查询结果
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = response.getAggregations();
        Map<String, Aggregation> map = aggregations.getAsMap();
        Terms terms = (Terms) map.get("类型名称");
        List<? extends Terms.Bucket> buckets = terms.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            System.out.println(bucket.getKeyAsString()+":"+bucket.getDocCount());
        }
        restHighLevelClient.close();


        //高亮设置
//        HighlightBuilder highlightBuilder = new HighlightBuilder();
//        highlightBuilder.field("name").preTags("<font style='color:red'>").postTags("</font>");
//        searchSourceBuilder.highlighter(highlightBuilder);
    }
}

elasticRestTemplate操作es

package com.tjx.elasticsearch;

import com.alibaba.fastjson.JSONObject;
import com.tjx.elasticsearch.bean.ChildItem;
import com.tjx.elasticsearch.bean.Item;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.range.Range;
import org.elasticsearch.search.aggregations.bucket.range.RangeAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.InternalNumericMetricsAggregation;
import org.elasticsearch.search.aggregations.metrics.avg.Avg;
import org.elasticsearch.search.aggregations.metrics.avg.AvgAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.cardinality.CardinalityAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.stats.extended.ExtendedStatsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.tophits.TopHits;
import org.elasticsearch.search.aggregations.metrics.tophits.TopHitsAggregationBuilder;
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.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.ResultsExtractor;
import org.springframework.data.elasticsearch.core.ScrolledPage;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.IndexQueryBuilder;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery;

@SpringBootTest
public class TestElasticsearchTemplate {

    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    @Test
    void createIndex(){
        //创建索引及映射
        elasticsearchTemplate.createIndex(Item.class);
        //创建映射
//        elasticsearchTemplate.putMapping(Item.class);
    }


    @Test
    void putMegacorp() {
        List<String> list=new ArrayList<>();
        list.add("sports");
        list.add("music");
        ChildItem childItem=new ChildItem(100,"taibai");
        Item item1=new Item(6L,"John","男",25,list,childItem);
        Item item2=new Item(7L,"Jane","Smith",32, Arrays.asList("music"),childItem);
        Item item3=new Item(8L,"Douglas","Fir",35,Arrays.asList("forestry"),childItem);
        IndexQuery indexQuery1 = new IndexQueryBuilder().withId(String.valueOf(item1.getLd())).withObject(item1).build();
        IndexQuery indexQuery2 = new IndexQueryBuilder().withId(String.valueOf(item2.getLd())).withObject(item2).build();
        IndexQuery indexQuery3 = new IndexQueryBuilder().withId(String.valueOf(item3.getLd())).withObject(item3).build();
        elasticsearchTemplate.bulkIndex(Arrays.asList(indexQuery1,indexQuery2,indexQuery3));
    }

    @Test
    void testPage() {
        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(matchAllQuery())
                .withIndices("test_springdata_es")
                .withPageable(PageRequest.of(0, 10))
                .build();

        ScrolledPage<Item> scroll = elasticsearchTemplate.startScroll(1000, searchQuery, Item.class);
        String scrollId = scroll.getScrollId();
        List<Item> content = scroll.getContent();
        content.forEach(item->{
            System.out.println(item);
        });
        System.out.println(scrollId);
        elasticsearchTemplate.clearScroll(scrollId);
    }


    //平均最大最小求和聚合
    @Test
    void testAggregation(){
        AvgAggregationBuilder avgAggregationBuilder = AggregationBuilders.avg("taibai").field("price");
//        MaxAggregationBuilder maxAggregationBuilder = AggregationBuilders.max("taibai").field("price");
        SearchQuery searchQuery = new NativeSearchQueryBuilder().addAggregation(avgAggregationBuilder)
                .withIndices("goods")
                .withTypes("_doc")
                .build();
        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {

            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });
        Aggregation aggregation1 = aggregations.asList().get(0);
        InternalNumericMetricsAggregation.SingleValue singleValue= (InternalNumericMetricsAggregation.SingleValue) aggregation1;
        double value = singleValue.value();
        System.out.println(value);
    }

    //去重
    @Test
    void testAggregationCardinality(){
        CardinalityAggregationBuilder aggregationBuilder = AggregationBuilders.cardinality("taibai").field("price");
        SearchQuery searchQuery = new NativeSearchQueryBuilder().addAggregation(aggregationBuilder)
                .withIndices("goods")
                .withTypes("_doc")
                .build();
        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {

            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });
        Aggregation aggregation1 = aggregations.getAsMap().get("taibai");
        InternalNumericMetricsAggregation.SingleValue singleValue= (InternalNumericMetricsAggregation.SingleValue) aggregation1;
        double value = singleValue.value();
        System.out.println(value);
    }


    //扩展查询
    @Test
    void testAggregationextended_stats(){
        ExtendedStatsAggregationBuilder extendedStatsAggregationBuilder = AggregationBuilders.extendedStats("taibai").field("price");
        SearchQuery searchQuery = new NativeSearchQueryBuilder().addAggregation(extendedStatsAggregationBuilder)
                .withIndices("goods")
                .withTypes("_doc")
                .build();
        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {

            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });
        Aggregation aggregation1 = aggregations.getAsMap().get("taibai");
        InternalNumericMetricsAggregation.MultiValue multiValue= (InternalNumericMetricsAggregation.MultiValue ) aggregation1;
        System.out.println(multiValue.value("max"));
    }


    //terms词聚合
    @Test
    void testAggregationTerms(){
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("taibai").field("price");
        SearchQuery searchQuery = new NativeSearchQueryBuilder().addAggregation(termsAggregationBuilder)
                .withIndices("goods")
                .withTypes("_doc")
                .build();
        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {

            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });
        Aggregation aggregation1 = aggregations.getAsMap().get("taibai");
        Terms term1 = (Terms)aggregation1;
        List<? extends Terms.Bucket> buckets = term1.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            System.out.println(bucket.getKey()+"||"+bucket.getDocCount());
        }
    }

    //top_hits最高匹配权值聚合
    @Test
    void testAggregationtop_hits(){
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("taibai").field("price");
        TopHitsAggregationBuilder topHitsAggregationBuilder = AggregationBuilders.topHits("top").size(3);
        termsAggregationBuilder.subAggregation(topHitsAggregationBuilder);
        SearchQuery searchQuery = new NativeSearchQueryBuilder().addAggregation(termsAggregationBuilder)
                .withIndices("goods")
                .withTypes("_doc")
                .build();
        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {

            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });
        Aggregation aggregation1 = aggregations.getAsMap().get("taibai");
        Terms term1 = (Terms)aggregation1;
        List<? extends Terms.Bucket> buckets = term1.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            System.out.println(bucket.getKey()+"||"+bucket.getDocCount());
            Aggregation aggregation = bucket.getAggregations().getAsMap().get("top");
            TopHits topHits= (TopHits) aggregation;
            Iterator<SearchHit> iterator = topHits.getHits().iterator();
            while (iterator.hasNext()){
                SearchHit next = iterator.next();
                Object object=JSONObject.parse(next.getSourceAsString());
                System.out.println(object);
            }
        }
    }


    @Test
    void testAggregationRange(){
        RangeAggregationBuilder rangeAggregationBuilder = AggregationBuilders.range("taibai").field("age")
                .addRange(20,30).addRange(30,40).addRange(40,50);
        SearchQuery searchQuery = new NativeSearchQueryBuilder().addAggregation(rangeAggregationBuilder)
                .withIndices("bank")
                .withTypes("_doc")
                .build();
        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {

            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });
        Aggregation aggregation1 = aggregations.getAsMap().get("taibai");
        Range range = (Range)aggregation1;
        List<? extends Range.Bucket> buckets = range.getBuckets();
        for (Range.Bucket bucket : buckets) {
            System.out.println(bucket.getKeyAsString()+"--"+bucket.getDocCount());
        }
    }


    @Test
    void testAggregationLast(){
        RangeAggregationBuilder rangeAggregationBuilder = AggregationBuilders.range("age_range").field("age")
                .addRange(20,30).addRange(30,40).addRange(40,50);
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("gender_group").field("gender.keyword");
        AvgAggregationBuilder aggregationBuilder = AggregationBuilders.avg("balance_avg").field("balance");
        termsAggregationBuilder.subAggregation(aggregationBuilder);
        rangeAggregationBuilder.subAggregation(termsAggregationBuilder);
        SearchQuery searchQuery = new NativeSearchQueryBuilder().addAggregation(rangeAggregationBuilder)
                .withIndices("bank")
                .withTypes("_doc")
                .build();
        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {

            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });
        Aggregation aggregation1 = aggregations.getAsMap().get("age_range");
        Range range = (Range)aggregation1;
        List<? extends Range.Bucket> buckets = range.getBuckets();
        for (Range.Bucket bucket : buckets) {
            System.out.println(bucket.getKeyAsString()+"--"+bucket.getDocCount());
            Aggregation gender_group = bucket.getAggregations().getAsMap().get("gender_group");
            Terms terms=(Terms)gender_group;
            List<? extends Terms.Bucket> buckets1 = terms.getBuckets();
            for (Terms.Bucket bucket1 : buckets1) {
                System.out.println(bucket1.getKeyAsString()+"--"+bucket1.getDocCount());
                Aggregation balance_avg = bucket1.getAggregations().getAsMap().get("balance_avg");
                Avg avg= (Avg) balance_avg;
                System.out.println(avg.getValue());
            }
        }
    }



}

mapper操作es

@Configuration
public class TransportClientConfig extends ElasticsearchConfigurationSupport {

  @Bean
  public Client elasticsearchClient() throws UnknownHostException {
//    Settings settings = Settings.builder().put("cluster.name", "taibai").build();
    Settings settings = Settings.builder().build();
    TransportClient client = new PreBuiltTransportClient(settings);
    client.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
    return client;
  }

  @Bean(name = {"elasticsearchOperations", "elasticsearchTemplate"})
  public ElasticsearchTemplate elasticsearchTemplate() throws UnknownHostException {
      return new ElasticsearchTemplate(elasticsearchClient(), entityMapper());
  }

  @Bean
  @Override
  public EntityMapper entityMapper() {
    ElasticsearchEntityMapper entityMapper = new ElasticsearchEntityMapper(elasticsearchMappingContext(),
  	  new DefaultConversionService());
    entityMapper.setConversions(elasticsearchCustomConversions());
    return entityMapper;
  }
}

GoodMapper

import com.tjx.elasticsearch.bean.Goods;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

import java.util.List;

public interface GoodsMapper extends ElasticsearchRepository<Goods, String> {
    List<Goods> findByName(String name);


    List<Goods> findByName(String name, Pageable pageable);
}

TestMapper

package com.tjx.elasticsearch;

import com.tjx.elasticsearch.bean.Goods;
import com.tjx.elasticsearch.mapper.GoodsMapper;
import org.elasticsearch.index.query.*;
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.Pageable;
import org.springframework.data.domain.Sort;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

@SpringBootTest
class TestMapper {

	@Autowired
	GoodsMapper goodsMapper;


	//添加一条数据 and  修改一条数据
	@Test
	void insertGoods() {
		SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String str = simpleDateFormat.format(new Date());
		Goods goods=new Goods(1025332689,"","OPPO R17新年版 2500万美颜拍照 6.4英寸水滴屏 光感屏幕指纹 6G+128G 全网通 移动联通电信4G 双卡双待手机",
				37400,20,100,"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				10,str,str,"10000243333000",558,"手机","OPPO","{'颜色': '王者荣耀定制版', '版本': 'R17'}",1,1,1,4L);
		System.out.println(goodsMapper.save(goods));
	}

	//批量插入和批量修改
	@Test
	void insertGoodsList() {

		List<Goods> list=new ArrayList<>();
		SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String str = simpleDateFormat.format(new Date());
		Goods goods=new Goods(1001332689,"","OPPO R17新年版 2500万美颜拍照 6.4英寸水滴屏 光感屏幕指纹 6G+128G 全网通 移动联通电信4G 双卡双待手机",
				37400,10000,100,"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				10,str,str,"10000243333000",558,"手机","OPPO","{'颜色': '王者荣耀定制版', '版本': 'R17'}",1,1,1);

		Goods goods2=new Goods(1001368912,"","OPPO R17新年版 2500万美颜拍照 6.4英寸水滴屏 光感屏幕指纹 6G+128G 全网通 移动联通电信4G 双卡双待手机",
				37400,10000,100,"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				10,str,str,"10000243333000",558,"手机","OPPO","{'颜色': '王者荣耀定制版', '版本': 'R17'}",1,1,1);


		Goods goods3=new Goods(100001402792L,"","OPPO R17新年版 2500万美颜拍照 6.4英寸水滴屏 光感屏幕指纹 6G+128G 全网通 移动联通电信4G 双卡双待手机",
				37400,10000,100,"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				"https://m.360buyimg.com/mobilecms/s720x720_jfs/t1/10441/9/5525/162976/5c177debEaf815b43/3aa7d4dc182cc4d9.jpg!q70.jpg.webp",
				10,str,str,"10000243333000",558,"手机","OPPO","{'颜色': '王者荣耀定制版', '版本': 'R17'}",1,1,1);

		list.add(goods);
		list.add(goods2);
		list.add(goods3);
		goodsMapper.saveAll(list);
	}


	//删除数据
	@Test
	void updateGoods() {
		//删除一条
//		goodsMapper.deleteById("1001332689");
		//删除所有或者传入集合 删除集合中的数据
		goodsMapper.deleteAll();
	}



    //查询数据
	@Test
	void uqueryGoods() {
		//查询一条数据
//		Optional<Goods> goods = goodsMapper.findById("100001402792");
//		System.out.println(goods.get());

//		System.out.println("====================================");
		//查询所有数据
//		Iterable<Goods> goodsAll = goodsMapper.findAll();
//		Iterator<Goods> goodsIterator = goodsAll.iterator();
//		int count=0;
//		while (goodsIterator.hasNext()){
//			Goods goods1 = goodsIterator.next();
//			System.out.println(goods1);
//			count++;
//		}
//		System.out.println(count);

//		System.out.println("====================================");
		//分页排序
		// page页码   并不是跳过多少数据
		//返回数
		Pageable pageable=PageRequest.of(1,100,Sort.by(Sort.Direction.ASC, "num"));
		Page<Goods> goodsPage = goodsMapper.findAll(pageable);
		Iterator<Goods> goodsIterator = goodsPage.iterator();
		int count=0;
		while (goodsIterator.hasNext()){
			Goods goods1 = goodsIterator.next();
			System.out.println(goods1);
			count++;
		}
		System.out.println(count);
	}


	@Test
	void exists(){
		//判断文档是否存在
		boolean exists = goodsMapper.existsById("文档ID");
	}


	//term查询
	@Test
	void termGoods(){
		//主要用于精确匹配哪些值，比如数字，日期，布尔值或 not_analyzed 的字符串(未经分析的文本数据类型)
		// 搜索前不会再对搜索词进行分词，所以我们的搜索词必须是文档分词集合中的一个。
		TermQueryBuilder termQueryBuilder=new TermQueryBuilder("name","2018");
		Pageable pageable=PageRequest.of(0,100);
		Iterable<Goods> goods = goodsMapper.search(termQueryBuilder,pageable);
		Iterator<Goods> goodsIterator = goods.iterator();
		int count=0;
		while (goodsIterator.hasNext()){
			Goods goods1 = goodsIterator.next();
			System.out.println(goods1);
			count++;
		}
		System.out.println(count);
	}


	//terms查询
	@Test
	void termsGoods(){
		//terms 跟 term 有点类似，但 terms 允许指定多个匹配条件。
		// 如果某个字段指定了多个值，那么文档需要一起去做匹配    或者关系
		TermsQueryBuilder termsQueryBuilder=new TermsQueryBuilder("name","2018","最新","女鞋");
		Pageable pageable=PageRequest.of(0,100);
		Iterable<Goods> goods = goodsMapper.search(termsQueryBuilder,pageable);
		Iterator<Goods> goodsIterator = goods.iterator();
		int count=0;
		while (goodsIterator.hasNext()){
			Goods goods1 = goodsIterator.next();
			System.out.println(goods1);
			count++;
		}
		System.out.println(count);
	}


	//range查询
	@Test
	void rangelGoods(){
		//范围查询
		RangeQueryBuilder rangeQueryBuilder=new RangeQueryBuilder("price");
		rangeQueryBuilder.gt(20);
		rangeQueryBuilder.lt(10000);
		Pageable pageable=PageRequest.of(0,100);
		Iterable<Goods> goods = goodsMapper.search(rangeQueryBuilder,pageable);
		Iterator<Goods> goodsIterator = goods.iterator();
		int count=0;
		while (goodsIterator.hasNext()){
			Goods goods1 = goodsIterator.next();
			System.out.println(goods1);
			count++;
		}
		System.out.println(count);
	}


	//exists查询
	@Test
	void existsGoods(){
		//exists 查询可以用于查找文档中是否包含指定字段或没有某个字段，类似于SQL语句中的 IS_NULL 条件
		//包含这个字段就返回返回这条数据
		ExistsQueryBuilder existsQueryBuilder=new ExistsQueryBuilder("category_name");
		Pageable pageable=PageRequest.of(0,100);
		Iterable<Goods> goods = goodsMapper.search(existsQueryBuilder,pageable);
		Iterator<Goods> goodsIterator = goods.iterator();
		int count=0;
		while (goodsIterator.hasNext()){
			Goods goods1 = goodsIterator.next();
			System.out.println(goods1);
			count++;
		}
		System.out.println(count);
	}

	//match查询
	@Test
	void matchGoods(){
        //match查询会先对搜索词进行分词,分词完毕后再逐个对分词结果进行匹配，因此相比于term的精确搜索，match是分词匹配搜索
		//如果用 match 下指定了一个确切值，在遇到数字，日期，布尔值或者 not_analyzed 的字符串时，它将为你搜索你给定的值
		MatchQueryBuilder matchQueryBuilder=new MatchQueryBuilder("name","2018年最新女鞋");
		Pageable pageable=PageRequest.of(0,100);
		Iterable<Goods> goods = goodsMapper.search(matchQueryBuilder,pageable);
		Iterator<Goods> goodsIterator = goods.iterator();
		int count=0;
		while (goodsIterator.hasNext()){
			Goods goods1 = goodsIterator.next();
			System.out.println(goods1);
			count++;
		}
		System.out.println(count);
	}

	//bool查询 和 filter 查询
	@Test
	void boolGoods(){
//		bool 查询可以用来合并多个条件查询结果的布尔逻辑，它包含一下操作符：
//		must :: 多个查询条件的完全匹配,相当于 and 。
//		must_not :: 多个查询条件的相反匹配，相当于 not 。
//		should :: 至少有一个查询条件匹配, 相当于 or 。
		BoolQueryBuilder boolQueryBuilder=new BoolQueryBuilder();
		//搜索2018年价格在1000-2000之内的女鞋   颜色不能是白色的  只能是黑色或者是红色
		RangeQueryBuilder rangeQueryBuilder=new RangeQueryBuilder("price");
		rangeQueryBuilder.lte(2000);
		rangeQueryBuilder.gte(1000);
		MatchQueryBuilder matchQueryBuilder=new MatchQueryBuilder("name","2018女鞋");

		MatchQueryBuilder matchQueryBuilder2=new MatchQueryBuilder("spec","蓝色");
		boolQueryBuilder.must(rangeQueryBuilder);
		boolQueryBuilder.must(matchQueryBuilder);
		boolQueryBuilder.mustNot(matchQueryBuilder2);

		MatchQueryBuilder matchQueryBuilder3=new MatchQueryBuilder("spec","黑色 红色");
		boolQueryBuilder.must(matchQueryBuilder3);

		TermQueryBuilder termsQueryBuilder=new TermQueryBuilder("num",10000);
		boolQueryBuilder.filter(termsQueryBuilder);

//		Pageable pageable=PageRequest.of(0,100);
		Iterable<Goods> goods = goodsMapper.search(boolQueryBuilder);
		Iterator<Goods> goodsIterator = goods.iterator();
		int count=0;
		while (goodsIterator.hasNext()){
			Goods goods1 = goodsIterator.next();
			System.out.println(goods1);
			count++;
		}
		System.out.println(count);
	}


	//自定义方法
	@Test
	void testCustom(){
//		List<Goods> goodsList = goodsMapper.findByName("2018新款");
//		for (Goods goods : goodsList) {
//			System.out.println(goods);
//		}
		//自定义的方法是分词后 and的关系  必须全部满足
		List<Goods> goodsList2 = goodsMapper.findByName("2018新款李白",PageRequest.of(1,10));
		for (Goods goods : goodsList2) {
			System.out.println(goods);
		}
	}
}

pom

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.1.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.tjx</groupId>
	<artifactId>elasticsearch_springboot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>elasticsearch_springboot</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<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>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
		</dependency>

		<!--<dependency>-->
			<!--<groupId>org.elasticsearch.plugin</groupId>-->
			<!--<artifactId>transport-netty4-client</artifactId>-->
			<!--<version>7.3.2</version>-->
		<!--</dependency>-->
		<!--<dependency>-->
			<!--<groupId>org.elasticsearch.client</groupId>-->
			<!--<artifactId>transport</artifactId>-->
			<!--<version>7.3.2</version>-->
		<!--</dependency>-->

		<!--<dependency>-->
			<!--<groupId>org.elasticsearch</groupId>-->
			<!--<artifactId>elasticsearch</artifactId>-->
			<!--<version>7.3.2</version>-->
		<!--</dependency>-->

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

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.47</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<!-- mybatis依赖 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.0.0</version>
		</dependency>
		<!-- druid数据源依赖 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.12</version>
		</dependency>



	</dependencies>

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

</project>

源码git地址: https://gitee.com/hfl-learn-note/elasticsearch_springboot

完

怒放de生命2010
关注
专栏目录
Spring Boot 集成 ElasticSearch.docx
11-20
Spring Boot集成ElasticSearch是将流行的搜索引擎Elasticsearch与Spring Boot框架相结合，简化了开发过程，使得开发者可以快速地在应用程序中使用Elasticsearch的功能。本文将详细介绍如何在Spring Boot项目中集成...
SpringBoot集成ElasticSearch
qq_42828901的博客
07-26 179
ElasticSearch https://www.elastic.co/guide/index.html 选择 ElasticSearch的客户端Elasticsearch Clients 选择[Java REST Client 7.13] 使用高级的客户端Java High Level REST Client 高级客户端封装了低级的客户端,里面包含常见的API 1.原生的依赖(对基本的依赖进行的封装) <dependency> <groupId>...
SpringBoot-ES操作
sichenss的博客
04-13 3131
本篇基于黑马程序员SpringBoot2全套视频教程,springboot零基础到项目实战(SpringBoot2完整版),是自己学习中整理的笔记
ES7基础篇-10-SpringBoot集成ES操作
Alan0517
11-13 7508
当使用es的客户端时，对于索引库操作，不涉及映射，先获取他的索引库客户端// 创建索引操作客户端然后借助idea的提示，会出现一系列API每个API都可以同步或异步调用。同步方法返回一个响应对象，而异步方法的名称以async后缀结尾，需要一个监听器参数，一旦收到响应或错误，就会被通知（由低级客户端管理的线程池）。
基于SpringBoot的ElasticSearch操作（超详细教程）
Coder
10-05 5520
基于SpringBoot+Elasticsearch的操作项目， 从零到一，囊括了es本身的API操作、java代码的请求 （索引操作、doc操作插入、精准搜索、模糊搜索、聚合搜索等）
Springboot项目使用Elastic Search教程(完整步骤)
weixin_52424236的博客
06-05 4049
经过上面的步骤就配置完成了，运行成功后sprinboot的cmd如下使用apifox进行测试其实从零开始的话要配置的东西还是挺多的，也要查挺多文章，但是所幸elasticsearch和它的插件还有相关的工具的下载和安装并不麻烦（解压即可用），使用起来难度还是不高的。当时搜了挺多文章的资料的，想着把他们整合到一起，希望能够帮助到需要的小伙伴。d下重新运行上面的那条配置指令即可经过上面的步骤就配置完成了，运行成功后sprinboot的cmd如下。
Spring Boot 集成 Elasticsearch
最新发布
08-11
Spring Boot 集成 Elasticsearch
Spring Boot elasticsearch7.6.2基础操作：创建索引、新增数据、查询数据
04-29
在本文中，我们将深入探讨如何使用Spring Boot与Elasticsearch 7.6.2进行基本操作，包括创建索引、添加数据以及查询数据。Elasticsearch是一个强大的分布式搜索引擎，而Spring Boot是Java开发中的轻量级框架，两者...
Spring Boot整合ElasticSearch实现多版本兼容的方法详解
08-27
接下来，在DAO层，我们可以创建一个接口，继承`ElasticsearchRepository, Long>`，这样就可以利用Spring Data Elasticsearch提供的默认CRUD操作。例如： ```java public interface UserRepository extends ...
python中的Elasticsearch操作汇总
09-18
在Python中，Elasticsearch是一个强大的全文搜索引擎库，它提供了丰富的API来操作Elasticsearch集群。下面我们将深入探讨如何在Python环境中使用Elasticsearch进行各种常见的数据操作。 首先，我们需要导入`elastic...
springboot操作es
你就像甜甜的益达
07-25 1709
es记得把没用文件删掉.mvn,和一些mvn的配置文件,要不然可能会导致项目编译不通过。在测试类进行测试,测试类中直接注入restHighLevelClient即可使用;
springboot项目使用ES
热门推荐
香辣小鸡翅膀的博客
07-01 1万+
springboot + ES
SpringBoot整合ES的简单应用
qq614571540的博客
10-08 1146
springboot整个elasticsearch的简单应用
项目中使用es（一）：使用springboot操作elasticsearch
站在墙头上的博客
05-30 3608
ElasticsearchRepository操作es和ElasticsearchRestTemplate操作es
使用SpringBoot操作ElasticSearch
qq_44621891的博客
12-12 243
目录1.引入依赖2.配置application.yml3.SpringBoot如何操作ES提供了相关注解简化ES操作使用使用对象向ES索引文档，删除文档，更新文档1.使用接口继承ElasticsearchRepository接口测试BookRepository执行结果,使用kibana查看操作demo 1.引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artif
SpringBoot系列之ES详细讲解
程序员高级码农的博客
01-04 2210
在我们实际使用过程中，如果value为中文，在查询时，可能会遇到命名有对应的数据，但是就查不到，主要原因就在于分词，如对于中文的查询，可以考虑下面这种方式​​​​​​​。通常来说，实际的业务场景中，不太可能出现上面这种没有任何限制的查全量数据，即便真的有查全量数据的case，更常见的是分页查询，如下​​​​​​​。配置文件application.yml，注意下面的配置信息，下面采用的是由我们自己来解析配置的方式​​​​​​​。即查询所有的文档，如借助kibanan的控制台，发起的请求形如​​​​​​​。
SpringBoot集成elasticsearch使用（增删改查）
ljfgyy0205的博客
04-11 4172
此文适合了解了es相关概念以及基础知识的同学阅读提示：以下是本篇文章正文内容，下面案例可供参考。
ES完整使用从安装到springboot项目操作
NiKaBoy的博客
01-18 1689
ES的原理和基本概念 ES和Kibana的下载与安装 项目中使用ES 配置ElasticsearchClient
Spring Boot 整合 ElasticSearch实战指南
本文档介绍了如何在Spring Boot项目中集成Elasticsearch，包括POM配置、客户端构建以及查询接口的开发。 在Spring Boot项目中集成Elasticsearch是提高应用程序搜索和数据分析能力的重要步骤。首先，我们需要在`pom....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怒放de生命2010

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

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值