1. Toy模板网首页
  2. > Toy博客

springboot和flask整合nacos，使用openfeign实现服务调用，使用gateway实现网关的搭建（附带jwt续约的实现）

10月前 作者：[奸笑]这个不是斜眼笑[奸笑] 分类：Toy博客 阅读(48) 违法举报

这篇具有很好参考价值的文章主要介绍了springboot和flask整合nacos，使用openfeign实现服务调用，使用gateway实现网关的搭建（附带jwt续约的实现）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

环境准备：

插件 版本
jdk 21
springboot

3.0.11
springcloud

2022.0.4
springcloudalibaba

2022.0.0.0
nacos 2.2.3（稳定版）
python 3.8

nacos部署（docker）

先创建目录，分别创建config，logs，data目录，单独创建一个容器

docker run -d \
-e MODE=standalone \
-p 8848:8848 \
-p 9848:9848 \
-p 7848:7848 \
-v /data/nacos/conf:/mnt/data3/dockerfiles/nacos/config \
-v /data/nacos/logs:/mnt/data3/dockerfiles/nacos/logs \
-v /data/nacos/data:/mnt/data3/dockerfiles/nacos/data \
--name nacos-mysql \
--restart=always \
nacos/nacos-server:v2.2.3

 将配置文件拷贝出来(主要是application.properties和logback.xml)

docker cp nacos-mysql:/home/nacos/conf ./

修改mysql的信息（修改文件application.properties）

springboot和flask整合nacos，使用openfeign实现服务调用，使用gateway实现网关的搭建（附带jwt续约的实现）,springboot,docker,spring boot,gateway,java,flask,后端,nacos,jwt

再次运行

docker run -d \
-e MODE=standalone \
-p 8848:8848 \
-p 9848:9848 \
-p 7848:7848 \
-v /data/nacos/conf:/mnt/data3/dockerfiles/nacos/config \
-v /data/nacos/logs:/mnt/data3/dockerfiles/nacos/logs \
-v /data/nacos/data:/mnt/data3/dockerfiles/nacos/data \
--name nacos-mysql \
--restart=always \
nacos/nacos-server:v2.2.3

开启服务器端口：

centos开启防火墙端口

 访问 ip:port/nacos

springboot和flask整合nacos，使用openfeign实现服务调用，使用gateway实现网关的搭建（附带jwt续约的实现）,springboot,docker,spring boot,gateway,java,flask,后端,nacos,jwt

出现此页面即为安装成功。

springboot注册到nacos

先贴一个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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.11</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>platform</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>platform</name>
    <description>platform</description>
    <properties>
        <java.version>21</java.version>
        <spring-cloud.version>2022.0.0</spring-cloud.version>
        <spring-cloud-alibaba.version>2022.0.0.0</spring-cloud-alibaba.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.2</version>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>org.springframework.cloud</groupId>-->
<!--            <artifactId>spring-cloud-starter-openfeign</artifactId>-->
<!--        </dependency>-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>3.0.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>edge-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>2.0.1.Final</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</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-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bootstrap</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.41</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>4.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-loadbalancer</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <repositories>
        <repository>
            <id>projectlombok.org</id>
            <url>https://projectlombok.org/edge-releases</url>
        </repository>
    </repositories>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件bootstrap.yml

spring:
  application:
    name: platform
  cloud:
    nacos:
      server-addr: ip:port
      config:
        file-extension: yml
        group: DEFAULT_GROUP
        prefix: ${sping.application.name}

springboot启动类

@SpringBootApplication
@EnableFeignClients
@EnableCaching
@EnableScheduling
@EnableDiscoveryClient
@RefreshScope
public class PlatformApplication {

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

}

启动后就可以将服务注册到nacos中

python集成flask注册到nacos

首先下载nacos的sdk包

pip install nacos-sdk-python

python代码

import glob
import nacos
import threading
from flask import request, send_file
from flask import Flask, Response

# nacos注册中心配置
SERVER_ADDRESS = "http://ip:port"
client = nacos.NacosClient(SERVER_ADDRESS)


def service_register():
    """
     ephemeral参数：是否是临时服务，应为false; 
     刚才上面也提到了，如果是 非临时实例，客户端就无需主动完成心跳检测。
     因此此处将服务注册为 非临时实例
    """
    client.add_naming_instance(
        "train", "ip", "port", ephemeral=False)

