服务网关Gateway

最新推荐文章于 2024-07-29 18:00:00 发布
最新推荐文章于 2024-07-29 18:00:00 发布
阅读量124 收藏
点赞数
分类专栏： SpringCloud 分布式 文章标签： gateway 微服务 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38516942/article/details/127289961
版权

1.1.为什么要使用Gateway?

​ 大家都都知道在微服务架构中，一个系统会被拆分为很多个微服务。那么作为客户端要如何去调用这么多的微服务呢？如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去调用。这样的架构，会存在着诸多的问题：

  1. 客户端请求不同的微服务，就要维护不同的ip

  2. 客户端无法实现负载均衡

上面的这些问题可以借助API网关来解决：

在业界比较流行的网关，有下面这些：

  • Ngnix+lua

    使用nginx的反向代理和负载均衡可实现对api服务器的负载均衡及高可用 lua是一种脚本语言,可以来编写一些简单的逻辑,nginx支持lua脚本

  • Spring Cloud Gateway

    Spring公司为了替换Zuul而开发的网关服务，将在下面具体介绍。

注意：SpringCloud alibaba技术栈中并没有提供自己的网关，我们可以采用Spring Cloud Gateway来做网关。

1.2.Gateway介绍

1.2.1.Gateway是什么

​ Spring Cloud Gateway是Spring公司基于Spring 5.0，Spring Boot 2.0 和 Project Reactor等技术开发的网关，目标是替代 Netflflix ZUUL，并且基于 Filter 链的方式提供了路由，过滤，和限流等功能。

组件RPS(request per second)
Spring Cloud GatewayRequests/sec: 32213.38
Zuul1XRequests/sec: 20800.13

上表为Spring Cloud Gateway与Zuul的性能对比，从结果可知，Spring Cloud Gateway的RPS是Zuul的1.6倍

1.2.3.Gateway执行流程

  1. Gateway Client向Gateway Server发送请求

  2. HandlerMapping负责路由查找，并根据路由断言判断路由是否可用

  3. WebHandler创建过滤器链并调用

  4. 请求会一次经过PreFilter–微服务–PostFilter的方法，最终返回响应给Gateway Client

1.2.创建gateway工程

1.2.1.创建工程

1.2.1.pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud_parent</artifactId>
        <groupId>com.bjpowernode</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>api_gateway</artifactId>

    <dependencies>
        <!-- nacos启动器 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- gateway的启动器，gateway有自己的服务器。多个Tomcat会报错 -->
        <!--注意：不要添加spring-boot-starter-web启动器-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
    </dependencies>
</project>

注意：不要添加spring-boot-starter-web启动器

        <!--servlet运行的服务器是tomcat-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

1.2.1.application.yml

spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.239.131:8848
server:
  port: 9527

1.2.1.App

package com.bjpowernode;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GatewayApp {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApp.class, args);
    }
}

1.3.路由

1.3.1.通过断言条件路由

