Spring Cloud 是一系列框架的有序集合,它利用 Spring Boot 的开发便利性简化了分布式系统的开发,比如服务发现、服务网关、服务路由、链路追踪等。Spring Cloud 并不重复造轮子,而是将市面上开发得比较好的模块集成进去,进行封装,从而减少了各模块的开发成本。换句话说:Spring Cloud 提供了构建分布式系统所需的“全家桶”。
其核心思想是**将成熟的分布式组件进行统一封装与集成,提供开箱即用的“全家桶”式解决方案**,从而降低微服务架构的搭建、治理与维护成本。
1. 概述
Spring Cloud 是一系列框架的有序集合,它利用 Spring Boot 的开发便利性简化了分布式系统的开发。其核心思想是将成熟的分布式组件进行统一封装与集成,提供开箱即用的“全家桶”式解决方案,从而降低微服务架构的搭建、治理与维护成本。传统分布式系统需要自行拼装、配置和治理各类中间件,重复造轮子且运维成本高,而 Spring Cloud 通过标准化封装让开发者专注业务逻辑。
2. Nacos 服务注册与发现
Nacos 是 Spring Cloud Alibaba 提供的注册中心与配置中心,负责服务的注册、发现与统一配置管理。
1.1 下载与部署
需要从 Nacos 官方网站下载安装包:https://github.com/alibaba/nacos/releases
1.2 引入依赖
父工程统一管理 Spring Cloud Alibaba 版本:
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>2.2.5.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
客户端引入服务发现依赖:
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
1.3 配置 Nacos 地址
在客户端配置文件中声明应用名称与 Nacos 服务端地址:
string:
application:
iname:item-service
cloud:
nacos:
server-addr:192.168.3.133:8848
启动 Nacos 容器时可指定环境变量(custom.env):
PREFER_HOST_MODE=hostname
MODE=standalone
SPRING_DATASOURCE_PLATFORM=mysql
MYSQL_SERVICE_HOST=192.168.3.133 //配置为自己的ip
MYSQL_SERVICE_DB_NAME=nacos
MYSQL_SERVICE_PORT=3306
MYSQL_SERVICE_USER=root
MYSQL_SERVICE_PASSWORD=123
MYSQL_SERVICE_DB_PARAM=characterEncoding=utf8&connectTimeout=1000&
socketTimeout=3000&autoReconnect=true&useSSL=false&
allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
使用 Docker 以单机模式启动 Nacos:
docker run -d --name nacos --env-file /root/nacos/custom.env
-p 8848:8848 -p 9848:9848 -p 9849:9849
--restart=always nacos/nacos-server:v2.1.1-slim
3. OpenFeign 远程调用
OpenFeign 是基于接口的声明式 HTTP 客户端,用于简化微服务之间的远程调用。
2.1 引入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
2.2 启用 Feign 客户端
在启动类上使用 @EnableFeignClients 注解开启 Feign 功能:
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
@EnableFeignClients
@MapperScan("com.cartService.mapper")
@SpringBootApplication
public class CartServiceApplication {
public static void main(String[] args) {
SpringApplication.run(CartServiceApplication.class, args);
}
}
2.3 编写 FeignClient
通过 @FeignClient 声明远程服务接口:
import com.cartService.domain.dto.ItemDTO;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@FeignClient("item-service")
public interface itemClient {
@GetMapping("/items")
List<ItemDTO> queryItemByIds(@RequestParam("ids") List<Long> ids);
}
2.4 使用 FeignClient 实现远程调用
注入接口即可像调用本地方法一样发起远程请求:
private final itemClient itemClient;
List<ItemDTO> items = itemClient.queryItemByIds(itemIds);
4. OpenFeign 整合 OkHttp
为 Feign 开启 OkHttp 连接池,可复用底层 HTTP 连接,提升远程调用性能。
3.1 引入依赖
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-okhttp</artifactId>
</dependency>
3.2 开启连接池
feign:
okhttp:
enabled: true
5. 最佳实践:抽取公共 API 模块
多个微服务可能使用相同的 Client,若重复编写,一旦需要变更就要改动多处。
- 新建一个模块
richu-api,引入 openFeign 的依赖。 - 配置 DTO 和 Client。
- 在其他模块引入:
<dependency>
<groupId>com.richu</groupId>
<artifactId>richu-api</artifactId>
<version>1.0.0</version>
</dependency>
- 指定包名扫描:
@EnableFeignClients(basePackages = "com.richu.api.client")
6. 日志输出
OpenFeign 只有在日志级别为 Debug 时才会进行日志输出。日志级别说明如下:
| 级别 | 说明 |
|---|---|
| None | 不记录任何值,默认值 |
| BASIC | 仅记录请求的方法、URL、响应状态码和执行时间 |
| Headers | 在 BASIC 基础上,额外记录请求和响应的头信息 |
| Full | 记录所有的请求和响应的明细,包括头信息、请求体、元数据 |
通过配置类设置日志级别为 FULL:
public class DefaultFeignConfig {
@Bean
public Logger.Level feignLoggerLevel() {
return Logger.Level.FULL;
}
}
局部配置,在 @FeignClient 注解中声明:
@FeignClient(value = "item-service",configuration = DefaultFeignConfig.class)
public interface ItemClient {
@GetMapping("/items")
List<ItemDTO> queryItemByIds(@RequestParam("ids") Collection<Long> ids);
}
全局配置,在 @EnableFeignClients 注解中声明:
@EnableFeignClients(basePackages = "com.richu.api.client",defaultConfiguration = DefaultFeignConfig.class)
@MapperScan("com.cartService.mapper")
@SpringBootApplication
public class CartServiceApplication {
public static void main(String[] args) {
SpringApplication.run(CartServiceApplication.class, args);
}
}
7. 网关(Spring Cloud Gateway)
6.1 使用
网关是网络的关口,负责请求的路由、转发与身份校验。
- 创建新模块。
- 引入网关依赖:
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
</dependencies>
- 编写启动类:
@SpringBootApplication
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class,args);
}
}
- 配置路由规则:
spring:
application:
name:gateway
cloud:
nacos:
discovery:
server-addr: 192.168.3.1:8848
gateway:
routes:
- id: item-service //路由id 自定义 唯一
uri: lb://item-service //目标微服务 lb代表负载均衡
predicates: //路由断言
- Path=/items/** //请求路径做判断
- id: cart-service
uri: lb://cart-service
predicates:
- Path=/carts/**
6.2 路由属性
| 属性 | 说明 |
|---|---|
| id | 路由唯一标识 |
| uri | 路由目标地址 |
常用路由断言(Predicates):
| 断言 | 配置说明 |
|---|---|
| After | 在指定时间之后进行路由 |
| Before | 在指定时间之前进行路由 |
| Between | 在指定时间之间进行路由 |
| Cookie | Cookie=cookie名, cookie值的正则表达式规则 |
| Header | Header=header名, header值的正则表达式规则 |
| Host | Host=主机名(可配置多个,也可以使用通配符) |
| Method | Method=请求类型 |
| Path | Path=请求路径 |
| Query | Query=参数名,参数值 |
路由过滤器(GatewayFilter)用于在请求转发前后对请求/响应进行处理。
6.3 自定义过滤器
| 类型 | 作用范围 | 说明 |
|---|---|---|
| GatewayFilter | 任意指定的路由 | 路由过滤器,作用于单个路由 |
| GlobalFilter | 所有路由 | 全局过滤器,声明后自动生效 |
GlobalFilter 接口定义如下:
public interface GlobalFilter{
Mono<void> filter(ServerWebExchange exchange,GatewayFilterChain chain)
//请求上下文request,response 过滤器链
}
6.3.1 GlobalFilter
public class GlobalFilters implements GlobalFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
//TODO 请求校验逻辑
ServerHttpRequest request = exchange.getRequest();
HttpHeaders headers = request.getHeaders();
System.out.println("headers = "+headers);
//放行
return chain.filter(exchange);
}
@Override
public int getOrder() {
return 0;
}
}
6.3.2 GatewayFilter
@Component
public class GateWayFilter extends AbstractGatewayFilterFactory {
@Override
public GatewayFilter apply(Object config) {
return new GatewayFilter() {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
return chain.filter(exchange);
}
};
}
}
装饰类可以指定顺序:
@Component
public class GateWayFilter extends AbstractGatewayFilterFactory {
@Override
public GatewayFilter apply(Object config) {
return new OrderedGatewayFilter(new GatewayFilter() {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
return chain.filter(exchange);
}
},1);
}
}
实现登录校验的全局过滤器示例:
package com.richu.gateway.filters;
import cn.hutool.core.text.AntPathMatcher;
import com.richu.common.exception.UnauthorizedException;
import com.richu.gateway.config.AuthProperties;
import com.richu.gateway.util.JwtTool;
import lombok.RequiredArgsConstructor;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.List;
@Component
@RequiredArgsConstructor
public class GlobalFilters implements GlobalFilter, Ordered {
private final AuthProperties authProperties;
private final JwtTool jwtTool;
private AntPathMatcher antPathMatcher = new AntPathMatcher();
private String token;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
//获取request
ServerHttpRequest request = exchange.getRequest();
//判断是否需要进行登录拦截
if (isExclude(request.getPath().toString())){
return chain.filter(exchange);
}
//获取token
List<String> hearders = request.getHeaders().get("Authorization");
if (hearders != null && !hearders.isEmpty()) {
token = hearders.get(0);
}
Long userid = null;
//校验token
try {
userid = jwtTool.parseToken(token);
}catch (UnauthorizedException e){
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(HttpStatus.UNAUTHORIZED);
return response.setComplete();
}
//TODO 传递用户信息
System.out.println(userid);
//放行
return chain.filter(exchange);
}
private boolean isExclude(String path) {
for (String pathPattern: authProperties.getExcludePaths()){
if (antPathMatcher.match(path,pathPattern)){
return true;
}
}
return false;
}
@Override
public int getOrder() {
return 0;
}
}
6.4 网关传递信息到微服务
在网关校验通过后,可将用户信息写入请求头并向下游微服务传递:
//传递用户信息
String userinfo = userid.toString();
ServerWebExchange swe = exchange.mutate()
.request(builder -> builder.header("user-info", userinfo)).build();
//放行
return chain.filter(swe);
在微服务的 common 模块拦截器中获取,便于其他业务模块直接使用。
- 定义拦截器类:
public class UseInfoInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//获取登录用户信息
String userinfo = request.getHeader("user-info");
//判断是否获取了用户如果是,存入ThreadLocal
if (StrUtil.isBlankIfStr(userinfo)){
UserContext.setUser(Long.parseLong(userinfo));
}
//放行
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
}
}
- 配置类:
@Configuration
public class MvcConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new UseInfoInterceptor());
}
}
- 配置自动装配:
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.richu.common.config.MyBatisConfig,\
com.richu.common.config.MvcConfig,\
com.richu.common.config.JsonConfig
解决措施,在 MvcConfig 上加条件注解:
//解决措施,在MvcConfig上加
@ConditionalOnClass(DispatcherServlet.class)
8. 配置管理
7.1 配置热更新
将配置迁移到 Nacos 配置中心,可减少重复配置、简化开发。
引入 Nacos 配置与 Bootstrap 依赖:
//nacos项
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>pring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
//bootstrap配置
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>
Nacos 配置示例:
spring:
cloud:
nacos:
server-addr:192.168.3.133
config:
file-extension:yaml
sgared-configs:
--data-id:shared-jdbc.yaml
--data-id:shared-log.yaml
--data-id:shared-swagger.yaml
热更新前提条件(Nacos 配置绑定到 Bean):
@Data
@Component
@ConfigurationPreperties(prefix = "hm.cart")
public class config{
private Integer num;
}
7.2 动态路由
监听 Nacos 路由配置变更后,利用 RouteDefinitionWriter 更新路由表:
package com.richu.gateway.routers;
import cn.hutool.json.JSONUtil;
import com.alibaba.cloud.nacos.NacosConfigManager;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;
import javax.annotation.PostConstruct;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Executor;
@Slf4j
@Component
@RequiredArgsConstructor
public class DunamicRoute {
private final NacosConfigManager nacosConfigManager;
private final RouteDefinitionWriter writer;
private final String dataId = "gateway-routes.json";
private final String group = "DEFAULT_GROUP";
private final Set<String> RouteIds = new HashSet<>();
//项目启动时,先拉取一次配置,并且添加配置监听器
@PostConstruct
public void init() throws NacosException {
String configInfo = nacosConfigManager.getConfigService().getConfigAndSignListener(dataId, group, 5000, new Listener() {
@Override
public Executor getExecutor() {
return null;
}
@Override
public void receiveConfigInfo(String configInfo){
//监听到配置变更,需要更新路由表
updateConfigInfo(configInfo);
}
});
//第一次读取配置
updateConfigInfo(configInfo);
}
public void updateConfigInfo(String config){
//1.解析配置信息
List<RouteDefinition> list = JSONUtil.toList(config, RouteDefinition.class);
//2.删除旧的路由表
for (String ids : RouteIds) {
//删除路由表
writer.delete(Mono.just(ids)).subscribe();
}
RouteIds.clear();
//3.更新路由表
for (RouteDefinition routeDefinition : list) {
//更新路由表
writer.save(Mono.just(routeDefinition)).subscribe();
//记录路由id
RouteIds.add(routeDefinition.getId());
}
}
}
9. 微服务保护与分布式事务
8.1 解决方案
雪崩问题:微服务调用链的某个服务故障,导致整个链路的微服务都不可用。
| 方案 | 说明 |
|---|---|
| 请求限流 | 限制访问微服务的请求的并发量 |
| 线程隔离 | 舱壁模式,隔离资源避免连锁耗尽 |
| 服务熔断 | 由断路器统计请求的异常比例或慢调用比例,如果超出阈值则会熔断该业务,拦截该接口的请求 |
Sentinel 与 Hystrix 对比:
| Sentinel | Hystrix | |
|---|---|---|
| 隔离策略 | 信号量隔离 | 线程池隔离/信号量隔离 |
| 熔断降级策略 | 基于慢调⽤⽐例或异常⽐例 | 基于失败⽐率 |
| 实时指标实现 | 滑动窗⼝ | 滑动窗⼝(基于 RxJava) |
| 规则配置 | ⽀持多种数据源 | ⽀持多种数据源 |
| 扩展性 | 多个扩展点 | 插件的形式 |
| 基于注解的⽀持 | ⽀持 | ⽀持 |
| 限流 | 基于 QPS,⽀持基于调⽤关系的限流 | 有限的⽀持 |
| 流量整形 | ⽀持慢启动、匀速排队模式 | 不⽀持 |
| 系统⾃适应保护 | ⽀持 | 不⽀持 |
| 控制台 | 开箱即⽤,可配置规则、查看秒级监控、机器发现等 | 不完善 |
| 常⻅框架的适配 | Servlet、Spring Cloud、Dubbo、gRPC 等 | Servlet、Spring Cloud Netflix |
8.2 Sentinel
8.2.1 安装控制台
启动控制台:
java -server -Xms64m -Xmx256m
-Dserver.port=8090 -Dcsp.sentinel.dashboard.server=localhost:8090
-Dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar
访问 http://localhost:8090/#/login,用户名和密码均为 sentinel。
8.2.2 引入依赖
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
8.2.3 配置文件
spring:
cloud:
sentinel:
transport:
dashboard: localhost:8090
8.2.4 簇点链路
单机调用链路,是进入服务后被 Sentinel 监控的资源链,默认 Sentinel 只会监控 SpringMvc 的每一个 Endpoint(http 接口)。RestFul 的 API 请求路径相同,会导致簇点资源名称重复。开启 http-method-specify 以区分:
spring:
cloud:
sentinel:
transport:
dashboard: localhost:8090
http-method-specify: true
8.2.5 请求限流
点击流控,配置单机阈值即可对接口进行 QPS 限流。

8.2.6 线程隔离
点击流控,选择并发线程数,设置单机阈值,实现线程隔离。

8.2.7 Fallback
开启 Feign 的 Sentinel 支持:
feign:
sentinel:
enabled: true
okhttp:
enabled: true
@Slf4j
public class ItemClientFallbackFactory implements FallbackFactory<ItemClient> {
@Override
public ItemClient create(Throwable cause) {
return new ItemClient() {
@Override
public List<ItemDTO> queryItemByIds(Collection<Long> ids) {
//进行错误处理
log.info("查询商品失败",cause);
return null;
}
};
}
}
将该类定义为 Bean:
@Bean
public ItemClientFallbackFactory itemClientFallbackFactory(){
return new ItemClientFallbackFactory();
}
在 @FeignClient 上指定 fallbackFactory:
@FeignClient(value = "item-service",fallbackFactory = ItemClientFallbackFactory.class)
public interface ItemClient {
@GetMapping("/items")
List<ItemDTO> queryItemByIds(@RequestParam("ids") Collection<Long> ids);
}
8.2.8 服务熔断
断路器统计服务调用的异常比例、慢请求比例,如果超出阈值就会熔断该服务,拦截该服务的一切请求;当服务恢复时,断路器会放行。
8.3 分布式事务
分布式事务是指事务的发起者、资源及资源管理器和事务协调者分别位于分布式系统的不同节点之上。本质上来说,分布式事务就是为了保证在分布式场景下,数据操作的正确执行。
8.3.1 Seata
Seata 事务管理有三个角色:
| 角色 | 职责 |
|---|---|
| TC(Transaction Coordinator) | 事务协调者:维护全局和分支事务的状态,协调全局事务提交或者回滚 |
| TM(Transaction Manager) | 事务管理器:定义全局事务的范围,开始全局事务、提交和回滚全局事务 |
| RM(Resource Manager) | 资源管理器:管理分支事务,与 TC 交谈以注册分支事务和报告分支事务的状态 |
8.3.2 部署 TC 服务
- 导入数据库:
CREATE TABLE `undo_log` (
`id` bigint NOT NULL AUTO_INCREMENT,
`branch_id` bigint NOT NULL,
`xid` varchar(100) NOT NULL,
`context` varchar(128) NOT NULL,
`rollback_info` longblob NOT NULL,
`log_status` int NOT NULL,
`log_created` datetime NOT NULL,
`log_modified` datetime NOT NULL,
`ext` varchar(100) DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
- Docker 部署:
docker load -i seata-1.5.2.tar
docker inspect mysql
docker run --name seata -p 8099:8099 -p 7099:7099 -e SEATA_IP=192.168.3.133
-v ./seata:/seata-server/resources --privileged=true
--network richu -d seataio/seata-server:1.5.2
或:
docker run -d --name seata --restart always -p 8091:8091 -p 7091:7091 seataio/seata-server:2.6.0
8.3.3 微服务整合 Seata
- 导入依赖:
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>
- 在 Nacos 里面添加配置:
seata:
registery:
type:nacos # 注册中心nacos
nacos:
server-addr:nacos地址
namespace:""
group:DEFAULT_GROUP
application:service # seata服务名
username:nacos
password:nacos
tx-service-group:事务组名
service:
vgroup-mapping:
事务名:"default"
8.3.4 XA 模式
seata:
registery:
type:nacos 注册中心nacos
nacos:
server-addr:nacos地址
namespace:""
group:DEFAULT_GROUP
application:service #seata服务名
username:nacos
password:nacos
tx-service-group:事务组名
service:
vgroup-mapping:
事务名:"default"
data-source-proxy-mode:XA
入口方法声明 @GlobalTransactional,其他相关方法注解 @Transactional。
8.3.5 AT 模式
Seata 主推的是 AT 模式。在一阶段,Seata 会拦截“业务 SQL”,首先解析 SQL 语义,找到“业务 SQL”要更新的业务数据,在业务数据被更新前,将其保存成“before image”,然后执行“业务 SQL”更新业务数据,在业务数据更新之后,再将其保存成“after image”,最后生成行锁。以上操作全部在一个数据库事务内完成,保证了一阶段操作的原子性。
10. RabbitMQ
RabbitMQ 是高性能异步通信组件。
9.1 同步调用与异步调用
同步调用优点:时效性强,等到结果才返回。
同步调用缺点:
异步调用引入三个核心角色:
| 角色 | 说明 |
|---|---|
| 消息发送者(Publisher) | 投递消息的人,即原来的调用者 |
| 消息接收者(Consumer) | 接收和处理消息的人,即原来的服务提供者 |
| 消息代理(Broker) | 管理、暂存、转发消息,类似于服务器 |
9.2 安装 RabbitMQ
docker run -e RABBITMQ_DEFAULT_USER=richu -e RABBITMQ_DEFAULT_PASS=12345678 -v mq-plugins:/plugins
--name mq --hostname mq -p 15672:15672 -p 5672:5672
--network richu -d rabbitmq:3.8-management
9.3 Java 客户端收发流程
消息通信协议 AMQP 与语言无关,更符合微服务中独立性的要求。
- 创建 Queue。
- 在父工程引入依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
- 配置 yaml 文件:
spring:
rabbitmq:
host: 192.168.3.133
port: 5672
virtual-host: /
username: richu
password: 12345678
- 测试发送:
@SpringBootTest
class PublisherApplicationTest {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testqueue(){
String queueName = "queue1";
String Message = "hello mq";
rabbitTemplate.convertAndSend(queueName,Message);
}
}
- 测试接收:
@Slf4j
@Component
public class SpringRabiitListener {
@RabbitListener(queues = "queue1")
public void receive1(String msg) {
log.info("收到的消息为:{}",msg);
}
}
9.4 Work Queues
多个消费者监听同一个队列。
@Slf4j
@Component
public class SpringRabiitListener {
@RabbitListener(queues = "queue1")
public void receive1(String msg) {
log.info("1收到的消息为:{}",msg);
}
@RabbitListener(queues = "queue1")
public void receive2(String msg) {
System.out.printf("2收到的消息为:%s\n",msg);
}
}
@Test
public void testqueue(){
String queueName = "queue1";
for (int i = 0; i < 10; i++) {
String Message = "hahaha" + i;
rabbitTemplate.convertAndSend(queueName,Message);
}
}
运行结果示例:
2收到的消息为:hahaha1
2收到的消息为:hahaha3
2收到的消息为:hahaha5
2收到的消息为:hahaha7
08-28 13:19:07:463 INFO 18392 --- [ntContainer#0-1] c.i.consumer.mq.SpringRabiitListener : 1收到的消息为:hahaha0
2收到的消息为:hahaha9
08-28 13:19:07:464 INFO 18392 --- [ntContainer#0-1] c.i.consumer.mq.SpringRabiitListener : 1收到的消息为:hahaha2
08-28 13:19:07:464 INFO 18392 --- [ntContainer#0-1] c.i.consumer.mq.SpringRabiitListener : 1收到的消息为:hahaha4
08-28 13:19:07:464 INFO 18392 --- [ntContainer#0-1] c.i.consumer.mq.SpringRabiitListener : 1收到的消息为:hahaha6
08-28 13:19:07:464 INFO 18392 --- [ntContainer#0-1] c.i.consumer.mq.SpringRabiitListener : 1收到的消息为:hahaha8
spring:
rabbitmq:
host: 192.168.3.133
port: 5672
virtual-host: /
username: richu
password: 12345678
listener:
direct:
prefetch: 1
9.5 Fanout 交换机
交换机接收发送者发送的消息,并将消息发送到绑定的队列。
| 交换机类型 | 路由行为 |
|---|---|
| Fanout | 广播,发送到所有绑定的队列 |
| Direct | 定向,根据 RoutingKey 路由 |
| Topic | 话题,基于带通配符的 RoutingKey 路由 |
向交换机发送消息:
@Test
public void testqueue1(){
String queueName = "richu.fanout";
String Message = "hahaha";
//交换机名称 RoutingKey 消息
rabbitTemplate.convertAndSend(queueName,null,Message);
}
接收消息:
@RabbitListener(queues = "queue1")
public void receive1(String msg) {
log.info("1收到的消息为:{}",msg);
}
@RabbitListener(queues = "queue2")
public void receive2(String msg) {
log.info("2收到的消息为:{}",msg);
}
结果:两个消费者都收到消息。
08-28 14:06:18:718 INFO 2900 --- [ntContainer#1-1] c.i.consumer.mq.SpringRabiitListener : 1收到的消息为:hahaha
08-28 14:06:18:718 INFO 2900 --- [ntContainer#0-1] c.i.consumer.mq.SpringRabiitListener : 2收到的消息为:hahaha
声明两个队列并与交换机绑定,即可实现广播。
9.6 Direct 交换机
部分队列收到消息。每个队列和交换机都设置 BindingKey,发布者发消息时指定消息的 BindingKey,交换机将消息路由到 BindingKey 一致的队列。
@Test
public void testqueue1(){
String queueName = "richu.fanout";
String Message = "我是消息";
rabbitTemplate.convertAndSend(queueName,"blue",Message);
}
9.7 Topic 交换机
基于 RoutingKey 路由,通常由多个单词组合,以 . 做分隔符。
| 通配符 | 含义 |
|---|---|
# |
代表 0 个或多个单词 |
* |
代表一个单词 |
示例:chain.#、#.news。
9.8 声明队列与交换机
| 组件 | 说明 | 构建工厂类 |
|---|---|---|
| Queue | 声明队列 | QueueBuilder |
| Exchange | 声明交换机 | ExchangeBuilder |
| Binding | 声明队列和交换机的绑定关系 | BindingBuilder |
@Configuration
public class FanoutConfiguration {
@Bean
public FanoutExchange fanoutExchange() {
return new FanoutExchange("richu.exchange");
}
@Bean
public Queue fanoutQueue() {
//return QueueBuilder.durable("richu.queue").build();
return new Queue("richu.queue");
}
@Bean
public Binding fanoutBinding(Queue fanoutQueue, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(fanoutQueue).to(fanoutExchange);
}
}
基于注解开发的 SpringAMQP 方式:
//基于注解开发
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name="queue1",durable = "true"),
exchange = @Exchange(name = "richu.fanout",type = ExchangeTypes.DIRECT),
key = {"red","blue"}
))
public void receive1(String msg) {
log.info("1收到的消息为:{}",msg);
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name="queue2",durable = "true"),
exchange = @Exchange(name = "richu.fanout",type = ExchangeTypes.DIRECT),
key = {"red","blue"}
))
public void receive2(String msg) {
log.info("2收到的消息为:{}",msg);
}
9.9 消息转换器
使用 Json 序列化代替 JDK 的默认转换器,避免消息体可读性差与类型问题。
- 引入依赖:
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
- publish 和 consumer 都要设置:
@SpringBootApplication
public class PublisherApplication {
public static void main(String[] args) {
SpringApplication.run(PublisherApplication.class);
}
@Bean
public Jackson2JsonMessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}
}
11. RabbitMQ 高级
10.1 发送者重连
有时候由于网络波动可能会导致 MQ 丢失消息,可开启发送者重试机制。
logging:
pattern:
dateformat: MM-dd HH:mm:ss:SSS
spring:
rabbitmq:
host: 192.168.3.133
port: 5672
virtual-host: /
username: richu
password: 12345678
template:
retry:
enabled: true #开启超时重试机制
initial-interval: 100ms #失败后的等待时长
multiplier: 1 #下次的等待时长倍数
max-attempts: 3 #最大尝试次数
10.2 发送者确认
发送者发消息给 MQ 时,MQ 会返回确认结果给发送者。
10.2.1 添加配置
logging:
pattern:
dateformat: MM-dd HH:mm:ss:SSS
spring:
rabbitmq:
host: 192.168.3.133
port: 5672
virtual-host: /
username: richu
password: 12345678
listener:
direct:
prefetch: 1
publisher-confirm-type: correlated
publisher-returns: true
publisher-confirm-type 取值说明:
| 取值 | 说明 |
|---|---|
| none | 关闭 confirm 机制 |
| simple | 同步阻塞等待 MQ 的回执消息 |
| correlated | MQ 异步回调方式返回回执消息 |
10.2.2 配置 ReturnsCallback
@Slf4j
@Configuration
@RequiredArgsConstructor
public class Mqconfig {
private final RabbitTemplate rabbitTemplate;
@PostConstruct
public void init() {
rabbitTemplate.setReturnsCallback(returned -> {
log.error("监听到了消息return");
log.debug("exchange:{}",returned.getExchange());
log.debug("routingKey:{}",returned.getRoutingKey());
log.debug("message:{}",returned.getMessage());
log.debug("replyCode:{}",returned.getReplyCode());
log.debug("replyText:{}",returned.getReplyText());
});
}
}
10.2.3 配置发送者
CorrelationData cd = new CorrelationData(UUID.randomUUID().toString());
cd.getFuture().addCallback(new ListenableFutureCallback<CorrelationData.Confirm>() {
@Override
public void onFailure(Throwable ex) {
log.error("处理结果异常",ex);
}
@Override
public void onSuccess(CorrelationData.Confirm result) {
if (result.isAck()){
log.debug("收到了confirm ack");
}else{
log.error("收到了confirm nack !reson:{}",result.getReason());
}
}
});
String queueName = "richu.fanout";
String Message = "我是消息";
rabbitTemplate.convertAndSend(queueName,"blue",Message,cd);
10.3 MQ 的可靠性
一旦宕机,内存中的所有数据消息都会丢失;且内存空间有限,当消费者故障或处理过慢时,会导致消息积压,引发 MQ 阻塞。可对消息设置持久化(PERSISTENT):
public void testqueue(){
//1.自定义构建消息
/* Message message = MessageBuilder.withBody("hello0".getBytes(StandardCharsets.UTF_8))
.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT).build(); //不持久*/
Message message = MessageBuilder.withBody("hello0".getBytes(StandardCharsets.UTF_8))
.setDeliveryMode(MessageDeliveryMode.PERSISTENT).build(); //持久
String queueName = "queue1";
for (int i = 0; i < 100000; i++) {
rabbitTemplate.convertAndSend(queueName,message);
}
}
10.4 Lazy Queue
只写入磁盘,消息持久化到磁盘,需要消息时才会从磁盘中读取并加载到内存。RabbitMQ 3.12 之后默认支持。
x-queue-mode = lazy
10.5 消费者可靠性
10.5.1 消费者确认机制
| 确认结果 | 行为 |
|---|---|
| ack | 成功处理消息,MQ 队列删除消息 |
| nack | 处理失败,MQ 队列需要再次投递消息 |
| reject | 拒绝接收,MQ 队列删除消息 |
logging:
pattern:
dateformat: MM-dd HH:mm:ss:SSS
spring:
rabbitmq:
host: 192.168.3.133
port: 5672
virtual-host: /
username: richu
password: 12345678
template:
retry:
enabled: true #开启超时重试机制
initial-interval: 100ms #失败后的等待时长
multiplier: 1 #下次的等待时长倍数
max-attempts: 3 #最大尝试次数
listener:
direct:
acknowledge-mode: auto
10.5.2 失败重试机制
在开启重试模式后,若重试次数耗尽消息依然失败,则由 MessageRecoverer 接口处理,它包含三种实现:
| 实现 | 行为 |
|---|---|
| RejectAndDontRequeueRecoverer | 重试耗尽后直接 reject,丢弃消息(默认方式) |
| ImmediateRequeueMessageRecoverer | 重试耗尽后返回 nack,消息重新入队(不建议:会出现死循环) |
| RepublishMessageRecoverer | 重试耗尽后,将失败消息投递到指定的交换机(推荐) |
listener: # 开启消费者确认其机制
simple:
prefetch: 1 #消费者每次只能获取一条消息,处理完才能获取下一条(可实现能者多劳)
acknowledge-mode: AUTO # none:关闭ack;manual:手动ack;auto:自动ack
retry:
enabled: true #开启消费者失败重试
initial-interval: 1000ms #初始的失败等待时长为1秒
multiplier: 1 #下次失败的等待时长倍数,下次等待时长 = multiplier * last-interval
max-attempts: 3 #最大重试次数
stateless: true #true无状态;false有状态。如果业务中包含事务,这里改为false
使用 RepublishMessageRecoverer 将失败消息转发到 error 交换机:
@Configuration
@RequiredArgsConstructor
public class ErrorMessageConfig {
private final RabbitTemplate rabbitTemplate;
@Bean
public DirectExchange directExchange() {
return new DirectExchange("error");
}
@Bean
public Queue errorQueue() {
return new Queue("error");
}
@Bean
public Binding bindingError(Queue queue, DirectExchange directExchange) {
return BindingBuilder.bind(queue).to(directExchange).with("error");
}
@Bean
public RepublishMessageRecoverer messageConverter(RabbitTemplate rabbitTemplate) {
return new RepublishMessageRecoverer(rabbitTemplate,"error","error");
}
}
10.6 业务幂等性
执行一个业务一次或者多次,对业务状态的影响保持一致。
发送者方案:
@Bean
public MessageConverter messageConverter(){
Jackson2JsonMessageConverter jjmc = new Jackson2JsonMessageConverter();
jjmc.setCreateMessageIds(true);
return jjmc;
}
业务判断(基于业务本身做判断)更为可靠。
10.7 延迟消息
10.7.1 死信交换机
消息成为死信的几种情况:
- 消费者声明为消费失败,消息的 requeue 参数设置为 false。
- 消息是一个过期消息。
- 队列消息积满。
通过 dead-letter-exchange 属性指定一个交换机,该队列的死信就会投递到这个交换机中。
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name="dlx.queue",durable = "true"),
exchange = @Exchange(name = "dlx.direct",type = ExchangeTypes.DIRECT),
key = {"hi"}
))
public void listenexchange(Message msg) {
log.info("死信交换机和死信队列收到的消息为:{}",msg);
}
@Configuration
@RequiredArgsConstructor
public class NormalConfig {
@Bean
public DirectExchange normalExchange() {
return new DirectExchange("normal.exchange");
}
@Bean
public Queue normalQueue() {
return QueueBuilder.durable("normal.queue").deadLetterExchange("dlx.direct").build();
}
@Bean
public Binding bindingNormal( Queue queue, DirectExchange directExchange) {
return BindingBuilder.bind(queue).to(directExchange).with("hi");
}
}
发送延迟消息:
@Test
void testSendDelayMessage(){
rabbitTemplate.convertAndSend("normal.exchange","hi","我是一只坤",message->{
message.getMessageProperties().setDelay(10000);
return message;
});
}
10.7.2 延迟消息插件
安装延迟消息插件:
docker exec -it mq rabbitmq-plugins enable rabbitmq_delayed_message_exchange
使用延迟交换机:
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name="dlx.queue",durable = "true"),
exchange = @Exchange(name = "dlx.direct",delayed = "true"),
key = {"hi"}
))
public void delayedexchange(Message msg) {
log.info("死信交换机和死信队列收到的消息为:{}",msg);
}
发送消息:
@Test
void testSendDelayMessage(){
rabbitTemplate.convertAndSend("normal.exchange","hi","我是一只坤",message->{
message.getMessageProperties().setDelay(10000);
return message;
});
}
12. Elasticsearch
11.1 安装
Elasticsearch 安装:
docker run -d --name es -e ES_JAVA_OPTS="-Xms512m -Xmx512m" \
-e "discovery.type=single-node" \
-v es-data:/usr/share/elasticsearch/data \
-v es-plugins:/usr/share/elasticsearch/plugins \
--privileged \
--network richu \
-p 9200:9200 \
-p 9300:9300 \
elasticsearch:7.12.1
或:
docker run -d --name elasticsearch --restart=always -p 9200:9200 -p 9300:9300
-e "discovery.type=single-node" -e "ES_JAVA_OPTS=-Xms512m -Xmx512m"
-v D:/es/data:/usr/share/elasticsearch/data
-v D:/es/plugins:/usr/share/elasticsearch/plugins docker.elastic.co/elasticsearch/elasticsearch:7.6.2
Kibana 图形化界面:
docker run -d --name kibana -e ELASTICSEARCH_HOST=http://es:9200 --network=richu -p 5601:5601 kibana:7.12.1
IK 分词器安装:
docker exec -it elasticsearch /bin/bash
./bin/elasticsearch-plugin install https://get.infini.cloud/elasticsearch/analysis-ik/7.6.2
重启 ES:docker restart elasticsearch。
测试 IK 分词:
- 最细粒度分词(ik_max_word):
POST /_analyze
{
"analyzer": "ik_max_word",
"text": "我爱学习,我每天学习"
}
- 最常用 / 最合理分词(ik_smart):
POST /_analyze
{
"analyzer": "ik_smart",
"text": "我爱学习,我每天学习"
}
运行结果(ik_smart 示例):
我
爱
学习
我
每天
学习
11.2 倒排索引
| 概念 | 说明 |
|---|---|
| 文档(Document) | 每条数据就是一个文档 |
| 词条(Term) | 文档按照语义分成的词语 |
POST /_analyze
{
"analyzer":"standard",
"text":"我爱学习,我每天学习"
}
<entry key="ext_dict">ext.dic</entry>
11.3 基础概念
| 概念 | 说明 |
|---|---|
| 索引库(Index) | 相同类型的文档的集合 |
| 类型(type) | 字段数据类型,如 text、keyword、long、date 等 |
| index | 是否创建索引,默认为 true |
| analyzer | 使用哪种分词器 |
| properties | 该字段的子字段 |
常见字段数据类型:
- 字符串:
text(可分词文本)、keyword(精确值,如品牌、国家、ip 地址) - 数值:
long、integer、short、byte、double、float - 布尔:
boolean - 日期:
date - 对象:
object
11.4 索引库的 CRUD 操作
创建索引库:
PUT /索引库
{
"mapping":{
"properties":{
"字段名":{
"type":"text",
"analyzer":"ik_smart"
}
}
}
}
查询索引库:
GET /richu
删除索引库:
DELETE /richu
修改索引库(新增字段):
PUT /修改的索引库/_mapping{
"properties":{
"新字段名":{
"type":"text",
"analyzer":"ik_smart"
}
}
}
11.5 文档的 CRUD
新增文档:
POST /索引库/_doc/文档id
{
"字段1":"值1",
"字段2":"值2",
"字段3":"值3"
}
查询文档:
GET /索引库/_doc/文档id
删除文档:
DELETE /索引库/_doc/文档id
修改(先删除再新增,如果没有则会添加):
PUT /索引库/_doc/文档id
{
"字段1":"值1",
"字段2":"值2",
"字段3":"值3"
}
增量修改:
POST /索引库/_doc/文档id
{
"doc":{
"字段名":"值"
}
}
- 批处理请求:
POST /_bulk
//新增
{"index" : { "_index":"索引名","_id":"1"}}
{"字段1":"值1","字段2":"值2"}
//删除
{"delete":{"_index":"test","_id":2}}
//修改
{"update":{"_id":"1","_index":"test"}}
{"doc":{"field2":"value"}}
11.6 Java Rest Client
引入依赖:
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>
默认为 7.17.10,覆盖版本:
<elasticsearch.version>7.12.1</elasticsearch.version>
创建 client:
@BeforeEach
void setUp(){
client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.16.3.133:9200")));
}
@AfterEach
void destrory() throws IOException {
if (client != null){
client.close();
}
}
测试:
@Test
void test(){
System.out.println("client"+client);
}
11.7 操作索引库的 API
新增索引库:
@Test
void createIndex() throws IOException {
//准备request对象
CreateIndexRequest request = new CreateIndexRequest("items");
//2.准备发送请求
request.source(MAPPING_TEMPLATE, XContentType.JSON);
//发送
client.indices().create(request, RequestOptions.DEFAULT);
}
private static final String MAPPING_TEMPLATE = "{\n" +
" \"mappings\":{\n" +
" \"properties\":{\n" +
" \"id\":{\n" +
" \"type\":\"keyword\"\n" +
" },\n" +
" \"name\":{\n" +
" \"type\":\"keyword\",\n" +
" \"analyzer\":\"ik_smart\"\n" +
" },\n" +
" \"price\":{\n" +
" \"type\":\"keyword\",\n" +
" \"index\":false\n" +
" },\n" +
" \"category\":{\n" +
" \"type\":\"keyword\"\n" +
" },\n" +
" \"brand\":{\n" +
" \"type\":\"keyword\"\n" +
" },\n" +
" \"sold\":{\n" +
" \"type\":\"integer\"\n" +
" },\n" +
" \"commentCount\":{\n" +
" \"type\":\"integger\",\n" +
" \"index\":false\n" +
" },\n" +
" \"isAD\":{\n" +
" \"type\":\"boolean\"\n" +
" },\n" +
" \"updateTime\":{\n" +
" \"type\":\"date\"\n" +
" }\n" +
"\t }\n" +
" }\n" +
"}";
查询索引库:
@Test
void selectIndex() throws IOException {
GetIndexRequest request = new GetIndexRequest("items");
//判断是否存在
client.indices().exists(request, RequestOptions.DEFAULT);
}
删除索引库:
@Test
void deleteIndex() throws IOException {
DeleteIndexRequest request = new DeleteIndexRequest("items");
//判断是否存在
client.indices().delete(request, RequestOptions.DEFAULT);
}
11.8 操作文档
新增文档:
@Test
void createIndex() throws IOException {
//准备一个request
IndexRequest request = new IndexRequest("items").id("1");
//准备参数
request.source("{\"name\":\"tom\",\"age\":\"18\"}",XContentType.JSON);
//发送请求
client.index(request,RequestOptions.DEFAULT);
}
查询文档:
@Test
public void getIndex() throws IOException {
//准备一个request
GetRequest request = new GetRequest("items","1");
//发送请求
GetResponse response = client.get(request, RequestOptions.DEFAULT);
//解析结果
String sourceAsString = response.getSourceAsString();
System.out.println(sourceAsString);
}
删除文档:
@Test
public void changeIndex() throws IOException {
//准备一个request
IndexRequest request = new IndexRequest("items").id("1");
//发送请求
IndexResponse rep = client.index(request, RequestOptions.DEFAULT);
//解析结果
System.out.println(rep);
}
全量更新:
@Test
public void changeIndex() throws IOException {
//准备一个request
IndexRequest request = new IndexRequest("items").id("1");
request.source(MAPPING_TEMPLATE, XContentType.JSON);
IndexResponse rep = client.index(request, RequestOptions.DEFAULT);
System.out.println(rep);
}
局部更新:
@Test
public void updateIndex() throws IOException {
//准备一个request
UpdateRequest request = new UpdateRequest("items","1");
//发送请求
request.doc(
"name","zs",
"age","46"
);
//解析结果
client.update(request, RequestOptions.DEFAULT);
}
11.9 批处理
@Test
public void bulkIndex() throws IOException {
//准备一个request
BulkRequest bulkRequest = new BulkRequest();
//发送请求
bulkRequest.add(new IndexRequest("items","1").
source("{\"name\":\"tom\",\"age\":\"18\"}",XContentType.JSON));
bulkRequest.add(new DeleteRequest("items","1"));
//解析结果
client.bulk(bulkRequest, RequestOptions.DEFAULT);
}
13. DSL 操作
查询语法:
GET /indexName/_search
{
"query":{
"查询类型":{
"查询条件":条件值
}
}
}
//查询所有
GET /indexName/_search
{
"query":{
"match_all":{
}
}
}
12.1 叶子查询
| 分类 | 查询类型 |
|---|---|
| 全文检索(full text) | match、multi_match |
| 精确查询 | ids、range、term |
| 地理(geo)查询 | geo_distance、geo_bounding_box |
match 查询,对输入内容分词后再查询:
GET /indexName/_search
{
"query":{
"match":{
"FILELD":"TEXT"
}
}
}
multi_match 查询,支持同时查询多个字段:
GET /indexName/_search
{
"query":{
"multi_match":{
"query":"TEXT",
"fields":["FIELD1","FIELD2"]
}
}
}
term 精确查询:
GET /indexName/_search
{
"query":{
"term":{
"fields":{
"value":"values"
}
}
}
}
range 范围查询:
GET /indexName/_search
{
"query":{
"range":{
"fields":{
"gte":value,
"lte":value
}
}
}
}
ids 根据 id 查询:
GET /indexName/_search
{
"query":{
"ids":{
"values":["12","13"]
}
}
}
12.2 复合查询
基于逻辑运算组合叶子查询,实现组合条件,常用 bool;基于算法修改查询时的文档相关性算分从而改变文档排名,常用 function_score、dis_max。
| 子句 | 含义 |
|---|---|
| must | 与 |
| should | 或 |
| must_not | 非 |
| filter | 必须匹配,不参与算分 |
GET /items/_search
{
"query":{
"bool":{
"must":[{"match":{"fileds":"value"}}],
"filter":["term":{"fileds":"value"},"range":{"gte":"value","lte":"value"}]
}
}
}
12.3 排序和分页
排序 sort:
GET /indexName/_search
{
"query":{
"match_all":{}
},
"sort":{
"FIELD":"DESC" ASC、DESC
}
}
分页:from 从第几个文档开始,size 总共查询几个文档。
GET /indexName/_search
{
"query":{
"match_all":{}
},
"from":0,
"size":10,
"sort":{
"FIELD":"DESC" ASC、DESC
}
}
12.4 深度分页问题
深度分页场景下可结合 highlight 高亮返回结果:
GET /items/_search
{
"query":{
"match":{
"filed":"value"
}
},
"highlight":{
"fields":{
"fields":{
"pre_tags":"<em>",
"post_tags":"</em>"
}
}
}
}
一句话总结:Spring Cloud 通过 Nacos、OpenFeign、Gateway、Sentinel、Seata、RabbitMQ、Elasticsearch 等组件的有机整合,提供了一套开箱即用的微服务“全家桶”,覆盖服务注册发现、远程调用、网关路由、流控容错、分布式事务与异步通信等核心场景。