# 测试nacos
@app.route("/testNacos/<testId>", methods=["GET"])
def testNacos(testId):
    resMap = {}
    print("nacos: {}".format(testId))
    resMap["code"] = "200"
    resMap["message"] = "hello nacos"
    resMap["data"] = str(testId)
    response = Response(json.dumps(resMap), status=200,
                        content_type='application/json')
    return response

if __name__ == "__main__":
    # main()
    threading.Timer(5, service_register).start()
    app.run("0.0.0.0", 12352)

启动后就可以将服务注册到nacos中

到这里，服务注册到nacos已经完成了

使用openfeign进行服务间的调用

@FeignClient("train")
public interface InferRpcService {

    @GetMapping("/testNacos/{testId}")
    VitsResponse testNacos(@PathVariable String testId);
}

测试类

@Test
public void testNacosPy(){
    System.out.println(trainService.testNacos("232323"));
}

执行后

springboot和flask整合nacos，使用openfeign实现服务调用，使用gateway实现网关的搭建（附带jwt续约的实现）,springboot,docker,spring boot,gateway,java,flask,后端,nacos,jwt

经测试没有问题

gateway网关服务

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.11</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>gateway</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gateway</name>
    <description>gateway</description>
    <properties>
        <java.version>21</java.version>
        <spring-cloud.version>2022.0.4</spring-cloud.version>
        <spring-cloud-alibaba.version>2022.0.0.0</spring-cloud-alibaba.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</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-bootstrap</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>4.4.0</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.41</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件（bootstrap.yml）

spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: ip:port
      config:
        file-extension: yml
        group: DEFAULT_GROUP
        prefix: ${sping.application.name}
    gateway:
      # 下游服务https配置
      httpclient:
        ssl:
          use-insecure-trust-manager: true
      routes:
        - id: platform
          uri: lb://platform
          predicates:
            - Path=/api/platform/**
          filters:
            - StripPrefix=2

启动类

@RefreshScope
@EnableDiscoveryClient
@SpringBootApplication
public class GatewayApplication {

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

}

jwt续约

工具类

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;
import lombok.extern.slf4j.Slf4j;

import java.time.LocalDateTime;
import java.util.*;

@Slf4j
public class JWTUtils {

    private static final String SING = "auth";

    public static String getToken(Map<String, String> map) {

        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.MINUTE, 30);
        JWTCreator.Builder builder = JWT.create();
        map.forEach((k, v) -> {
            builder.withClaim(k, v);
        });
        String token = builder.withExpiresAt(instance.getTime())
                .sign(Algorithm.HMAC256(SING));
        return token;
    }

    public static DecodedJWT verify(String token) {
        return JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
    }

    /**
     * 查看是否需要续约
     *
     * @param jwtToken 前端的
     * @return -1过期，不需要续约  0 不需要操作  1 需要续约
     */
    public static int renewed(String jwtToken) {
        DecodedJWT verify = null;
        try {
            verify = JWT.require(Algorithm.HMAC256(SING)).build().verify(jwtToken);
            if (Objects.nonNull(verify)) {
                log.info("过期时间: {}", verify.getExpiresAt());
                Date date = verify.getExpiresAt();
                if (date.before(new Date())) {
                    log.info("token已过期");
                    return -1;
                } else if (DateUtils.toLocalDateTime(date).minusMinutes(15L).isAfter(LocalDateTime.now())) {
                    log.info("token处于正常状态");
                    return 0;
                } else if (DateUtils.toLocalDateTime(date).minusMinutes(15L).isBefore(LocalDateTime.now())) {
                    log.info("token需要续签");
                    return 1;
                }
            }
        } catch (JWTVerificationException | IllegalArgumentException e) {
            log.info("token已过期");
            return -1;
        }

        log.info("token已过期");
        return -1;
    }

    public static String doRenewed(String number) {
        Map<String, String> map = Collections.singletonMap("openid", number);
        return getToken(map);
    }
}

public class DateUtils {

    public static LocalDateTime toLocalDateTime(Date date){
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }
}

全局过滤器

import com.alibaba.fastjson.JSON;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.example.gateway.constant.Constant;
import com.example.gateway.constant.LoginConstant;
import com.example.gateway.constant.VitsCloneConstant;
import com.example.gateway.dto.response.CommonResponse;
import com.example.gateway.utils.JWTUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
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;

