目录
1. pom.xml配置
2. application.yml文件配置
3. entity文件配置
4. repository配置
5. controller调用
6. repository自定义方法
7. 其它查询方法--controller调用
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。
我们建立一个网站或应用程序，并要添加搜索功能，但是想要完成搜索工作的创建是非常困难的。我们希望搜索解决方案要运行速度快，我们希望能有一个零配置和一个完全免费的搜索模式，我们希望能够简单地使用JSON通过HTTP来索引数据，我们希望我们的搜索服务器始终可用，我们希望能够从一台开始并扩展到数百台，我们要实时搜索，我们要简单的多租户，我们希望建立一个云的解决方案。因此我们利用Elasticsearch来解决所有这些问题及可能出现的更多其它问题。
ES的基本知识:
mysql数据库可以分为:数据库(database) ->表(table) -> 行(row)->列(column)
es相应也分为: 索引(index)->类型(type)->文档(document)->字段(field)
具体的对应规则如下:
Relational DB -> Database-> Table -> Row -> Column
Elasticsearch -> Index -> Type -> Document-> Field注:
关于type
6.*版本中type已过时, 并且当前版本只能建一个type
7.*版本将删除type, 所以在开发过程中弱化type的概念
1. pom.xml配置
<modelVersion>4.0.0</modelVersion>
<!-- 定义公共资源版本 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.1.RELEASE</version>
<relativePath/>
</parent>
<dependencies>
<!-- elasticsearch -->
<!-- springboot-data-elasticsearch 提供了面向对象的方式操作elasticsearch -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
</dependencies>2. application.yml文件配置
server:
port: 18015
max-http-header-size: 8192
redis:
host: 10.101.15.59
spring:
application:
name: spring-boot-elasticsearch-actuator #ServiceId
# ******************* elasticsearch ******************* #
data:
elasticsearch:
cluster-name: my-application
cluster-nodes: ${redis.host}:9300
properties: {}
elasticsearch:
rest:
uris: ["http://${redis.host}:9200"] # 不配置该配置会报错: Elasticsearch health check failed3. entity文件配置
entity中注解说明
Spring Data通过注解来声明字段的映射属性，有下面的三个注解：
@Document 作用在类，标记实体类为文档对象，一般有两个属性
indexName：对应索引库名称
type：对应在索引库中的类型
shards：分片数量，默认5
replicas：副本数量，默认1
@Id 作用在成员变量，标记一个字段作为id主键
@Field 作用在成员变量，标记为文档的字段，并指定字段映射属性：
type：字段类型，是枚举：FieldType，可以是text、long、short、date、integer、object等
text：存储数据时候，会自动分词，并生成索引
keyword：存储数据时候，不会分词建立索引
Numerical：数值类型，分两类
基本数据类型：long、interger、short、byte、double、float、half_float
浮点数的高精度类型：scaled_float
需要指定一个精度因子，比如10或100。
elasticsearch会把真实值乘以这个因子后存储，取出时再还原。
Date：日期类型
elasticsearch可以对日期格式化为字符串存储，
但是建议我们存储为毫秒值，存储为long，节省空间。
index：是否索引，布尔类型，默认是true
store：是否存储，布尔类型，默认是false
analyzer：分词器名称，这里的ik_max_word即使用ik分词器entity示例
package org.fiend.entity;
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;
/**
* @author langpf 2019/2/27
*/
// indexName索引名称 可以理解为数据库名 必须为小写,
// 不然会报org.elasticsearch.indices.InvalidIndexNameException异常
// type类型 可以理解为表名
@Document(indexName = "item", type = "docs", shards = 1, replicas = 0)
public class Item {
/**
* 注: 该注解是必填项
* @Description: @Id注解必须是springframework包下的
* org.springframework.data.annotation.Id
* @Author:
*/
@Id
private Long id;
@Field(type = FieldType.Text, analyzer = "ik_max_word")
private String title; //标题
@Field(type = FieldType.Keyword)
private String category;// 分类
@Field(type = FieldType.Keyword)
private String brand; // 品牌
@Field(type = FieldType.Double)
private Double price; // 价格
@Field(index = false, type = FieldType.Keyword)
private String images; // 图片地址
public Item(Long id, String title, String category,
String brand, Double price, String images) {
this.id = id;
this.title = title;
this.category = category;
this.brand = brand;
this.price = price;
this.images = images;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
public String getImages() {
return images;
}
public void setImages(String images) {
this.images = images;
}
}4. repository配置
package org.fiend.repository;
import org.fiend.entity.Item;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author langpf 2019/2/27
*/
@Component
// <ItemEntity, Long>: ItemEntity的@Id所注解的数据项的数据类型, 必须与Long一致,
// 即ItemEntity的@Id如果是String类型, 这里的Long就变为String
public interface ItemRepository extends ElasticsearchRepository<Item, Long> {
/**
* @Description:根据价格区间查询
* @Param price1
* @Param price2
* @Author:
*/
List<Item> findByPriceBetween(double price1, double price2);
}5. controller调用
ElasticsearchTemplate用来对索引的创建，删除，以及数据的插入，查询(包括按页查询)等。repository用来实现对数据的CRUD操作
package org.fiend.controller;
import com.alibaba.fastjson.JSONObject;
import org.fiend.entity.Item;
import org.fiend.repository.ItemRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* @author Administrator
*/
@Controller
@RequestMapping(value = "item")
public class ItemController {
Logger log = LoggerFactory.getLogger(getClass());
@Autowired
private ElasticsearchTemplate elasticsearchTemplate;
@Autowired
private ItemRepository itemRepository;
/**
* 创建索引
*/
@GetMapping("createIndex")
public JSONObject createIndex(Object obj) {
JSONObject json = new JSONObject();
boolean result = elasticsearchTemplate.createIndex(obj.getClass());
json.put("result", result);
return json;
}
@GetMapping("insert")
public String insert() {
Item item = new Item(1L, "小米手机7", " 手机",
"小米", 3499.00, "http://image.baidu.com/13123.jpg");
itemRepository.save(item);
return "success";
}
//http://localhost:8888/delete?id=1525415333329
@GetMapping("delete")
public String delete(long id) {
itemRepository.deleteById(id);
return "success";
}
/**
* elasticsearch中本没有修改，它的修改原理是该是先删除在新增
* 修改和新增是同一个接口，区分的依据就是id。
*/
//http://localhost:8888/update?id=1525417362754&name=修改&description=修改
@GetMapping("update")
public String update(Long id, String title, String category, String brand, Double price, String images) {
Item item = new Item(id, title, category, brand, price, images);
itemRepository.save(item);
return "success";
}
/**
* 查找所有
*/
@GetMapping("findAll")
public List<Item> findAll() {
// 查找所有
// Iterable<Item> list = this.itemRepository.findAll();
// 对某字段排序查找所有 Sort.by("price").descending() 降序
// Sort.by("price").ascending(): 升序
Iterable<Item> iterable = itemRepository.findAll(Sort.by("price").ascending();
List<Item> list = Lists.newArrayList(iterable);
return list;
}
}6. repository自定义方法
Spring Data 的另一个强大功能，是根据方法名称自动实现功能。
比如：你的方法名叫做：findByTitle，那么它就知道你是根据title查询，然后自动帮你完成，无需写实现类。
当然，方法名称要符合一定的约定：
Keyword | Sample |
And | findNameAndPrice |
Or | findByNameOrPrice |
Is | findByName |
Not | findByNameNot |
Between | findByPriceBetween |
LessThanEqual | findByPriceLessThan |
GreaterThanEqual | findByPriceGreaterThan |
Before | findByPriceBefore |
After | findByPriceAfter |
Like | findByNameLike |
StartingWith | findByNameStartingWith |
EndingWith | findByNameEndingWith |
Contains/Containing | findByNameContaining |
In | findByNameIn(Collection<String>names) |
NotIn | findByNameNotIn(Collection<String>names) |
Near | findByStoreNear |
True | findByAvailableTrue |
False | findByAvailableFalse |
OrderBy | findByAvailableTrueOrderByNameDesc |
例如，按照价格区间查询，定义这样的一个方法：
public interface ItemRepository extends ElasticsearchRepository<Item,Long> {
/**
* @Description:根据价格区间查询
* @Param price1
* @Param price2
* @Author:
*/
List<Item> findByPriceBetween(double price1, double price2);
}添加一些测试数据：
@Autowired
private ItemRepository itemRepository;
/**
* @Description:准备测试数据
* @Author:
*/
@Test
public void insertList() {
List<Item> list = new ArrayList<>();
list.add(new Item(1L, "小米手机7", "手机", "小米", 3299.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(2L, "坚果手机R1", "手机", "锤子", 3699.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(3L, "华为META10", "手机", "华为", 4499.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(4L, "小米Mix2S", "手机", "小米", 4299.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(5L, "荣耀V10", "手机", "华为", 2799.00, "http://image.baidu.com/13123.jpg"));
// 接收对象集合，实现批量新增
itemRepository.saveAll(list);
}7. 其它查询方法--controller调用
/**
* 自定义查询: matchQuery
*/
@GetMapping("matchQuery")
public Page<Item> matchQuery() {
// 构建查询条件
// NativeSearchQueryBuilder：Spring提供的一个查询条件构建器, 帮助构建json格式的请求体
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 添加基本分词查询
// QueryBuilders.matchQuery(“title”, “小米手机”)：利用QueryBuilders来生成一个查询。
// QueryBuilders提供了大量的静态方法, 用于生成各种不同类型的查询：
queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米手机"));
// 搜索, 获取结果
// Page<item>：默认是分页查询, 因此返回的是一个分页的结果对象, 包含属性：
// totalElements：总条数
// totalPages：总页数
// Iterator：迭代器, 本身实现了Iterator接口, 因此可直接迭代得到当前页的数据
Page<Item> page = this.itemRepository.search(queryBuilder.build());
for (Item item : page) {
System.out.println(item);
}
// 总条数
long total = page.getTotalElements();
System.out.println("total = " + total);
// Iterator<Item> iterable = page.iterator();
return page;
}
/**
* 自定义查询: termQuery
* termQuery: 功能更强大, 除了匹配字符串以外, 还可以匹配 int/long/double/float/....
*/
@GetMapping("termQuery")
public Page<Item> termQuery() {
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
builder.withQuery(QueryBuilders.termQuery("price", 998.0));
// 查找
Page<Item> page = this.itemRepository.search(builder.build());
for (Item item : page) {
System.out.println(item);
}
return page;
}
/**
* 自定义查询: fuzzyQuery -- 模糊查询
*/
@GetMapping("fuzzyQuery")
public Page<Item> fuzzyQuery() {
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
builder.withQuery(QueryBuilders.fuzzyQuery("title", "faceoooo"));
Page<Item> page = this.itemRepository.search(builder.build());
for (Item item : page) {
System.out.println(item + "");
}
return page;
}
/**
* 分页查询
*/
@GetMapping("searchByPage")
public Page<Item> searchByPage() {
// 构建查询条件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 添加基本分词查询
queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
// 分页：
int pageNum = 0;
int size = 2;
queryBuilder.withPageable(PageRequest.of(pageNum, size));
// 搜索, 获取结果
Page<Item> page = this.itemRepository.search(queryBuilder.build());
// 总条数
long total = page.getTotalElements();
System.out.println("总条数 = " + total);
// 总页数
System.out.println("总页数 = " + page.getTotalPages());
// 当前页
System.out.println("当前页：" + page.getNumber());
// 每页大小
System.out.println("每页大小：" + page.getSize());
for (Item item : page) {
System.out.println(item);
}
return page;
}
/**
* 排序查询
*/
@GetMapping("searchAndSort")
public Page<Item> searchAndSort() {
// 构建查询条件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 添加基本分词查询
queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
// 排序
queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
// 搜索, 获取结果
Page<Item> page = this.itemRepository.search(queryBuilder.build());
// 总条数
long totalNum = page.getTotalElements();
System.out.println("总条数: " + totalNum);
// 总页数
System.out.println("总页数 = " + page.getTotalPages());
// 当前页
System.out.println("当前页： " + page.getNumber());
// 每页大小
System.out.println("每页大小：" + page.getSize());
for (Item item : page) {
System.out.println(item);
}
return page;
}
// 聚合查询:
// 比较常用的一些度量聚合方式:
// Avg Aggregation：求平均值
// Max Aggregation：求最大值
// Min Aggregation：求最小值
// Percentiles Aggregation：求百分比
// Stats Aggregation：同时返回avg、max、min、sum、count等
// Sum Aggregation：求和
// Top hits Aggregation：求前几
// Value Count Aggregation：求总数
// ……
/**
* Elasticsearch中的聚合, 包含多种类型, 最常用的两种, 一个叫桶, 一个叫度量：
* 聚合查询: 聚合为桶 -- 查询
* aggregation bucket 查询
*/
@GetMapping("aggBucketSearch")
public AggregatedPage<Item> aggBucketSearch() {
// 构建查询条件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 不查询任何结果
queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
// 1、添加一个新的聚合, 聚合类型为terms, 聚合名称为brands, 聚合字段为brand
// AggregationBuilders：聚合的构建工厂类, 所有聚合都由这个类来构建
queryBuilder.addAggregation(AggregationBuilders.terms("brands").field("brand"));
// 2、查询, 需要把结果强转为AggregatedPage类型
AggregatedPage<Item> aggPage = (AggregatedPage<Item>)
this.itemRepository.search(queryBuilder.build());
// 3 解析
// 3.1 从结果中取出名为brands的那个聚合,
// 因为是利用String类型字段来进行的term聚合, 所以结果要强转为StringTerm类型
StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
// 3.2、获取桶
List<StringTerms.Bucket> buckets = agg.getBuckets();
// 3.3、遍历
for (StringTerms.Bucket bucket : buckets) {
// 3.4、获取桶中的key, 即品牌名称
System.out.println(bucket.getKeyAsString());
// 3.5、获取桶中的文档数量
System.out.println(bucket.getDocCount());
}
return aggPage;
}
// （1）统计某个字段的数量
// ValueCountBuilder vcb= AggregationBuilders.count("count_uid").field("uid");
// （2）去重统计某个字段的数量（有少量误差）
// CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
// （3）聚合过滤
// FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter")
// .filter(QueryBuilders.queryStringQuery("uid:001"));
// （4）按某个字段分组
// TermsBuilder tb= AggregationBuilders.terms("group_name").field("name");
// （5）求和
// SumBuilder sumBuilder= AggregationBuilders.sum("sum_price").field("price");
// （6）求平均
// AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
// （7）求最大值
// MaxBuilder mb= AggregationBuilders.max("max_price").field("price");
// （8）求最小值
// MinBuilder min= AggregationBuilders.min("min_price").field("price");
// （9）按日期间隔分组
// DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
// （10）获取聚合里面的结果
// TopHitsBuilder thb= AggregationBuilders.topHits("top_result");
// （11）嵌套的聚合
// NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
// （12）反转嵌套
// AggregationBuilders.reverseNested("res_negsted").path("kps ");
/**
* 聚合查询: 嵌套聚合, 求平均值
*/
@GetMapping("aggSubSearch")
public AggregatedPage<Item> aggSubSearch() {
// 构建查询条件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 不查询任何结果
queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
// 1、添加一个新的聚合, 聚合类型为terms, 聚合名称为brands, 聚合字段为brand
queryBuilder.addAggregation(AggregationBuilders.terms("brands").field("brand")
// 在品牌聚合桶内进行嵌套聚合, 求平均值
.subAggregation(AggregationBuilders.avg("priceAvg").field("price")));
// 2、查询,需要把结果强转为AggregatedPage类型
AggregatedPage<Item> aggPage = (AggregatedPage<Item>)
this.itemRepository.search(queryBuilder.build());
// 3 解析
// 3.1 从结果中取出名为brands的那个聚合,
// 因为是利用String类型字段来进行的term聚合, 所以结果要强转为StringTerm类型
StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
// 3.2、获取桶
List<StringTerms.Bucket> buckets = agg.getBuckets();
// 3.3、遍历
for (StringTerms.Bucket bucket : buckets) {
// 3.4、获取桶中的key, 即品牌名称 3.5、获取桶中的文档数量
System.out.println(bucket.getKeyAsString() + ", 共" + bucket.getDocCount() + "台");
// 3.6.获取子聚合结果：
InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
System.out.println("平均售价：" + avg.getValue());
}
return aggPage;
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
