微服务入门（二）JSR303、Elasticsearch
JSR303 数据校验
javax.validation.constraints 中定义了非常多的校验注解，@Email、 @Future、 @NotBlank、 @Size 等，BindingResult 获取校验结果，
给Bean添加校验注解:javax.validation.constraints，并定义自己的message提示
比如
@NotBlank(message = "品牌名必须提交")
private String name;
开启校验功能@Valid，给校验的bean后紧跟一个BindingResult，就可以获取到校验的结果
public R save(@Valid @RequestBody BrandEntity brand,BindingResult result){
这个需要自己处理错误逻辑
// if(result.hasErrors()){
// Map map = new HashMap<>();
// //1、获取校验的错误结果
// result.getFieldErrors().forEach((item)->{
// //FieldError 获取到错误提示
// String message = item.getDefaultMessage();
// //获取错误的属性的名字
// String field = item.getField();
// map.put(field,message);
// });
//
// return R.error(400,"提交的数据不合法").put("data",map);
// }else {
//
// }
可以写一个统一的异常处理，编写异常处理类，使用@ControllerAdvice，使用@ExceptionHandler标注方法可以处理的异常。
/**
* 集中处理所有异常
*/
@Slf4j
//@ResponseBody
//@ControllerAdvice(basePackages = "com.atguigu.gulimall.product.controller")
@RestControllerAdvice(basePackages = "com.atguigu.gulimall.product.controller")
public class GulimallExceptionControllerAdvice {
@ExceptionHandler(value= MethodArgumentNotValidException.class)
public R handleVaildException(MethodArgumentNotValidException e){
log.error("数据校验出现问题{}，异常类型：{}",e.getMessage(),e.getClass());
BindingResult bindingResult = e.getBindingResult();
Map<String,String> errorMap = new HashMap<>();
bindingResult.getFieldErrors().forEach((fieldError)->{
errorMap.put(fieldError.getField(),fieldError.getDefaultMessage());
});
return R.error(BizCodeEnume.VAILD_EXCEPTION.getCode(),BizCodeEnume.VAILD_EXCEPTION.getMsg()).put("data",errorMap);
}
@ExceptionHandler(value = Throwable.class)
public R handleException(Throwable throwable){
log.error("错误：",throwable);
return R.error(BizCodeEnume.UNKNOW_EXCEPTION.getCode(),BizCodeEnume.UNKNOW_EXCEPTION.getMsg());
}
}
/***
* 错误码和错误信息定义类
* 1. 错误码定义规则为5为数字
* 2. 前两位表示业务场景，最后三位表示错误码。例如：100001。10:通用 001:系统未知异常
* 3. 维护错误码后需要维护错误描述，将他们定义为枚举形式
* 错误码列表：
* 10: 通用
* 001：参数格式校验
* 11: 商品
* 12: 订单
* 13: 购物车
* 14: 物流
*
*
*/
public enum BizCodeEnume {
UNKNOW_EXCEPTION(10000,"系统未知异常"),
VAILD_EXCEPTION(10001,"参数格式校验失败");
private int code;
private String msg;
BizCodeEnume(int code,String msg){
this.code = code;
this.msg = msg;
}
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
}
在@RestControllerAdvice中标注的包里的文件，都能使用这个异常，把BindingResult result去掉就可以了
public R save(@Valid @RequestBody BrandEntity brand){
对于多场景的复杂校验，比如新增需要校验，更新不需要校验的情况，需要分组
1)、 @NotBlank(message = “品牌名必须提交”,groups = {AddGroup.class,UpdateGroup.class})， 给校验注解标注什么情况需要进行校验
AddGroup和UpdateGroup是两个接口，
public interface AddGroup {
}
public interface UpdateGroup {
}
/**
* 品牌id
*/
@NotNull(message = "修改必须指定品牌id",groups = {
UpdateGroup.class})
@Null(message = "新增不能指定id",groups = {
AddGroup.class})
@TableId
private Long brandId;
/**
* 品牌名
*/
@NotBlank(message = "品牌名必须提交",groups = {
AddGroup.class,UpdateGroup.class})
private String name;
/**
* 品牌logo地址
*/
@NotBlank(groups = {
AddGroup.class})
@URL(message = "logo必须是一个合法的url地址",groups={
AddGroup.class,UpdateGroup.class})
private String logo;
校验的controller里也增加分组
public R save(@Validated({
AddGroup.class}) @RequestBody BrandEntity brand/*,BindingResult result*/){
默认没有指定分组的校验注解@NotBlank，在分组校验情况@Validated({AddGroup.class})下不生效，只会在@Validated生效；
也可以自定义校验，首先编写一个自定义的校验注解，然后编写一个自定义的校验器 ConstraintValidator，最后关联自定义的校验器和自定义的校验注解
@Documented
@Constraint(validatedBy = {
ListValueConstraintValidator.class })
@Target({
METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
public @interface ListValue {
String message() default "{com.atguigu.common.valid.ListValue.message}";
Class<?>[] groups() default {
};
Class<? extends Payload>[] payload() default {
};
int[] vals() default {
};
}
public class ListValueConstraintValidator implements ConstraintValidator<ListValue,Integer> {
private Set<Integer> set = new HashSet<>();
//初始化方法
@Override
public void initialize(ListValue constraintAnnotation) {
int[] vals = constraintAnnotation.vals();
for (int val : vals) {
set.add(val);
}
}
//判断是否校验成功
/**
*
* @param value 需要校验的值
* @param context
* @return
*/
@Override
public boolean isValid(Integer value, ConstraintValidatorContext context) {
return set.contains(value);
}
}
使用
@NotNull(groups = {
AddGroup.class})
@ListValue(vals={
0,1},groups = {
AddGroup.class})
private Integer showStatus;
可以自定义错误信息，在resouces文件夹下，新建ValidationMessages.properties
com.atguigu.common.valid.ListValue.message=必须提交指定的值
目录结构
统一结果返回类
规范每个接口返回数据的格式
public class R extends HashMap<String, Object> {
private static final long serialVersionUID = 1L;
//利用fastJson进行逆转
public <T>T getData(TypeReference<T> typeReference){
Object data = get("data");//默认map
String s = JSON.toJSONString(data);
T t = JSON.parseObject(s, typeReference);
return t;
}
public R setData(Object data){
put("data",data);
return this;
}
//利用fastJson进行逆转
public <T>T getData2(String key,TypeReference<T> typeReference){
Object data = get(key);//默认map
String s = JSON.toJSONString(data);
T t = JSON.parseObject(s, typeReference);
return t;
}
public R() {
put("code", 0);
put("msg", "success");
}
public static R error() {
return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
}
public static R error(String msg) {
return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
}
public static R error(int code, String msg) {
R r = new R();
r.put("code", code);
r.put("msg", msg);
return r;
}
public static R ok(String msg) {
R r = new R();
r.put("msg", msg);
return r;
}
public static R ok(Map<String, Object> map) {
R r = new R();
r.putAll(map);
return r;
}
public static R ok() {
return new R();
}
public R put(String key, Object value) {
super.put(key, value);
return this;
}
public Integer getCode() {
return (Integer) this.get("code");
}
}
使用
1. return R.ok().put("page", page);
2.OrderEntity orderEntity = orderService.getOrderByOrderSn(orderSn);
return R.ok().setData(orderEntity);
3. FareVo data = fare.getData(new TypeReference<FareVo>() {
});
4. MemberAddressVo data = r.getData2("memberReceiveAddress",new TypeReference<MemberAddressVo>() {
});
Elasticsearch
全文检索使用Elasticsearch，它可以快速地储存、 搜索和分析海量数据。Elastic 是 Lucene 的封装， 提供了 REST API 的操作接口， 开箱即用。
REST API： 天然的跨平台。
官方文档
基本概念
Index（索引）
动词， 相当于 MySQL 中的 insert；
名词， 相当于 MySQL 中的 Database
Type（类型）
在 Index（索引） 中， 可以定义一个或多个类型。
类似于 MySQL 中的 Table； 每一种类型的数据放在一起；
Document（文档）
保存在某个索引（Index） 下， 某种类型（Type） 的一个数据（Document） ， 文档是 JSON 格式的， Document 就像是 MySQL 中的某个 Table 里面的内容；
搜索速度快主要是因为使用了倒排索引机制
安装
我这边没办法使用linux，所以没办法使用docker安装，分享一下win7安装Elasticsearch。Windows上安装ElasticSearch7
安装完成以后，http://localhost:9200/，显示
说明Elasticsearch运行成功，访问http://localhost:9100/，
说明elasticsearch-head-master运行成功，使用postman可以访问
为了和教程保持一致，准备使用kibana，刚开始下载的最新版7.15.0，结果打开就闪退，可能是版本太高，最后下载了6.8.1，解压以后，点击bin目录下的kibana.bat启动，如果启动页面是这样，说明已启动
访问http://localhost:5601/app/kibana，
在Dev tools页面测试
初步检索
1、 _cat
GET /_cat/nodes： 查看所有节点
GET /_cat/health： 查看 es 健康状况
GET /_cat/master： 查看主节点
GET /_cat/indices： 查看所有索引 show databases;
2、 索引一个文档（保存）
保存一个数据， 保存在哪个索引的哪个类型下， 指定用哪个唯一标识
PUT customer/external/1； 在 customer 索引下的 external 类型下保存 1 号数据为
PUT customer/external/1
PUT 和 POST 都可以，
POST 新增。 如果不指定 id， 会自动生成 id。 指定 id 就会修改这个数据， 并新增版本号
PUT 可以新增可以修改。 PUT 必须指定 id； 由于 PUT 需要指定 id， 我们一般都用来做修改操作， 不指定 id 会报错
3、 查询文档
GET customer/external/1
{
"_index": "customer", //在哪个索引
"_type": "external", //在哪个类型
"_id": "1", //记录 id
"_version": 1, //版本号
"_seq_no": 0, //并发控制字段， 每次更新就会+1， 用来做乐观锁
"_primary_term": 1, //同上， 主分片重新分配， 如重启， 就会变化
"found": true,
"_source": {
//真正的内容
"name": "John Doe"
}
}
乐观锁
进行修改，需要带上if_primary_term和_seq_no，来判断是否能更改，?if_seq_no=0&if_primary_term=1，如果符合则更改成功，如果不符合，已经在提交之前，被其他人修改过，会报错
4、 更新文档
POST customer/external/1/_update
{
"doc":{
"name": "John Doew"
}
}
带_update 对比元数据如果一样就不进行任何操作。我这是提交了两次，第二次就出现这个结果，带_update，提交数据必须带"doc"
或者
POST customer/external/1
{
"name": "John Doe2"
}
不带_update，可以一直提交post更新，版本会增加
或者
PUT customer/external/1
{
"name": "John Doe"
}
修改数据，版本号也会一直增加
put和post(不带_update)，会一直更新，如果带_update 对比元数据如果一样就不进行任何操作。
看场景；
对于大并发更新， 不带 update；
对于大并发查询偶尔更新， 带 update； 对比更新， 重新计算分配规则。
更新同时增加属性
POST customer/external/1/_update
{
"doc": {
"name": "Jane Doe", "age": 20 }
}
PUT 和 POST 不带_update 也可以
5、 删除文档&索引
DELETE customer/external/1
DELETE customer
6、批量导入数据
使用bulk可以批量导入数据
POST customer/external/_bulk
{
"index":{
"_id":"1"}}
{
"name": "John Doe" }
{
"index":{
"_id":"2"}}
{
"name": "Jane Doe" }
语法
{
action: {
metadata }}\n
{
request body }\n
{
action: {
metadata }}\n
{
request body }\n
{
"index":{
"_id":"1"}}
{
"name": "John Doe" }
这两句属于一个操作，给新增数据指定id，保存数据位name
在kibana上测试，postman不能测试，
复杂实例
POST /_bulk
{
"delete": {
"_index": "website", "_type": "blog", "_id": "123" }}
{
"create": {
"_index": "website", "_type": "blog", "_id": "123" }}
{
"title": "My first blog post" }
{
"index": {
"_index": "website", "_type": "blog" }}
{
"title": "My second blog post" }
{
"update": {
"_index": "website", "_type": "blog", "_id": "123"} }
{
"doc" : {
"title" : "My updated blog post"} }
批量导入测试数据，可以从
accounts.json获取，
通过postman查询一下，发现已经有了bank的数据
进阶检索
1、 SearchAPI
ES 支持两种基本方式检索 :
1、一个是通过使用 REST request URI 发送搜索参数（uri+检索参数）
2、另一个是通过使用 REST request body 来发送它们（uri+请求体）
1） 、 检索信息
一切检索从_search 开始
请求参数方式检索
GET bank/_search?q=*&sort=account_number:asc
响应结果解释：
took - Elasticsearch 执行搜索的时间（ 毫秒）
time_out - 告诉我们搜索是否超时
_shards - 告诉我们多少个分片被搜索了， 以及统计了成功/失败的搜索分片
hits - 搜索结果
hits.total - 搜索结果
hits.hits - 实际的搜索结果数组（ 默认为前 10 的文档）
sort - 结果的排序 key（ 键） （ 没有则按 score 排序）
score 和 max_score –相关性得分和最高得分（ 全文检索用）
第二种方式，uri+请求体进行检索
GET bank/_search
{
"query": {
"match_all": {
}
},
"sort": [
{
"account_number": "asc"
},
{
"balance": "desc"
}
]
}
这种语法就是Query DSL
Query DSL
Elasticsearch 提供了一个可以执行查询的 Json 风格的 DSL（ domain-specific language 领域特定语言） 。 这个被称为 Query DSL。
一个查询语句 的典型结构
{
QUERY_NAME: {
ARGUMENT: VALUE,
ARGUMENT: VALUE,...
}
}
如果是针对某个字段， 那么它的结构如下：
{
QUERY_NAME: {
FIELD_NAME: {
ARGUMENT: VALUE,
ARGUMENT: VALUE,...
}
}
}
比如
GET bank/_search
{
"query": {
"match_all": {
}
},
"from": 0,
"size": 5,
"sort": [
{
"account_number": {
"order": "desc"
}
}
]
}
query 定义如何查询，
1. match_all 查询类型【代表查询所有的所有】 ， es 中可以在 query 中组合非常多的查询类型完成复杂查询
2.除了 query 参数之外， 我们也可以传递其它的参数以改变查询结果。 如 sort， size
3.from+size 限定， 完成分页功能
4.sort 排序， 多字段排序， 会在前序字段相等时后续字段内部排序， 否则以前序为准
返回部分字段
通过"_source": 可以指定返回的部分字段
GET bank/_search
{
"query": {
"match_all": {
}
},
"from": 0,
"size": 5,
"_source": ["age","balance"]
}
match【 匹配查询】
可以使用match来进行匹配，作为查询条件，基本类型是全局匹配，字符串就是全局检索了
GET bank/_search
{
"query": {
"match": {
"account_number": "20"
}
}
}
GET bank/_search
{
"query": {
"match": {
"address": "Mill Avenue"
}
}
}
最终查询出 address 中包含 Mill 或者 Avenue或者 Mill Avenue的所有记录， 并给出相关性得分，分数高的匹配最高，就是之前说的倒排索引。
match_phrase【 短语匹配】
把match换成match_phrase就会将需要匹配的值当成一个整体单词（ 不分词） 进行检索
multi_match【 多字段匹配】
GET bank/_search
{
"query": {
"multi_match": {
"query": "mill",
"fields": ["state","address"]
}
}
}
这个会查询出state 或者 address 包含 mill的数据
bool【 复合查询】
复合语句可以合并 任何 其它查询语句， 包括复合语句， 复合语句之间可以互相嵌套， 可以表达非常复杂的逻辑。
must： 必须达到 must 列举的所有条件
GET bank/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"address": "mill" } },
{
"match": {
"gender": "M" } }
]
}
}
}
匹配address包含mill和gender为M的数据
must_not 必须不是指定的情况
GET bank/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"address": "mill" } },
{
"match": {
"gender": "M" } }
],
"should": [
{
"match": {
"address": "lane" }}
],
"must_not": [
{
"match": {
"email": "baluba.com" }}
]
}
}
}
这里边有个should，应该达到 should 列举的条件， 如果达到会增加相关文档的评分， 并不会改变查询的结果。 如果 query 中只有 should 且只有一种匹配规则， 那么 should 的条件就会被作为默认匹配条件而去改变查询结果
filter【结果过滤】
并不是所有的查询都需要产生分数， 特别是那些仅用于 “filtering”（过滤） 的文档。 为了不计算分数 Elasticsearch 会自动检查场景并且优化查询的执行
GET bank/_search
{
"query": {
"bool": {
"filter": {
"range": {
"balance": {
"gte": 10000,
"lte": 20000
}
}
}
}
}
}
也可以与must组合使用，对结果进行过滤
GET bank/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"address": "mill"}}
],
"filter": {
"range": {
"balance": {
"gte": 10000,
"lte": 20000
}
}
}
}
}
}
term
和 match 一样。 匹配某个属性的值。 全文检索字段用 match， 其他非 text 字段匹配用 term
GET bank/_search
{
"query": {
"bool": {
"must": [
{
"term": {
"age": {
"value": "28"
}
}},
{
"match": {
"address": "990 Mill Road"
}}
]
}
}
}
精确匹配
查询字段加上keyword，就可以精确匹配
GET bank/_search
{
"query": {
"match": {
"address.keyword": "990 Mill Road"
}
}
}
aggregations（ 执行聚合）
聚合提供了从数据中分组和提取数据的能力。 最简单的聚合方法大致等于 SQL GROUP BY 和 SQL 聚合函数。 在 Elasticsearch 中， 您有执行搜索返回 hits（ 命中结果） ， 并且同时返回聚合结果， 把一个响应中的所有 hits（ 命中结果） 分隔开的能力。 这是非常强大且有效的，您可以执行查询和多个聚合， 并且在一次使用中得到各自的（ 任何一个的） 返回结果， 使用一次简洁和简化的 API 来避免网络往返
1.搜索 address 中包含 mill 的所有人的年龄分布以及平均年龄， 但不显示这些人的详情。
GET bank/_search
{
"query": {
"match": {
"address": "mill"
}
},
"aggs": {
"group_by_state": {
"terms": {
"field": "age"
}
},
"avg_age": {
"avg": {
"field": "age"
}
}
},
"size": 0
}
size： 0 不显示搜索数据
aggs： 执行聚合。 聚合语法如下
"aggs": {
"aggs_name 这次聚合的名字， 方便展示在结果集中": {
"AGG_TYPE 聚合的类型（ avg,term,terms） ": {
}
}
},
2.按照年龄聚合， 并且请求这些年龄段的这些人的平均薪资
GET bank/account/_search
{
"query": {
"match_all": {
}
},
"aggs": {
"age_avg": {
"terms": {
"field": "age",
"size": 100
},
"aggs": {
"banlances_avg": {
"avg": {
"field": "balance"
}
}
}
}
},
"size": 100
}
复杂： 查出所有年龄分布， 并且这些年龄段中 M 的平均薪资和 F 的平均薪资以及这个年龄段的总体平均薪资
GET bank/account/_search
{
"query": {
"match_all": {
}
},
"aggs": {
"age_agg": {
"terms": {
"field": "age",
"size": 100
},
"aggs": {
"gender_agg": {
"terms": {
"field": "gender.keyword",
"size": 100
},
"aggs": {
"balance_avg": {
"avg": {
"field": "balance"
}
}
}
},
"balance_avg": {
"avg": {
"field": "balance"
}
}
}
}
},
"size": 1000
}
Mapping（映射）
Mapping 是用来定义一个文档（ document） ， 以及它所包含的属性（ field） 是如何存储和索引的，比如， 使用 mapping 来定义：
1.哪些字符串属性应该被看做全文本属性（full text fields） 。
2. 哪些属性包含数字， 日期或者地理位置。
3. 文档中的所有属性是否都能被索引（_all 配置） 。
4.日期的格式。
5. 自定义映射规则来执行动态添加属性
新建的时候会猜测数据类型，比如
如果要修改数据类型，可以使用
PUT /my-index
{
"mappings": {
"properties": {
"age": {
"type": "integer" },
"email": {
"type": "keyword" },
"name": {
"type": "text" }
}
}
}
然后使用GET my-index/_mapping 查看
如果对现有索引添加新字段，需要使用
PUT /my-index/_mapping
{
"properties": {
"employee-id": {
"type": "keyword",
"index": false
}
}
}
“index”: false设置这个字段不能被索引，不被索引就不会被检索到
对于已经存在的映射字段， 我们不能更新。 更新必须创建新的索引进行数据迁移。
数据迁移
通过GET my-index/_mapping ，查看my-index里的字段类型，
然后新建一个new_my-index，修改里边的字段类型，比如修改age为type
PUT /new_my-index
{
"mappings": {
"properties": {
"age": {
"type": "long"
},
"email": {
"type": "keyword"
},
"name": {
"type": "text"
},
"employee-id": {
"type": "keyword"
}
}
}
}
然后查看，
然后数据迁移
POST _reindex
{
"source": {
"index": "my-index"
},
"dest": {
"index": "new_my-index"
}
}
分词
一个 tokenizer（ 分词器） 接收一个字符流， 将之分割为独立的 tokens（ 词元， 通常是独立的单词） ， 然后输出 tokens 流
使用ik分词器，IK分词器的安装与使用IK分词器创建索引
使用默认分词器
POST _analyze
{
"text": "我是中国人"
}
使用分词器
POST _analyze
{
"analyzer": "ik_smart",
"text": "我是中国人"
}
使用另一个分词器：ik_max_word
POST _analyze
{
"analyzer": "ik_max_word",
"text": "我是中国人"
}
Elasticsearch-Rest-Client
Elasticsearch与spring boot整合，需要整合Elasticsearch-Rest-Client，官方文档
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.4.2</version>
</dependency>
配置
@Bean
RestHighLevelClient client() {
RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.56.10", 9200,
"http"));
return new RestHighLevelClient(builder);
}
测试
@Test
void test1() throws IOException {
Product product = new Product();
product.setSpuName("华为");
product.setId(10L);
IndexRequest request = new IndexRequest("product").id("20")
.source("spuName","华为","id",20L);
try {
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
System.out.println(request.toString());IndexResponse response2 = client.index(request, RequestOptions.DEFAULT);
} catch (ElasticsearchException e) {
if (e.status() == RestStatus.CONFLICT) {
}
}
}
spring boot与es的实战
商品上架和搜索功能，es对应的mapping
PUT gulimall_product
{
"mappings": {
"properties": {
"skuId": {
"type": "long"
},
"spuId": {
"type": "keyword"
},
"skuTitle": {
"type": "text",
"analyzer": "ik_smart"
},
"skuPrice": {
"type": "keyword"
},
"skuImg": {
"type": "keyword",
"index": false,
"doc_values": false
},
"saleCount": {
"type": "long"
},
"hasStock": {
"type": "boolean"
},
"hotScore": {
"type": "long"
},
"brandId": {
"type": "long"
},
"catalogId": {
"type": "long"
},
"brandName": {
"type": "keyword",
"index": false,
"doc_values": false
},
"brandImg": {
"type": "keyword",
"index": false,
"doc_values": false
},
"catalogName": {
"type": "keyword",
"index": false,
"doc_values": false
},
"attrs": {
"type": "nested",
"properties": {
"attrId": {
"type": "long"
},
"attrName": {
"type": "keyword",
"index": false,
"doc_values": false
},
"attrValue": {
"type": "keyword"
}
}
}
}
}
}
项目结构
对应代码
@Configuration
public class GulimallElasticSearchConfig {
//全局通用设置项,单实例singleton,构建授权请求头,异步等信息
public static final RequestOptions COMMON_OPTIONS;
static {
RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
// builder.addHeader("Authorization","Bearer"+TOKEN);
// builder.setHttpAsyncResponseConsumerFactory(
// new HttpAsyncResponseConsumerFactory.HeapBufferedResponseConsumerFactory(30*1024*1024*1024));
COMMON_OPTIONS = builder.build();
}
@Bean
public RestHighLevelClient esRestClient() {
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost("192.168.56.10", 9200, "http")));
return client;
}
}
EsConstant.java
public class EsConstant {
public static final String PRODUCT_INDEX = "gulimall_product";//sku数据在es中的索引
public static final Integer PRODUCT_PAGESIZE = 16;//每页显示数量
}
ElasticSearchSaveController.java 商品上架功能，把数据上传到es
@Slf4j
@RequestMapping("/search/save")
@RestController
public class ElasticSearchSaveController {
@Autowired
private ProductSaveService productSaveService;
@PostMapping("/product")
public R productStatusUp(@RequestBody List<SkuEsModel> skuEsModels) {
boolean b = false;
try {
b = productSaveService.productStatusUp(skuEsModels);
} catch (Exception e) {
log.error("ElasticSaveController商品上架错误:{}", e);
}
if (!b) {
return R.ok();
} else {
return R.error(BizCodeEnume.PRODUCT_UP_EXCEPTION.getCode(), BizCodeEnume.PRODUCT_UP_EXCEPTION.getMsg());
}
}
}
ProductSaveServiceImpl .java
@Slf4j
@Service
public class ProductSaveServiceImpl implements ProductSaveService {
@Autowired
RestHighLevelClient restHighLevelClient;
@Override
public boolean productStatusUp(List<SkuEsModel> skuEsModels) throws IOException {
//保存到es
//1.给es建立索引product(在Kibana中操作!)
//2.给es保存数据
BulkRequest bulkRequest = new BulkRequest();
for (SkuEsModel model : skuEsModels) {
//构造保存请求
IndexRequest indexRequest = new IndexRequest(EsConstant.PRODUCT_INDEX);
indexRequest.id(model.getSkuId().toString());
String s = JSON.toJSONString(model);
indexRequest.source(s, XContentType.JSON);
bulkRequest.add(indexRequest);
}
BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
//TODO 批量处理错误
boolean b = bulk.hasFailures();
List<String> collect = Arrays.stream(bulk.getItems()).map(item -> {
return item.getId();
}).collect(Collectors.toList());
log.info("商品上架完成:{},返回数据:{},",collect,bulk.toString());
return b;
}
}
SearchController.java 商品检索功能，太多业务逻辑代码，重点看关于es的操作
@Controller
public class SearchController {
@Autowired
MallSearchService mallSearchService;
@GetMapping("/list.html")
public String lisgPage(SearchParamVo paramVo, Model model, HttpServletRequest request){
//根据页面传递的数据查询参数，去es中检索商品
String queryString = request.getQueryString();
paramVo.set_queryString(queryString);
SearchResult reslut = mallSearchService.search(paramVo);
model.addAttribute("result",reslut);
return "list";
}
}
MallSearchServiceImpl.java
@Service
public class MallSearchServiceImpl implements MallSearchService {
@Autowired
private RestHighLevelClient client;
@Autowired
ProductFeignService productFeignService;
@Override
public SearchResult search(SearchParamVo paramVo) {
//1.动态构建出查询需要的DSL语句
SearchResult result = null;
//准备检索请求
SearchRequest searchRequest = buildSearchRequest(paramVo);
try {
//执行检索请求
SearchResponse response = client.search(searchRequest, GulimallElasticSearchConfig.COMMON_OPTIONS);
//分析封装响应数据
result = buildSearchResult(response, paramVo);
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
/**
* 准备检索请求:
* 模糊匹配，过滤(按照属性，分类，品牌，价格区间，库存),排序，分类，高亮，聚合分析
*
* @return
*/
private SearchRequest buildSearchRequest(SearchParamVo paramVo) {
//构建DSL语句
SearchSourceBuilder builder = new SearchSourceBuilder();
//查询:模糊匹配，过滤(按照属性，分类，品牌，价格区间，库存)
//1.构建bool - query
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//1.1 must - 模糊匹配
if (!StringUtils.isEmpty(paramVo.getKeyword())) {
boolQuery.must(QueryBuilders.matchQuery("skuTitle", paramVo.getKeyword()));
}
//1.2 bool - fitler 按照三级分类id查询
if (paramVo.getCatalog3Id() != null) {
boolQuery.filter(QueryBuilders.termQuery("catalogId", paramVo.getCatalog3Id()));
}
//1.2 bool - filter 按照品牌id查询
if (paramVo.getBrandId() != null && paramVo.getBrandId().size() > 0) {
boolQuery.filter(QueryBuilders.termsQuery("brandId", paramVo.getBrandId()));
}
//1.2 bool - filter 按照指定属性进行查询，嵌入式查询,ScoreMode相关性得分
if (paramVo.getAttrs() != null && paramVo.getAttrs().size() > 0) {
for (String attrStr : paramVo.getAttrs()) {
//attrs=1_5寸:8寸&attrs=2_16G:8G
BoolQueryBuilder nestedBoolQuery = QueryBuilders.boolQuery();
String[] s = attrStr.split("_");
String attrId = s[0];//属性id
String[] attrValues = s[1].split(":");//检索的属性值
nestedBoolQuery.must(QueryBuilders.termQuery("attrs.attrId", attrId));
nestedBoolQuery.must(QueryBuilders.termsQuery("attrs.attrValue", attrValues));
//每一个必须得生成一个nested查询
NestedQueryBuilder nestedQuery = QueryBuilders.nestedQuery("attrs", nestedBoolQuery, ScoreMode.None);
boolQuery.filter(nestedQuery);
}
}
//1.2 bool - filter 按照库存进行查询 todo
builder.query(QueryBuilders.termsQuery("hasStock", paramVo.getHasStock() == 1));
//1.2 bool - filter 按照价格区间
if (!StringUtils.isEmpty(paramVo.getSkuPrice())) {
//1_500/_500/500_
RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("skuPrice");
String[] s = paramVo.getSkuPrice().split("_");
BigDecimal bigDecimal1 = new BigDecimal(s[0]);
if (s.length == 2) {
//gte大于等于，lte小于等于，gt大于，lt小于
//区间
BigDecimal bigDecimal2 = new BigDecimal(s[1]);
rangeQuery.gte(bigDecimal1).lte(bigDecimal2);
} else if (s.length == 1) {
//大于
if (paramVo.getSkuPrice().startsWith("_")) {
rangeQuery.lte(bigDecimal1);
}
//小于
if (paramVo.getSkuPrice().endsWith("_")) {
rangeQuery.gte(bigDecimal1);
}
}
boolQuery.filter(rangeQuery);
}
builder.query(boolQuery);
//排序，分类，高亮
//2.1 排序
if (!StringUtils.isEmpty(paramVo.getSort())) {
//sort = skuPrice_asc/desc
String sort = paramVo.getSort();
String[] s = sort.split("_");
SortOrder order = s[1].equalsIgnoreCase("asc") ? SortOrder.ASC : SortOrder.DESC;
builder.sort(s[0], order);
}
//2.2 分页
//from = (pageNum-1)*pageSize
builder.from((paramVo.getPageNum() - 1) * EsConstant.PRODUCT_PAGESIZE);
builder.size(EsConstant.PRODUCT_PAGESIZE);
//2.3 高亮
if (!StringUtils.isEmpty(paramVo.getKeyword())) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.field("skuTitle");
highlightBuilder.preTags("");
highlightBuilder.postTags("");
builder.highlighter(highlightBuilder);
}
//聚合分析
//1.品牌聚合
TermsAggregationBuilder brand_agg = AggregationBuilders.terms("brand_agg");
brand_agg.field("brandId").size(50);
//1.1品牌聚合的子聚合
brand_agg.subAggregation(AggregationBuilders.terms("brand_name_agg").field("brandName").size(1));
brand_agg.subAggregation(AggregationBuilders.terms("brand_img_agg").field("brandImg").size(1));
builder.aggregation(brand_agg);
//2.分类聚合
TermsAggregationBuilder catalog_agg = AggregationBuilders.terms("catalog_agg").field("catalogId").size(20);
catalog_agg.subAggregation(AggregationBuilders.terms("catalog_name_agg").field("catalogName").size(1));
builder.aggregation(catalog_agg);
//3.属性聚合(嵌入式聚合)
NestedAggregationBuilder attr_agg = AggregationBuilders.nested("attr_agg", "attrs");
//聚合出当前所有的attr_id
TermsAggregationBuilder attr_id_agg = AggregationBuilders.terms("attr_id_agg").field("attrs.attrId");
//聚合分析当前attr_id对应的名字
attr_id_agg.subAggregation(AggregationBuilders.terms("attr_name_agg").field("attrs.attrName").size(1));
//聚合分析当前attr_id对应的所有可能的属性值attrValue
attr_id_agg.subAggregation(AggregationBuilders.terms("attr_value_agg").field("attrs.attrValue").size(50));
attr_agg.subAggregation(attr_id_agg);
builder.aggregation(attr_agg);
String s = builder.toString();
System.out.println("DSL:" + s);
SearchRequest searchRequest = new SearchRequest(new String[]{
EsConstant.PRODUCT_INDEX}, builder);
return searchRequest;
}
/**
* 分析封装检索结果
*
* @return
*/
private SearchResult buildSearchResult(SearchResponse response, SearchParamVo paramVo) {
SearchResult result = new SearchResult();
//1.返回所有查询到的商品
SearchHits hits = response.getHits();
List<SkuEsModel> esModelList = new ArrayList<>();
if (hits.getHits() != null && hits.getHits().length > 0) {
for (SearchHit hit : hits.getHits()) {
String sourceAsString = hit.getSourceAsString();
SkuEsModel skuEsModel = JSON.parseObject(sourceAsString, SkuEsModel.class);
if (!StringUtils.isEmpty(paramVo.getKeyword())) {
//设置高亮内容
HighlightField skuTitle = hit.getHighlightFields().get("skuTitle");
String string = skuTitle.getFragments()[0].string();
skuEsModel.setSkuTitle(string);
}
esModelList.add(skuEsModel);
}
}
result.setProducts(esModelList);
//2.当前所有商品涉及到的所有属性信息
List<SearchResult.AttrVo> attrVos = new ArrayList<>();
ParsedNested attr_agg = response.getAggregations().get("attr_agg");
ParsedLongTerms attr_id_agg = attr_agg.getAggregations().get("attr_id_agg");//根据返回值确定数据类ParsedLongTerms，ParsedNested
for (Terms.Bucket bucket : attr_id_agg.getBuckets()) {
SearchResult.AttrVo attrVo = new SearchResult.AttrVo();
//1.得到属性的id
long attrId = bucket.getKeyAsNumber().longValue();
//2.得到属性的名字
String attrName = ((ParsedStringTerms) bucket.getAggregations().get("attr_name_agg")).getBuckets().get(0).getKeyAsString();
//3.得到属性的所有值
List<String> attrValues = ((ParsedStringTerms) bucket.getAggregations().get("attr_value_agg")).getBuckets().stream().map(item -> {
String keyAsString = ((Terms.Bucket) item).getKeyAsString();
return keyAsString;
}).collect(Collectors.toList());
attrVo.setAttrId(attrId);
attrVo.setAttrName(attrName);
attrVo.setAttrValue(attrValues);
attrVos.add(attrVo);
}
result.setAttrs(attrVos);
//3.当前所有商品涉及到的所有品牌信息
List<SearchResult.BrandVo> brandVos = new ArrayList<>();
ParsedLongTerms brand_agg = response.getAggregations().get("brand_agg");
for (Terms.Bucket bucket : brand_agg.getBuckets()) {
SearchResult.BrandVo brandVo = new SearchResult.BrandVo();
//1.品牌id
long brandId = bucket.getKeyAsNumber().longValue();
//2.品牌名字
String brandName = ((ParsedStringTerms) bucket.getAggregations().get("brand_name_agg")).getBuckets().get(0).getKeyAsString();
//3.品牌图片
String brandImg = ((ParsedStringTerms) bucket.getAggregations().get("brand_img_agg")).getBuckets().get(0).getKeyAsString();
brandVo.setBrandId(brandId);
brandVo.setBrandName(brandName);
brandVo.setBrandImg(brandImg);
brandVos.add(brandVo);
}
result.setBrands(brandVos);
//4.当前所有商品涉及到的所有分类信息
ParsedLongTerms catalog_agg = response.getAggregations().get("catalog_agg");
List<SearchResult.CatalogVo> catalogVos = new ArrayList<>();
List<? extends Terms.Bucket> buckets = catalog_agg.getBuckets();
for (Terms.Bucket bucket : buckets) {
SearchResult.CatalogVo catalogVo = new SearchResult.CatalogVo();
//得到分类id
String keyAsString = bucket.getKeyAsString();
catalogVo.setCatalogId(Long.parseLong(keyAsString));
//得到分类名
ParsedStringTerms catalog_name_agg = bucket.getAggregations().get("catalog_name_agg");
String catalog_name = catalog_name_agg.getBuckets().get(0).getKeyAsString();
catalogVo.setCatalogName(catalog_name);
catalogVos.add(catalogVo);
}
result.setCatalogs(catalogVos);
//5.当前所有商品涉及到的所有分页信息
//页码
result.setPageNum(paramVo.getPageNum());
// result.setPageNum();
//总计录数
long total = hits.getTotalHits().value;
result.setTotal(total);
//总页码
Long totalPages = total % EsConstant.PRODUCT_PAGESIZE == 0 ? total / EsConstant.PRODUCT_PAGESIZE : (total / EsConstant.PRODUCT_PAGESIZE) + 1;
result.setTotalPage(totalPages);
List<Integer> pageNavs = new ArrayList<>();
for (int i = 1; i <= totalPages; i++) {
pageNavs.add(i);
}
result.setPageNavs(pageNavs);
//6.构建面包屑导航
if (paramVo.getAttrs() != null && paramVo.getAttrs().size() > 0) {
List<SearchResult.NavVo> collect = paramVo.getAttrs().stream().map(attr -> {
SearchResult.NavVo navVo = new SearchResult.NavVo();
//分析每个attr的参数值
String[] s = attr.split("_");
navVo.setNavValue(s[1]);
R r = productFeignService.attrInfo(Long.parseLong(s[0]));
result.getAttrIds().add(Long.parseLong(s[0]));
if (r.getCode() == 0) {
AttrResponseVo attrs = r.getData2("attr", new TypeReference<AttrResponseVo>() {
});
navVo.setNavName(attrs.getAttrName());
} else {
navVo.setNavName(s[0]);
}
String replace = replaceQueryString(paramVo, attr, "attrs");
navVo.setLink("http://search.gulimall.com/list.html?" + replace);
return navVo;
}).collect(Collectors.toList());
result.setNavs(collect);
}
//品牌、分类面包屑导航
if (paramVo.getBrandId() != null && paramVo.getBrandId().size() > 0) {
List<SearchResult.NavVo> navs = result.getNavs();
SearchResult.NavVo navVo = new SearchResult.NavVo();
navVo.setNavName("品牌");
//远程查询所有品牌
R r = productFeignService.brandsInfo(paramVo.getBrandId());
if (r.getCode() == 0) {
List<BrandVo> brands = r.getData2("brands", new TypeReference<List<BrandVo>>() {
});
StringBuffer buffer = new StringBuffer();
String replace = "";
for (BrandVo brandVo : brands){
buffer.append(brandVo.getName()+";");
replace = replaceQueryString(paramVo,brandVo.getBrandId()+"","brandId");
}
navVo.setNavValue(buffer.toString());
navVo.setLink("http://search.gulimall.com/list.html?" + replace);
}
navs.add(navVo);
}
return result;
}
//取消了面包屑之后,跳转的位置(将请求地址的url替换,置空)
private String replaceQueryString(SearchParamVo paramVo, String value, String key) {
String encode = null;
try {
//编码
encode = URLEncoder.encode(value, "UTF-8");
encode = encode.replace("+", "%20");//对空格特殊处理(将空格变为%20)
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return paramVo.get_queryString().replace("&" + key + "=" + encode, "");
}
}