架構整合集成—分佈式標配組件—Spring Boot 集成 ElasticSearch

Spring Boot 集成 ElasticSearch

1. pom.xml 中添加依賴

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

2. application.properties中添加 配置信息

# 集羣名(默認值: elasticsearch，在elasticsearch.yml配置文件中修改
# `cluster.name`: es-application)
spring.data.elasticsearch.cluster-name=es-application
# 集羣節點地址列表，用逗號分隔
spring.data.elasticsearch.cluster-nodes=127.0.0.1:9300

3. 在查詢實體上添加ES註解 例如：

@Document(indexName = "customer", type = "customer", shards = 1, replicas = 0, refreshInterval = "-1")
public class Customer {

   //Id註解加上後，在Elasticsearch裏相應於該列就是主鍵了，在查詢時就可以直接用主鍵查詢
   @Id
   private String id;

   private String userName;

   private String address;

   private int age;

   public Customer() {
   }

   public Customer(String userName, String address, int age) {
      this.userName = userName;
      this.address = address;
      this.age = age;
   }

   public String getId() {
      return this.id;
   }

   public void setId(String id) {
      this.id = id;
   }

   public String getUserName() {
      return userName;
   }

   public void setUserName(String userName) {
      this.userName = userName;
   }

   public String getAddress() {
      return address;
   }

   public int getAge() {
      return age;
   }

   public void setAge(int age) {
      this.age = age;
   }

   public void setAddress(String address) {
      this.address = address;
   }

   @Override
   public String toString() {
      return "Customer{" +
            "id='" + id + '\'' +
            ", userName='" + userName + '\'' +
            ", address='" + address + '\'' +
            ", age=" + age +
            '}';
   }
}

4. 編寫操作的 repository （類似JPA）

public interface CustomerRepository extends ElasticsearchRepository<Customer, String> {
   public List<Customer> findByAddress(String address);
   public Customer findByUserName(String userName);
   public int  deleteByUserName(String userName);
   public Page<Customer> findByAddress(String address, Pageable pageable);
}

5. 簡單配置完成之後我們在業務中就可以使用 ElasticSearch 了。

我們來測試一下：repository

裏面除了增刪改查、排序、分頁、多條件查詢、範圍查詢、模糊查詢、聚合運算等，具體參考ES官方API

https://www.elastic.co/guide/en/elasticsearch/reference/current/getting-started.html

package com.duk.repository;

