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());
}
}