@Slf4j
@Component
public class AuthFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();

        // 获取请求路径
        String path = request.getPath().toString();
        log.info("path:{}", path);

        // 当前过滤器        
            if (StringUtils.contains(path, VitsCloneConstant.API_PREFIX)) {
            // 如果是登录接口，直接放行
            if (StringUtils.contains(path, LoginConstant.LOGIN_PATH)) {
                return chain.filter(exchange);
            }

            // 获取请求头中的Authorization字段
            String token = request.getHeaders().getFirst(LoginConstant.AUTHORIZATION_HEADER);

            // 如果校验失败，返回未授权状态
            if (StringUtils.isEmpty(token)) {
                CommonResponse<String> error = CommonResponse.error("无效的授权信息", "无效的授权信息");
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                return response.writeWith(Mono.just(response.bufferFactory().wrap(JSON.toJSONBytes(error))));
            }

            int renewed = JWTUtils.renewed(token);
            if (renewed == -1) {
                log.info("token已过期");
                CommonResponse<String> error = CommonResponse.error("无效的授权信息", "无效的授权信息");
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                return response.writeWith(Mono.just(response.bufferFactory().wrap(JSON.toJSONBytes(error))));
            } else if (renewed == 0) {
                log.info("jwtToken状态正常,无需操作");
                DecodedJWT verify = JWTUtils.verify(token);
                String openid = verify.getClaims().get("openid").asString();
                ServerHttpRequest modifiedRequest = exchange.getRequest()
                        .mutate()
                        .header("openId", openid)
                        .build();
                return chain.filter(exchange.mutate().request(modifiedRequest).build());
            } else {
                DecodedJWT verify = JWTUtils.verify(token);
                String openid = verify.getClaims().get("openid").asString();
                log.info("当前需要续约的jwtToken的用户手机号码: {}", openid);
                token = JWTUtils.doRenewed(openid);
                response.getHeaders().set(LoginConstant.AUTHORIZATION_HEADER, token);
                ServerHttpRequest modifiedRequest = exchange.getRequest()
                        .mutate()
                        .header("openId", openid)
                        .build();
                return chain.filter(exchange.mutate().request(modifiedRequest).build());
            }
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -900;
    }

}

常量类

public interface Constant {

    String TOKEN = "token";
}
public interface LoginConstant {

    String LOGIN_PATH = "/login";

    String AUTHORIZATION_HEADER = "token";
}
public interface VitsCloneConstant {

    String API_PREFIX="/api/platform/";
}

启动网关后，就可以通过网关访问服务了文章来源地址https://www.toymoban.com/news/detail-731760.html

