Spring Cloud

Spring Cloud 是一系列框架的有序集合,它利用 Spring Boot 的开发便利性简化了分布式系统的开发,比如服务发现、服务网关、服务路由、链路追踪等。Spring Cloud 并不重复造轮子,而是将市面上开发得比较好的模块集成进去,进行封装,从而减少了各模块的开发成本。换句话说:Spring Cloud 提供了构建分布式系统所需的“全家桶”。

其核心思想是**将成熟的分布式组件进行统一封装与集成,提供开箱即用的“全家桶”式解决方案**,从而降低微服务架构的搭建、治理与维护成本。

痛点:传统分布式系统需要自行拼装、配置和治理各类中间件,重复造轮子且运维成本高;Spring Cloud 通过标准化封装让开发者专注业务逻辑。
Spring Cloud Alibaba 2024 版

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` 统一维护 DTO 与 FeignClient,其他微服务直接引入该模块,实现一处定义、多处复用。
  1. 新建一个模块 richu-api,引入 openFeign 的依赖。
  2. 配置 DTO 和 Client。
  3. 在其他模块引入:
<dependency>
    <groupId>com.richu</groupId>
    <artifactId>richu-api</artifactId>
    <version>1.0.0</version>
</dependency>
  1. 指定包名扫描:
@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 使用

网关是网络的关口,负责请求的路由、转发与身份校验。

  1. 创建新模块。
  2. 引入网关依赖:
<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>
  1. 编写启动类:
@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class,args);
    }
}
  1. 配置路由规则:
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 模块拦截器中获取,便于其他业务模块直接使用。

  1. 定义拦截器类:
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);
    }
}
  1. 配置类:
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UseInfoInterceptor());
    }
}
  1. 配置自动装配:
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.richu.common.config.MyBatisConfig,\
  com.richu.common.config.MvcConfig,\
  com.richu.common.config.JsonConfig
**注意** `MvcConfig` 类会被没有 SpringMvc 的环境加载,此时会报错。

解决措施,在 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());
       }
    }
}
**提示** 将路由配置写入 Nacos 的 `gateway-routes.json` 配置文件中。

9. 微服务保护与分布式事务

8.1 解决方案

雪崩问题:微服务调用链的某个服务故障,导致整个链路的微服务都不可用。

方案 说明
请求限流 限制访问微服务的请求的并发量
线程隔离 舱壁模式,隔离资源避免连锁耗尽
服务熔断 由断路器统计请求的异常比例或慢调用比例,如果超出阈值则会熔断该业务,拦截该接口的请求

Sentinel 与 Hystrix 对比:

Sentinel Hystrix
隔离策略 信号量隔离 线程池隔离/信号量隔离
熔断降级策略 基于慢调⽤⽐例或异常⽐例 基于失败⽐率
实时指标实现 滑动窗⼝ 滑动窗⼝(基于 RxJava)
规则配置 ⽀持多种数据源 ⽀持多种数据源
扩展性 多个扩展点 插件的形式
基于注解的⽀持 ⽀持 ⽀持
限流 基于 QPS,⽀持基于调⽤关系的限流 有限的⽀持
流量整形 ⽀持慢启动、匀速排队模式 不⽀持
系统⾃适应保护 ⽀持 不⽀持
控制台 开箱即⽤,可配置规则、查看秒级监控、机器发现等 不完善
常⻅框架的适配 Servlet、Spring Cloud、Dubbo、gRPC 等 Servlet、Spring Cloud Netflix

8.2 Sentinel

8.2.1 安装控制台

alibaba/Sentinel: A powerful flow control component enabling reliability, resilience and monitoring for microservices. (面向云原生微服务的高可用流控防护组件) (github.com)

启动控制台:

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
**定义 FallbackFactory** 为 FeignClient 提供降级处理类。
@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 服务

  1. 导入数据库:
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;
  1. 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

  1. 导入依赖:
<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>
  1. 在 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”,最后生成行锁。以上操作全部在一个数据库事务内完成,保证了一阶段操作的原子性。

**提示** 因为 Seata 默认使用 AT 模式,所以可不用额外配置,只需将 `undo_log` 数据表添加到每一个微服务数据库中即可。

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 与语言无关,更符合微服务中独立性的要求。

  1. 创建 Queue。
  2. 在父工程引入依赖:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  1. 配置 yaml 文件:
spring:
  rabbitmq:
    host: 192.168.3.133
    port: 5672
    virtual-host: /
    username: richu
    password: 12345678
  1. 测试发送:
@SpringBootTest
class PublisherApplicationTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testqueue(){
        String queueName = "queue1";
        String Message = "hello mq";
        
        rabbitTemplate.convertAndSend(queueName,Message);
    }
}
  1. 测试接收:
@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
**说明** 同一个消息只能被一个消费者处理。默认情况为轮询,但不同设备的处理速度可能不同,从而导致慢的很忙、快的很闲。可通过 `prefetch` 实现能者多劳。
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 的默认转换器,避免消息体可读性差与类型问题。

  1. 引入依赖:
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
  1. 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 业务幂等性

执行一个业务一次或者多次,对业务状态的影响保持一致。

**实现方式** 1)给每一个消息设置一个唯一 id(发送者方案,不太推荐);2)基于业务本身做判断(推荐)。

发送者方案:

@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 分词:

  1. 最细粒度分词(ik_max_word):
POST /_analyze
{
  "analyzer": "ik_max_word",
  "text": "我爱学习,我每天学习"
}
  1. 最常用 / 最合理分词(ik_smart):
POST /_analyze
{
  "analyzer": "ik_smart",
  "text": "我爱学习,我每天学习"
}

运行结果(ik_smart 示例):

我
爱
学习
我
每天
学习

11.2 倒排索引

概念 说明
文档(Document) 每条数据就是一个文档
词条(Term) 文档按照语义分成的词语
POST /_analyze
{
  "analyzer":"standard",
  "text":"我爱学习,我每天学习"
}
**扩展分词器** 通过 `IkAnalyzer.cfg.xml` 配置扩展词典。
<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":{
    "字段名":"值"
  }
}
  1. 批处理请求:
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 等组件的有机整合,提供了一套开箱即用的微服务“全家桶”,覆盖服务注册发现、远程调用、网关路由、流控容错、分布式事务与异步通信等核心场景。