1.3.1.1.application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: sentinel-consumer #自定义的路由id，要求保持唯一即可
          uri: http://127.0.0.1:80 # 请求要转发到的地址
          predicates: #断言,断言通过才能有下一步的路由功能
            - Path=/consumer/**  #只有断言条件返回true(请求路径包含“/consumer”)时,才进行路由转发
1.3.1.2. 测试

1.开启服务和网关：

  • api_gateway
  • sentinel_consumer
  • sentinel_provider

2.浏览器访问：http://127.0.0.1:9527/consumer/getUserById/6

在这里插入图片描述

1.3.2.通过服务名路由

1.3.2.1.application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: sentinel-consumer #自定义的路由ID，保持唯一
          uri: lb://sentinel-consumer #lb代表从注册中心获取服务
          predicates: #断言
            - Path=/consumer/** #只有断言条件返回true(请求路径包含“/consumer”)时,才进行路由转发
1.3.2.2. 测试
  1. 重启网关：
  • api_gateway
  1. 浏览器访问：http://127.0.0.1:9527/consumer/getUserById/3
    在这里插入图片描述

1.4.断言

1.4.1.内置断言工厂

Spring Cloud Gateway 的功能很强大，前面我们只是使用了 predicates 进行了简单的条件匹配，其实Spring Cloud Gataway 帮我们内置了很多 Predicates 功能。

可参考spring官网：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gateway-request-predicates-factories

1.4.1.1.基于Datetime类型的断言工厂
  • 说明

此类型的断言根据时间做判断，主要有三个：

AfterRoutePredicateFactory：接收一个日期参数，判断请求日期是否晚于指定日期。

BeforeRoutePredicateFactory：接收一个日期参数，判断请求日期是否早于指定日期。

BetweenRoutePredicateFactory：接收两个日期参数，判断请求日期是否在指定时间段内。

  • 案例(均可重启后自测)
- After=2022-04-09T17:20:54.957+08:00[Asia/Shanghai]
1.4.1.2.基于RemoteAddr的断言工厂
  • 说明

RemoteAddrRoutePredicateFactory：接收一个IP地址段，判断请求主机地址是否在地址段中。

  • 案例
- RemoteAddr=192.168.1.1/24
1.4.1.3.基于Cookie的断言工厂
  • 说明

CookieRoutePredicateFactory：接收两个参数，cookie名字和一个正则表达式。判断请求cookie是否具有给定名称且值与正则表达式匹配。

  • 案例
- Cookie=chocolate, ch.
1.4.1.4.基于Header的断言工厂
  • 说明

HeaderRoutePredicateFactory：接收两个参数，标题名称和正则表达式。 判断请求Header是否 具有给定名称且值与正则表达式匹配。

  • 案例
- Header=X-Request-Id, \d+
1.4.1.3.基于Host的断言工厂
  • 说明

HostRoutePredicateFactory：接收一个参数，主机名模式。判断请求的Host是否满足匹配规则。

  • 案例
- Host=**.testhost.org
1.4.1.5.基于Method请求方法的断言工厂
  • 说明

MethodRoutePredicateFactory：接收一个参数，判断请求类型是否跟指定的类型匹配。

  • 案例
- Method=GET
1.4.1.6.基于Path请求路径的断言工厂
  • 说明

PathRoutePredicateFactory：接收一个参数，判断请求的URI部分是否满足路径规则。

  • 案例
- Path=/foo/{segment}
1.4.1.7.基于Query请求参数的断言工厂
  • 说明

QueryRoutePredicateFactory ：接收两个参数，请求param和正则表达式， 判断请求参数是否具有给定名称且值与正则表达式匹配。

  • 案例
- Query=baz, ba.

1.4.2.自定义路由断言工厂

1.4.2.1.内置断言工厂的实现原理

我们来设定一个场景: 假设我们的应用仅仅让age>18的人来访问，在自定义断言工厂之前，我们先看内置断言工厂的实现原理，打开AfterRoutePredicateFactory这个内置断言工厂：

在这里插入图片描述

1.4.2.2.创建断言工厂(第一步自定义断言工厂类)
package com.bjpowernode.PredicateFactory;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * 自定义断言工厂
 * Config 是一个类  需要我们自己去定义
 */
@Component
public class AgeRoutePredicateFactory extends AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> {

    public AgeRoutePredicateFactory() {
        super(AgeRoutePredicateFactory.Config.class);
    }

    //读取配置文件的中参数值 给他赋值到配置类中的属性上
    @Override
    public List<String> shortcutFieldOrder() {
        //这里的顺序要跟配置文件中的参数顺序一致
        return Arrays.asList("minAge", "maxAge");
    }

    //断言逻辑
    @Override
    public Predicate<ServerWebExchange> apply(AgeRoutePredicateFactory.Config config) {
        return new Predicate<ServerWebExchange>() {
            @Override
            public boolean test(ServerWebExchange serverWebExchange) {
                //1 接收前台传入的age参数
                String ageStr = 
                    serverWebExchange.getRequest().getQueryParams().getFirst("age");
                //2 先判断是否为空
                if (StringUtils.isNotEmpty(ageStr)) {
                    //3 如果不为空,再进行路由逻辑判断
                    int age = Integer.parseInt(ageStr);
                    if (age < config.getMaxAge() && age > config.getMinAge()) {
                    //4.通过判断则放行
                        return true;
                    } else {
                        return false;
                    }
                }
                return false;
            }
        };
    }