到了这里，关于springboot和flask整合nacos，使用openfeign实现服务调用，使用gateway实现网关的搭建（附带jwt续约的实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Nacos基础（2）——nacos的服务器和命名空间 & springBoot整合nacos & 多个nacos配置的情况

    Nacos基础（2）——nacos的服务器和命名空间 & springBoot整合nacos & 多个nacos配置的情况

    1.nacos是服务发现、配置管理和服务管理平台； 2.nacos的命名空间–组–服务； 3.springboot整合nacos，版本的对应； 4.引入多个nacos配置的方法； 用户 服务管理，命名空间，集群管理 命名空间唯一id 自定义命名空间，公共命名空间 如何找到配置文件 新建配置 层级关系 bootstrap

    2024年02月03日
    浏览(45)
  • SpringBoot整合Nacos实现配置中心

    SpringBoot整合Nacos实现配置中心

    目录 1.Nacos定位 2.Nacos的安装配置 3.整合Nacos 3.1.Nacos安装 3.2.Nacos登录 3.3.配置Nacos      4.Nacos使用 4.1.引入 Maven 依赖 4.2.配置bootstrap.yml 4.3.Nacos配置类 4.4.启用Nacos服务 4.5.测试获取配置 5.加载多个配置文件 datasource-dev.yaml mybatis-plus-dev.yaml 本地文件bootstrap.yml Contro代码 测试结果

    2024年02月09日
    浏览(38)
  • SpringBoot 整合 Nacos 实现统一配置中心

    SpringBoot 整合 Nacos 实现统一配置中心

    目录 1. Nacos 功能 1.1 配置中心 2. SpringBoot 整合 Nacos 实现统一配置中心 2.1 Nacos 的部署安装 2.1.1 安装并启动 Nacos 2.1.2 开启Nacos控制台授权登录 2.1.3 将 Nacos 的数据源切换为 MySQL 2.2 实现配置中心 2.2.1 创建配置信息 2.2.2 SringBoot 使用配置中心 配置中心 注册中心         在实际

    2024年02月06日
    浏览(51)
  • 微服务整合Seata1.5.2+Nacos2.2.1+SpringBoot

    微服务整合Seata1.5.2+Nacos2.2.1+SpringBoot

    本文以seata-server-1.5.2，以配置中心、注册中心使用Nacos，store.mode=db（mysql）为例进行操作。 Seata简介及入门参看：SpringCloud入门实战（十五）分布式事务框架Seata简介 链接: http://seata.io/zh-cn/blog/download.html下载压缩包，解压至非中文目录。 本文版本环境： Spring Cloud Alibaba 2021.0

    2024年02月09日
    浏览(41)
  • SpringCloud Alibaba（一）微服务简介+Nacos的安装部署与使用+Nacos集成springboot实现服务注册+Feign实现服务之间的远程调用+负载均衡+领域划分

    SpringCloud Alibaba（一）微服务简介+Nacos的安装部署与使用+Nacos集成springboot实现服务注册+Feign实现服务之间的远程调用+负载均衡+领域划分

    目录 一.认识微服务 1.0.学习目标 1.1.单体架构 单体架构的优缺点如下： 1.2.分布式架构 分布式架构的优缺点： 1.3.微服务 微服务的架构特征： 1.4.SpringCloud 1.5Nacos注册中心 1.6.总结 二、Nacos基本使用安装部署+服务注册 （一）linux安装包方式单节点安装部署 1. jdk安装配置 2. na

    2024年02月09日
    浏览(47)
  • 微服务远程调用openFeign整合

    微服务远程调用openFeign整合

    ✅作者简介：大家好，我是Leo，热爱Java后端开发者，一个想要与大家共同进步的男人😉😉 🍎个人主页：Leo的博客 💞当前专栏： 微服务探索之旅 ✨特色专栏： MySQL学习 🥭本文内容：微服务远程调用openFeign整合 🖥️个人小站 ：个人博客，欢迎大家访问 📚个人知识库：

    2024年02月09日
    浏览(39)

  • 研发提速：nacos+openfeign环境下的本地链接服务

    项目研发过程中，经常会遇到与测试人员工作重叠的情况，十分影响效率。 做了一个修改，可以在本地环境启动项目后和测试环境交互，并且不影响测试环境，理论上也可以用于线上环境的异常的快速处理。 准备事项如下： 一：搭建本地的nacos服务。 二：导入测试环境相应

    2024年02月08日
    浏览(37)
  • springboot整合https使用自签名证书实现浏览器和服务器之间的双向认证

    springboot整合https使用自签名证书实现浏览器和服务器之间的双向认证

    效果描述： 本地环境  两台以上电脑  可以实现安装客户端证书的电脑可以访问springboot启动项目，没有安装客户端证书的电脑无法访问springboot启动项目 1.操作：需要安装openssl工具 工具包：Win64OpenSSL_Light-3_3_0.exe 或者Win64OpenSSL_Light-3_3_0.msi  官网：[ Downloads ] - /source/index.html

    2024年04月28日
    浏览(50)

  • 【springcloud微服务】Spring Cloud Alibaba 整合dubbo与openfeign

    dubbo与springcloud都可以单独作为微服务治理框架在生产中进行使用，但使用过springcloud的同学大概了解到，springcloud生态的相关组件这些年已经逐步停更，这就导致在服务架构演进过程中的迭代断层，以至于一些新的技术组件引入困难重重，于是在国内的市场上就有了升级版的

    2024年02月07日
    浏览(64)

  • 熟练使用Nacos、GateWay、OpenFeign、Sentinel常用组件

    Nacos 面试题 ： 请简述Nacos是什么，它主要解决了什么问题？ Nacos提供了哪些核心功能？ Nacos是如何支持服务发现的？ 如何使用Nacos作为配置中心？ Nacos的集群部署是如何实现的？ 答案 ： Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它主要解

    2024年04月13日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包