import com.duk.model.Customer;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.metrics.sum.InternalSum;
import org.elasticsearch.search.aggregations.metrics.sum.SumAggregationBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
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 org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.ResultsExtractor;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class CustomerRepositoryTest {
    @Autowired
    private CustomerRepository repository;
    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    @Test
    public void saveCustomers() {
        repository.save(new Customer("Alice", "北京",13));
        repository.save(new Customer("Bob", "北京",23));
        repository.save(new Customer("neo", "西安",30));
        repository.save(new Customer("summer", "煙臺",22));
    }

    @Test
    public void fetchAllCustomers() {
        System.out.println("Customers found with findAll():");
        System.out.println("-------------------------------");
        Iterable<Customer> iterable=repository.findAll();
        for (Customer customer :iterable) {
            System.out.println(customer);
        }
    }

    @Test
    public void deleteCustomers() {
        repository.deleteAll();
//        repository.deleteByUserName("neo");
    }

    @Test
    public void updateCustomers() {
        Customer customer= repository.findByUserName("summer");
        System.out.println(customer);
        customer.setAddress("北京市海淀區西直門");
        repository.save(customer);
        Customer xcustomer=repository.findByUserName("summer");
        System.out.println(xcustomer);
    }

    @Test
    public void fetchIndividualCustomers() {
        System.out.println("Customer found with findByUserName('summer'):");
        System.out.println("--------------------------------");
        System.out.println(repository.findByUserName("summer"));
        System.out.println("--------------------------------");
        System.out.println("Customers found with findByAddress(\"北京\"):");
        String q="北京";
        for (Customer customer : repository.findByAddress(q)) {
            System.out.println(customer);
        }
    }

    @Test
    public void fetchPageCustomers() {
        System.out.println("Customers found with fetchPageCustomers:");
        System.out.println("-------------------------------");
        Sort sort = new Sort(Sort.Direction.DESC, "address.keyword");
        Pageable pageable = PageRequest.of(0, 10, sort);
        Page<Customer> customers=repository.findByAddress("北京", pageable);
        System.out.println("Page customers "+customers.getContent().toString());
    }

    @Test
    public void fetchPage2Customers() {
        // 精確查詢
        QueryBuilders.termQuery("address","北京");
        QueryBuilders.matchQuery("address","北京");
        //
        QueryBuilders.termsQuery("","");
        QueryBuilders.multiMatchQuery("","");
        QueryBuilders.matchAllQuery();
        // 模糊查詢
        //1.常用的字符串查詢
        QueryBuilders.queryStringQuery("fieldValue").field("fieldName");//左右模糊
        //2.常用的用於推薦相似內容的查詢
        //如果不指定filedName，則默認全部，常用在相似內容的推薦上
//        QueryBuilders.moreLikeThisQuery(new String[] {"fieldName"}).addLikeText("pipeidhua");
        //3.前綴查詢，如果字段沒分詞，就匹配整個字段前綴
        QueryBuilders.prefixQuery("fieldName","fieldValue");
        //4.fuzzy query:分詞模糊查詢，通過增加 fuzziness 模糊屬性來查詢，如能夠匹配 hotelName 爲 tel 前或後加一個字母的文檔，
        // fuzziness 的含義是檢索的 term 前後增加或減少 n 個單詞的匹配查詢
        QueryBuilders.fuzzyQuery("hotelName", "tel").fuzziness(Fuzziness.ONE);
        //5.wildcard query:通配符查詢，支持* 任意字符串；？任意一個字符
        QueryBuilders.wildcardQuery("fieldName","ctr*");//前面是fieldname，後面是帶匹配字符的字符串
        QueryBuilders.wildcardQuery("fieldName","c?r?");
        // 範圍查詢
        //閉區間查詢
        QueryBuilder queryBuilder0 = QueryBuilders.rangeQuery("fieldName").from("fieldValue1").to("fieldValue2");
        //開區間查詢
        //默認是 true，也就是包含
        QueryBuilder queryBuilder1 = QueryBuilders.rangeQuery("fieldName").from("fieldValue1").to("fieldValue2").includeUpper(false).includeLower(false);
        //大於
        QueryBuilder queryBuilder2 = QueryBuilders.rangeQuery("fieldName").gt("fieldValue");
        //大於等於
        QueryBuilder queryBuilder3 = QueryBuilders.rangeQuery("fieldName").gte("fieldValue");
        //小於
        QueryBuilder queryBuilder4 = QueryBuilders.rangeQuery("fieldName").lt("fieldValue");
        //小於等於
        QueryBuilder queryBuilder5 = QueryBuilders.rangeQuery("fieldName").lte("fieldValue");

        // 多條件查詢
        QueryBuilders.boolQuery().should();// or
        QueryBuilders.boolQuery().must();//文檔必須完全匹配條件，相當於 and
        QueryBuilders.boolQuery().mustNot();//文檔必須不匹配條件，相當於 not


        System.out.println("Customers found with fetchPageCustomers:");
        System.out.println("-------------------------------");
       QueryBuilder customerQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.matchQuery("address", "北京"));
        Page<Customer> page = repository.search(customerQuery, PageRequest.of(0, 10));
        System.out.println("Page customers "+page.getContent().toString());
        page = repository.search(customerQuery, PageRequest.of(1, 10));
        System.out.println("Page customers "+page.getContent().toString());
    }

    @Test
    public void fetchAggregation() {
        // 聚合查詢的使用方式。5步驟
        System.out.println("Customers found with fetchAggregation:");
        System.out.println("-------------------------------");

       QueryBuilder customerQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.matchQuery("address", "北京"));

        SumAggregationBuilder sumBuilder = AggregationBuilders.sum("sumAge").field("age");

        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(customerQuery)
                .addAggregation(sumBuilder)
                .build();

        Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {
            @Override
            public Aggregations extract(SearchResponse response) {
                return response.getAggregations();
            }
        });

       //轉換成map集合
        Map<String, Aggregation> aggregationMap = aggregations.asMap();
        //獲得對應的聚合函數的聚合子類，該聚合子類也是個map集合,裏面的value就是桶Bucket，我們要獲得Bucket
        InternalSum sumAge = (InternalSum) aggregationMap.get("sumAge");
        System.out.println("sum age is "+sumAge.getValue());
    }

}