    //自定义一个配置类, 用于接收配置文件中的参数
    @Data
    @NoArgsConstructor
    public static class Config {
        private int minAge;//18
        private int maxAge;//60
    }
}
1.4.2.3.配置断言(第二步application.yml配置文件)
spring:
  cloud:
    gateway:
      routes:
        - id: sentinel-consumer
          uri: lb://sentinel-consumer
          predicates:
            - Path=/consumer/**
            - Age=18,60 #配置断言必须使用断言工厂类名的前缀
1.4.2.4.测试
  1. 浏览器访问：http://127.0.0.1:9527/consumer/getUserById/1?age=17

在这里插入图片描述

  1. 浏览器访问：http://127.0.0.1:9527/consumer/getUserById/1?age=19
    在这里插入图片描述

1.5.过滤

Spring Cloud Gateway提供了过滤器的功能，可以对进入网关的请求和响应做处理：

在这里插入图片描述

Spring Cloud Gateway 的 Filter 从作用范围可分为另外两种GatewayFilter 与 GlobalFilter。

  • GatewayFilter：应用到单个路由或者一个分组的路由上。

  • GlobalFilter：应用到所有的路由上。

1.5.1.内置过滤器工厂

Spring Cloud Gateway中通过GatewayFilter的形式内置了很多不同类型的局部过滤器，可参考spring官网：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gatewayfilter-factories

过滤器工厂作用
AddRequestHeader给当前请求添加一个请求头
AddRequestParameter为原始请求添加请求参数
AddResponseHeader给响应结果中添加一个响应头
DedupeResponseHeader去掉重复请求头
Spring Cloud CircuitBreaker断路器
FallbackHeaders添加熔断后的异常信息到请求头
MapRequestHeader将上游请求头的值赋值到下游请求头
PrefixPath匹配的路由添加前缀
PreserveHostHeader保留原请求头
RequestRateLimiter限制请求的流量
RedirectTo重定向
RemoveRequestHeader移除请求中的一个请求头
RemoveResponseHeader从响应结果中移除有一个响应头
RemoveRequestParameter移除请求参数
RewritePath重写路径
RewriteLocationResponseHeader重写响应头中Location的值
RewriteResponseHeader重写响应头
SaveSession向下游转发请求前前置执行WebSession::save的操作
SecureHeaders禁用默认值
SetPath设置路径
SetRequestHeader重置请求头
SetResponseHeader修改响应头
SetStatus修改响应的状态码
StripPrefix对指定数量的路径前缀进行去除
Retry重试
RequestSize请求大小大于限制时，限制请求到达下游服务
SetRequestHostHeader重置请求头值
Modify a Request Body修改请求体内容
Modify a Response Body修改响应体内容
Relay将 OAuth2 访问令牌向下游转发到它所代理的服务
CacheRequestBody在请求正文发送到下游之前缓存请求正文并从 exchagne 属性获取正文

1.5.2.自定义过滤器工厂

需求：记录调用远程服务所需要的时间

1.5.2.1.创建过滤器工厂
package com.bjpowernode.FilterFactory;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
/**
 * 过滤器链
 */
@Component
public class LogGatewayFilterFactory
        extends AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> {

    public LogGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, 
                                     GatewayFilterChain chain) {
                if (config.getLog()) {
                    long beginTime = System.currentTimeMillis();
                    return chain.filter(exchange).then(Mono.fromRunnable(new Runnable() {
                        @Override
                        public void run() {
                            long endTime = System.currentTimeMillis();
                            System.out.println("time of call service ：" + 
                                               			(endTime - beginTime));
                        }
                    }));
                }
                //不通过不放行
                return null;
            }
        };
    }

    //读取配置文件中的参数 赋值到配置类中
    @Override
    public List<String> shortcutFieldOrder() {
        //这里的顺序要跟配置文件中的参数顺序一致
        return Arrays.asList("log");
    }

    //自定义一个配置类, 用于接收配置文件中的参数
    public static class Config {
        private boolean log;

        public Config() {
        }

        public Config(boolean log) {
            this.log = log;
        }

        public boolean getLog() {
            return log;
        }

        public void setLog(boolean log) {
            this.log = log;
        }
    }
}

在这里插入图片描述

1.5.2.2.配置过滤器
spring:
  cloud:
      routes:
        - id: sentinel-consumer
          uri: lb://sentinel-consumer
          predicates:
            - Path=/consumer/**
          filters: #自定义过滤器
            - Log=true
1.5.2.3.测试
  1. 浏览器访问：http://127.0.0.1:9527/consumer/getUserById/1

在这里插入图片描述

1.5.3.自定义全局过滤器

  • 需求：

在网关过滤器中通过Token 判断用户是否登录

  • 全局过滤器（GlobalFilter）：

作用于所有路由，Spring Cloud Gateway 定义了Global Filter接口，用户可以自定义实现自己的Global Filter。通过全局过滤器可以实现对权限的统一校验，安全性验证等功能，并且全局过滤器也是程序员使用比较多的过滤器。Spring Cloud Gateway内部也是通过一系列的内置全局过滤器对整个路由转发进行处理如下：
在这里插入图片描述

1.5.2.1.创建过滤器

在服务网关中定义过滤器只需要实现 GlobalFilter, Ordered接口就可对请求进行拦截与过滤。

package com.bjpowernode.FilterFactory;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
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.nio.charset.StandardCharsets;

@Component
public class LoginFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        String token = request.getQueryParams().getFirst("token");
        if (token == null) {
            BaseResult data = new BaseResult(401, "未登录");
            return response(response,data);
        }
        //放行
        return chain.filter(exchange);
    }

    private Mono<Void> response(ServerHttpResponse response, BaseResult data) {
        String jsonData = null;
        try {
            jsonData = new ObjectMapper().writeValueAsString(data);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        DataBuffer buffer = 
            response.bufferFactory().wrap(jsonData.getBytes(StandardCharsets.UTF_8));
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }

    /**
     * 过滤器的执行顺序：通过整数表示顺序，数值越小，优先级越高
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
}
class BaseResult {
    private int status;
    private String msg;
    private Object data;

    public BaseResult() {
    }

    public BaseResult(int status, String msg) {
        this.status = status;
        this.msg = msg;
    }

    public BaseResult(int status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}
1.5.2.2.测试

  1. 不加token：http://127.0.0.1:9527/gateway/consumer/getUserById?id=1&nam=zs
    在这里插入图片描述

  2. 加token：http://127.0.0.1:9527/consumer/getUserById/1?token=123

在这里插入图片描述

1.5.限流

网关是所有请求的公共入口，所以可以在网关进行限流，而且限流的方式也很多，我们本次采用前 面学过的Sentinel组件来实现网关的限流。

1.5.1.api_gateway

1.5.1.1.pom.xml
        <!--sentinel的启动器-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!--spring cloud gateway整合sentinel的启动器-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>
1.5.1.2.application.yml
spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8080 #指定sentinel的地址
1.5.1.3.自定义异常处理
package com.bjpowernode.exception;

import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.alibaba.fastjson.JSON;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class GatewayConfig {
 
    @PostConstruct
    public void init() {
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange exchange,
                                                      				Throwable t) {
                // 自定义异常信息
                Map map = new HashMap<>();
                map.put("status", 200);
                map.put("msg", "接口被限流了");
                return ServerResponse.status(HttpStatus.OK)
                        .contentType(MediaType.APPLICATION_JSON)
                        .body(BodyInserters.fromValue(map));
            }
        };
        //自定义异常处理
        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }
}

1.5.2.测试

  • 先启动sentinel的持久化到nacos的控制台
  • http://127.0.0.1:8080 账号和密码都是sentinel
  1. 新增流控规则
    在这里插入图片描述
  • 5秒内访问到第3次
    在这里插入图片描述
  1. 高并发访问：http://127.0.0.1:9527/consumer/getUserById/1

在这里插入图片描述

易未成
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7.Gateway服务网关
01-01
"Spring Cloud Gateway 服务网关" Spring Cloud Gateway 是 Spring Boot 应用提供的 API 网关支持，具有强大的智能路由与过滤器功能。 Gateway 是在 Spring 生态系统之上构建的 API 网关服务，基于 Spring 5，...
SpringCloud网关Gateway架构解析
08-24
SpringCloud 网关 Gateway 架构解析 SpringCloud 网关 Gateway 架构解析是当前微服务...网关架构是微服务架构中不可或缺的一部分，它可以提高业务灵活性、安全性、监控性和扩展性，帮助开发者更好地构建微服务架构。
springboot整合gateway实现网关功能
12-13
SpringBoot整合Gateway实现网关功能是一项常见的微服务架构设计任务，它可以帮助我们集中管理路由，提供过滤器功能，以及实现动态路由、限流、熔断等高级特性。下面将详细介绍这个过程及其涉及的关键知识点。 首先...
SpringCloud网关组件gateway
03-14
综上所述，SpringCloud Gateway 作为一个强大的微服务网关，为开发者提供了构建高效、灵活的 API 网关的平台，它不仅简化了服务之间的通信，还为服务治理、安全性、监控等提供了丰富的解决方案。在实际开发中，合理...
Spring Cloud Gateway
m0_75227031的博客
07-24 922
但是当前所有微服务的接⼝都是直接对外暴露的, 可以直接通过外部访问. 为了保证对外服务的安全性,服务端实现的微服务接⼝通常都带有⼀定的权限校验机制. 由于使⽤了微服务, 原本⼀个应⽤的的多个模块拆分成了多个应⽤, 我们不得不实现多次校验逻辑. 当这套逻辑需要修改时, 我们需要修改多个应⽤, 加重了开发⼈员的负担.引入：通过Eureka, Nacos解决了服务注册, 服务发现的问题, 使⽤Spring Cloud LoadBalance解决了负载均衡的问题, 使⽤OpenFeign解决了远程调⽤的问题.
微服务（网关路由）
qq_3512323979的博客
07-24 905
无论是还是都支持自定义，只不过编码方式、使用方式略有差别。自定义不是直接实现，而是实现。@Component@Override@Override// 获取请求// 编写过滤器逻辑System.out.println("过滤器执行了");// 放行注意：该类的名称一定要以为后缀！spring:cloud:gateway:- PrintAny # 此处直接以自定义的GatewayFilterFactory类名称前缀类声明过滤器@Component。
菜鸟从0学微服务——MyBatis-Plus
laolitou_1024的博客
07-25 1061
针对有编程基础，开始学习微服务的同学，我们陆续推出从0学微服务的笔记分享。力求从各个中间件的使用来反思这些中间件的作用和优势。 会分享的比较快，会记录demo演算和中间件的使用过程，至于细节的理论知识请自主查阅相关资料并学习。满是干货，注意查收。 本期我们开始学习MyBatis-Plus。
【SpringCloud】 微服务分布式环境下的事务问题，seata大合集
qq_50446805的博客
07-23 1180
前面聊了一些常见的分布式事务方案，接下来我们所主要实现的是通过微服务的阿里组件，seata来实现微服务领域中的分布式事务。Seata 是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata 将为用户提供了 AT、TCC、SAGA 和 XA 事务模式，为用户打造一站式的分布式解决方案。AT模式（Auto Transcation）是阿里首推的，因为对代码是零侵入的，使用起来很方便。TC：班主任，某某学生成绩下滑，学校里打架，则通知家长回家好好教育（驱动回滚）；
Gateway网关分布式微服务认证鉴权
pscool的博客
07-25 652
（之前有使用过这种实现，定义个公共认证模块的jar包，各个微服务引入这个jar包，jar包中引入了security，开启全局校验，各个微服务可以使用注解，各个微服务可以覆盖jar包中的关键配置类实现。但是，后来遇到微服务之间互相调用时也得把这个令牌给带上去以供被调用的微服务作权限校验的问题，这样就导致权限校验管理混乱。所以还不如直接在网关层作校验，然后校验通过后，将用户身份权限写成请求头，在网关转发的时候携带给下面的微服务，后面微服务如果有必要作权限校验的话，可以使用AOP自主实现校验逻辑）
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 256
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1028
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 106
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 556
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
最新发布
前端、移动端、后端源码级底层原理分享
07-29 735
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 686
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 440
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 388
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 138
新建springboot项目找不到java版本8?
网关 gateway
08-17
网关（gateway）是一个网络设备或软件，用于连接不同网络之间的通信。它充当了网络中两个或多个不同协议、不同物理媒介或不同网络体系结构之间的桥梁。 网关的作用是在不同网络之间转发数据包。当数据包从一个网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值