SpringCloudAlibaba2.2.6.RELEASE集成Gateway并实现JWT鉴权

最新推荐文章于 2024-05-20 10:19:53 发布
最新推荐文章于 2024-05-20 10:19:53 发布
阅读量1.4k 收藏 8
点赞数
文章标签： gateway spring cloud 微服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46122292/article/details/126664560
版权
  • 搭建前提

本文基于Nacos作为注册中心，进行搭建，所以前提是已经搭建了Nacos

Nacos单机版搭建教程
Nacos集群版搭建教程

1.导入依赖

注意：gateway的pom文件不要引用MVC的依赖包，不然会报错。

  <dependencies>
        <!--网关gateway-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

        <!-- openfeign服务调用 此处是避免依赖冲突才引入的-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <!-- 服务注册/发现-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!-- 引入自己定义的api-commons,这样就可以使用共有类 ,注意将自己的依赖包中排除mvc相关依赖，避免依赖传递-->
        <dependency>
            <groupId>com.wf</groupId>
            <artifactId>api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

2.编写启动类

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;


/**
 * @Description: 网关微服务
 */
@EnableDiscoveryClient
@SpringBootApplication
@Slf4j
public class GatewayServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayServiceApplication.class, args);
        log.info("网关微服务启动成功");
    }
}

3.编写配置文件

server:
  port: 9005
spring:
  application:
    name: gateway-service
  cloud:
    #nacos相关配置-------------------------------------------------
    nacos:
      discovery:
        #配置Nacos服务注册地址
        server-addr: 192.168.31.78:8848
    gateway:
      discovery:
        locator:
          #开启注册中心路由功能
          enabled: true

4.最终项目结构
在这里插入图片描述

  • 测试注册中心路由功能
    1.启动全部微服务
    在这里插入图片描述
    2.不通过Gateway访问9004微服务
    请求：http://localhost:9004/test
    在这里插入图片描述
    返回结果：
    在这里插入图片描述

3.通过Gateway访问9004微服务
请求：http://localhost:9005/message-services/test

注：本次请求携带了9004微服务的服务名称且端口号已经换成了9005
在这里插入图片描述

返回结果：
在这里插入图片描述

  • 自定义路由配置
    1.新增yml文件内容
server:
  port: 9005
spring:
  application:
    name: gateway-service
  cloud:
    #nacos相关配置-------------------------------------------------
    nacos:
      discovery:
        #配置Nacos服务注册地址
        server-addr: 192.168.31.78:8848
    gateway:
      discovery:
        locator:
          #开启注册中心路由功能
          enabled: true
      routes:
       #该组配置的一个id值，需要保证他的唯一，可以设置为和服务名一致
        - id: message-services
         #通过条件匹配之后需要路由到的新的服务地址，lb:// 表示开启负载均衡策略去路由 
          uri: lb://message-services
           #url的匹配条件,及断言，规则为url中必须携带 /user/management才能进行转发
          predicates:
            - Path=/message/board/**
          #在路由前对请求的地址进行额外的其他操作，例如拼接或者裁减等。 此处的作用在于去除掉 predicates中配置的路径，因为该路径只是断言，并无实际地址
          filters:
           #表示删除第二个路径，即删除predicates中配置的/message/board
            - StripPrefix=2

2.再次使用上文中的测试地址测试
请求：http://localhost:9005/message-services/test
在这里插入图片描述
返回结果：
在这里插入图片描述
提示404访问不到资源，因为此处使用了自定义路由，那么就应该携带自定义的请求路径

3.使用自定义的请求路由访问
请求：http://localhost:9005/message/board/test

注：此处使用的/message/board在9004微服务中并不存在该资源，此处只是在gateway中yml文件中predicates配置的自定义路由，然后通过filters中的配置去除掉/message/board得到9004微服务的真实资源地址
在这里插入图片描述
返回结果：
在这里插入图片描述

解析请求过程：

在这里插入图片描述

  • JWT统一鉴权
    1.配置过滤器
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.deploy.nativesandbox.comm.Response;
import com.wf.apicommons.utils.CodeEnum;
import com.wf.apicommons.utils.CommonResult;
import com.wf.apicommons.utils.JWTUtils;
import com.wf.apicommons.utils.MD5Util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.ratelimit.RateLimiter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
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.Flux;
import reactor.core.publisher.Mono;

/**
 * @Description: token鉴权过滤
 */
@Component
@Slf4j
public class AuthJwtFilter implements GlobalFilter, Ordered {

    /**
     * 无需鉴权的URL
     */
    private static  final String[] skipAuthUrls={"/user/login","/user/register","/user/getCode/**"};

    @Override
    public Mono<Void>
    filter(ServerWebExchange exchange,GatewayFilterChain chain) {
        //获取请求url地址
        String url =exchange.getRequest().getURI().getPath();
        //跳过不需要验证的路径
        if (null != skipAuthUrls && isSkipUrl(url)) {
            return chain.filter(exchange);
        }

        //从请求头中取得token
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        //标识当前请求来源于网关，屏蔽非法请求

        exchange.getRequest().mutate().header("RequestSource", MD5Util.encryption("from_gateway")).build();

        CommonResult<String> result=new CommonResult<>();

        //判断token是否为null
        if(!StrUtil.hasBlank(token)){
            try{
                //验证令牌
                JWTUtils.verify(token);
                //放行请求
                return chain.filter(exchange);
            } catch (SignatureVerificationException e) {
                //无效签名
                result.setCode(CodeEnum.JWT_INVALID.getCode());
                result.setData(CodeEnum.JWT_INVALID.getMessage());
            } catch (TokenExpiredException e) {
                //token过期
                result.setCode(CodeEnum.JWT_OVERDUE.getCode());
                result.setData(CodeEnum.JWT_OVERDUE.getMessage());
            } catch (AlgorithmMismatchException e) {
                //token算法不一致\
                result.setCode(CodeEnum.JWT_ALGORITHM_INCONSISTENCY.getCode());
                result.setData(CodeEnum.JWT_ALGORITHM_INCONSISTENCY.getMessage());
            } catch (Exception e) {
                //token失效
                result.setCode(CodeEnum.JWT_LOSE_EFFECT.getCode());
                result.setData(CodeEnum.JWT_LOSE_EFFECT.getMessage());
            }
        }else{
            //无效签名
            result.setCode(CodeEnum.JWT_INVALID.getCode());
            result.setData(CodeEnum.JWT_INVALID.getMessage());
        }



        return getFailResponse(exchange.getResponse(),result);
    }

    @Override
    public int getOrder() {
        return 0;
    }

    /**
     * 判断当前访问的url是否开头URI是在配置的忽略
     * url列表中
     *
     * @param url
     * @return
     */
    public boolean isSkipUrl(String url) {
        for (String skipAuthUrl : skipAuthUrls) {
            if (url.startsWith(skipAuthUrl)) {
                return true;
            }
        }
        return false;
    }


    /**
     * 获取失败返回信息
     * @param response
     * @param result
     * @return
     */
    private Mono<Void> getFailResponse(ServerHttpResponse response, CommonResult<String> result) {
        DataBuffer buffer = null;
        try {
        //将map转化成json，response使用的是Jackson
        String resultStr = new ObjectMapper().writeValueAsString(result);
            response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
            response.getHeaders().set("Access-Control-Allow-Origin","*");
            response.setStatusCode(HttpStatus.OK);
            response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
            buffer = response.bufferFactory().wrap(resultStr.getBytes("UTF-8"));
        } catch (Exception e) {
            log.info("gateway鉴权错误，{}",e.getMessage());
            e.printStackTrace();
        }
        return response.writeWith(Flux.just(buffer));
    }

}

此处的使用到的自定义工具类：
CodeEnum


import lombok.Data;

/**
 * 状态码枚举
 */
public enum CodeEnum {

    /**操作成功**/
    SUCCESS(200,"操作成功"),
    /**服务调用异常**/
    SERVICE_CALL_EXCEPTION(400,"服务调用异常"),
    /**操作失败**/
    ERROR(500,"操作失败"),
    /**参数不合法**/
    ILLEGAL_PARAMETER(5001,"参数不合法"),
    /**验证码已失效**/
    VERIFICATION_CODE_FAILURE(5002,"验证码已失效"),
    /**用户昵称重复**/
    DUPLICATE_NICKNAME(5003,"用户昵称重复"),
    /**用户名或密码错误**/
    LOGIN_FAILED(5004,"用户名或密码错误"),
    /**文件上传失败**/
    FILE_UPLOAD_FAILED(5005,"文件上传失败"),
    /**资源不存在*/
    RESOURCE_DOES_NOT_EXIST(5006,"资源不存在"),
    /**无效签名**/
    JWT_INVALID(2001,"无效签名"),
    /**token过期**/
    JWT_OVERDUE(2002,"token过期"),
    /**token算法不一致**/
    JWT_ALGORITHM_INCONSISTENCY(2003,"token算法不一致"),
    /**token失效**/
    JWT_LOSE_EFFECT(2004,"token失效"),
    /**非法请求**/
    ILLEGAL_REQUEST(2005,"非法请求,请求来源不合法");

    /**
     * 自定义状态码
     **/
    private Integer code;
    /**自定义描述**/
    private String message;

    CodeEnum(Integer code, String message){
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }
    public String getMessage() {
        return message;
    }
}

CommonResult


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 请求信息类，用于返回请求是否成功
 * @param <T>
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T>{
    /**
     * 响应状态码
     */
    private int code;

    /**
     * 响应结果描述
     */
    private String message;

    /**
     * 返回的数据
     */
    private T data;

    /**
     * 成功返回
     * @param data
     * @param <T>
     * @return
     */
    public static <T> CommonResult<T> success(T data) {
        CommonResult<T> response= new CommonResult<>();
        response.setCode(CodeEnum.SUCCESS.getCode());
        response.setMessage(CodeEnum.SUCCESS.getMessage());
        response.setData(data);
        return response;
    }

    /**
     *  失败返回,自定义code
     * @param code
     * @param message
     * @param <T>
     * @return
     */
    public static <T> CommonResult<T> fail(Integer code, String message) {
        CommonResult<T> response = new CommonResult<>();
        response.setCode(code);
        response.setMessage(message);
        return response;
    }

    /**
     *  失败返回
     * @param codeEnum
     * @param <T>
     * @return
     */
    public static <T> CommonResult<T> fail(CodeEnum codeEnum) {
        CommonResult<T> response = new CommonResult<>();
        response.setCode(codeEnum.getCode());
        response.setMessage(codeEnum.getMessage());
        return response;
    }
    /**
     *  失败返回
     * @param message
     * @param <T>
     * @return
     */
    public static <T> CommonResult<T> fail(String message) {
        CommonResult<T> response = new CommonResult<>();
        response.setCode(CodeEnum.ERROR.getCode());
        response.setMessage(message);
        return response;
    }

}

JWTUtils 



import cn.hutool.jwt.JWTUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;

/**
 * @Description: JWT工具类
 */
public class JWTUtils {
    //秘钥
    private static final String SIGNATURE = "323123213123213123313";
    //过期时间为1天
   public static  final Integer EXPIRATION_TIME= 1* 24 * 60 * 60;



    /**
     * 生成token
     * @param payload token需要携带的信息
     * @return token字符串
     */
    public static String getToken(Map<String,String> payload){
        // 指定token过期时间为1天
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, EXPIRATION_TIME);
        JWTCreator.Builder builder = JWT.create();
        // 构建payload
        payload.forEach((k,v) -> builder.withClaim(k,v));
        // 指定过期时间和签名算法
        return  builder.withExpiresAt(calendar.getTime()).sign(Algorithm.HMAC256(SIGNATURE));
    }




    /**
     * 验证token
     * @param token
     */
    public static void verify(String token){
        JWT.require(Algorithm.HMAC256(SIGNATURE)).build().verify(token);
    }

    /**
     * 获取token中payload
     * @param token
     * @return
     */
    public static DecodedJWT getToken(String token){
        return JWT.require(Algorithm.HMAC256(SIGNATURE)).build().verify(token);
    }

}

MD5Util 

import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;


/**
 * @Description: MD5工具类
 */
public class MD5Util {

    /**
     * 加密
     * @param content 需要加密的内容
     * @return
     */
    public static String encryption(String content) {
        if(StrUtil.isNotBlank(content)){
            return SecureUtil.md5(content);
        }
        return null;
    }

    /**
     * 验证
     *
     * @param ciphertext 密文
     * @return
     */
    public static boolean verifyingCiphertext(String ciphertext,String content) {
        if(StrUtil.isNotBlank(ciphertext)&&StrUtil.isNotBlank(content)){
            return   ciphertext.equals(encryption(content));
        }
       return false;
    }


}

注：以上代码需要引入胡图工具包

    <!--胡图工具包-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.2</version>
        </dependency>
  • 让微服务只允许来自网关的请求

真实场景中，往往是把微服务放到各个服务器，并不会对外暴露出来的，仅仅会对网关处的服务器进行开放，因此最好的做法就是不会暴露服务，nginx反向代理到网关，网关转发到对应的服务，真正对外提供的仅有nginx

此处我们在gateway转发请求是在Header中存入一个加密标识（from_gateway），等转发到微服务后再将其获取出来，进行解密，比对，只有正确的才放行

上述AuthJwtFilter类添加如下代码：

     //标识当前请求来源于网关，屏蔽非法请求
 exchange.getRequest().mutate().header("RequestSource", MD5Util.encryption("from_gateway")).build();

在9004微服务中新增如下代码：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.wf.apicommons.utils.CodeEnum;
import com.wf.apicommons.utils.CommonResult;
import com.wf.apicommons.utils.MD5Util;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


/**
 * @Description: JWT验证拦截器
 */
public class JWTInterceptor implements HandlerInterceptor {


    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        CommonResult<String> result=new CommonResult<>();
        
        //获取请求来源
        String requestSource = request.getHeader("RequestSource");
        boolean decrypt = MD5Util.verifyingCiphertext(requestSource,"request_from_gateway");
        //验证请求来源是否为网关转发
        if(decrypt){
            //放行请求
            return true;
        }else{
            result.setCode(CodeEnum.ILLEGAL_REQUEST.getCode());
            result.setData(CodeEnum.ILLEGAL_REQUEST.getMessage());
        }
        
        //将map转化成json，response使用的是Jackson
        String json = new ObjectMapper().writeValueAsString(result);
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json;charset=UTF-8");
        response.setHeader("Access-Control-Allow-Origin","*");
        response.getWriter().print(json);
        return false;
    }
}

测试：
请求：http://localhost:9004/test
在这里插入图片描述
返回结果：
在这里插入图片描述
通过网关测试：
请求：http://localhost:9005/message/board/test

在这里插入图片描述
返回结果：
在这里插入图片描述

亿只王菜菜
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
springcloud-gateway-oauth2:这是一个SpringCloud gateway +oauht2.0+jwt 实现微服务的认证和授权
05-11
1.springcloud-gateway-oauth2 这是一个SpringCloud gateway +oauht2.0+jwt 实现微服务的认证和授权 (记得修改 redis连接 和jdbc连接) 2.安装naocs 3.测试 1.访问认证服务: 2. 访问资源服务: 3. 用户的信息
导入spring-cloud-alibaba-dependencies的2.2.6版本依赖POM文件的project标签报错
qq_46484190的博客
04-27 2828
导入spring-cloud-alibaba-dependencies的2.2.6版本依赖POM文件的project标签报错遇到的问题报错信息解决方案 遇到的问题 我在父项目中导入spring-cloud-alibaba-dependencies的2.2.6版本，在子模块中引入spring-cloud-starter-alibaba-nacos-discovery，子模块的pom文件中的project标签报错，导入不了依赖。 报错信息 Failed to read artifact descriptor
【Spring Cloud】使用JWT技术实现登录功能
最新发布
hui_zai_的博客
05-20 963
使用JWT技术实现登录功能
springcloud依赖，持续更新
热门推荐
诗水人间
09-21 9万+
parent依赖 <!-- 版本管理配置 --> <properties> <!--依赖管理--> <spring-boot-dependencies.version>2.2.6.RELEASE</spring-boot-dependencies.version> <spring-cloud-alibaba-dependencies.version>2.2.1.RELEASE</spring-cloud-
【Spring Cloud & Alibaba 实战 | 总结篇】Spring Cloud Gateway + Spring Security OAuth2 + JWT 实现微服务统一认证授权和鉴权，
竹林幽深
10-08 5557
https://blog.51cto.com/u_12386660/4903587
微服务系统架构演变
weixin_44930692的博客
09-09 927
第一章 微服务介绍 最近在学习微服务，记录一下学习历程。 文章目录第一章 微服务介绍**1.1** 系统架构演变**1.1.1** 单体应用架构**单体应用架构优点：****单体应用架构缺点：****1.1.2** 垂直应用架构**优点：****缺点：****1.1.3** **分布式架构****优点**：**缺点**：1.1.4 SOA架构优点:缺点:**1.1.5** **微服务架构****优点**：**缺点**：**1.2** 微服务架构介绍**1.2.1** **微服务架构的常见问题****1.2.
springcloud 之springcloud alibaba
ljy_13141314的博客
12-18 1184
springcloud alibaba是springcloud微服务架构规范的落地项目 微服务是进程和进程服务之间的调用，不再是传统单体项目控制层，业务层之间的调用。
spring-boot-2.2.6.RELEASE.zip
04-04
spring-boot最新正式版源码spring-boot-2.2.6.RELEASE.zip，github太慢特上传此处，方便大家学习使用。其他资源亦可从我的资源页获取https://download.csdn.net/user/u010887744/uploads，如果没找到你想要的可以...
spring-boot-cli-2.2.6.RELEASE-bin.zip
03-31
这个“spring-boot-cli-2.2.6.RELEASE-bin.zip”文件是一个专门为Windows用户准备的安装包，包含了运行和开发Spring Boot应用所需的所有工具。 Spring Boot的核心理念是简化Spring应用程序的初始设置和配置。2.2.6....
spring-boot-starter-web-2.2.6.RELEASE.jar
04-21
spring-boot-starter-web-1.0.0.RELEASE.jar 各个版本，免费下载 spring-boot-starter-web.RELEASE.jar 各个版本，免费下载 spring-boot-starter-web.jar 各个版本，免费下载 如果不能免费下载，关注我，评论区联系...
spring-cloud-starter-alibaba-nacos-config-2.2.6.RELEASE.jar
05-09
spring-cloud-starter-alibaba-nacos-config-2.2.6.RELEASE
Spring Cloud实战 | 第六篇：Spring Cloud Gateway + Spring Security OAuth2 + JWT实现微服务统一认证授权鉴权
竹林幽深
10-07 4147
https://blog.51cto.com/u_12386660/4903483
Spring Boot 版本升级: 从 2.2.6.RELEASE 升级到 2.5.1 问题解决方案
这样不好么
12-23 4165
项目迁移时，选择了阿里云 Elasticsearch 服务, 版本是 7.10.0 且不能降级版本 Spring Boot 升级遇到跨域、依赖问题解决方案和源码探究...
Nacos(三)GateWay 和 Nacos结合，使用Nacos作为配置中心和注册中心
xuzai
01-31 1643
文章目录一、工程介绍1、父模块2、nacos-provider2.1 pom文件2.2 启动类2.3 controller2.4 bootstrap文件3、nacos-consumer模块3.1 pom文件3.2 启动类3.3 controller3.4 bootstrap文件4、gateway模块4.1 pom文件4.2 启动类4.3 bootstrap文件二、 nocas注册中心和配置中心相关配置1、在注册中心建立不同环境的命名空间2、在配置中心编写相关配置2.1 nacos-provider相关配置2
SpringCloud Alibaba 从零搭建鉴权中心服务（详细教程）
良月柒
01-06 130
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 16分钟。来自：blog.csdn.net/doomwatcher/article/details/121743887鉴权中心服务认识JWTjson web token 是一个开放的标准 ，它定义了一个种紧凑的，自包含的方式，用于作为json对象在各方之间安全的传输信息服务器鉴权完成之后 会生成 json 对象 发送给客户端，...
nacos 和 gateway 一个简单的配置实例
凉快
05-24 3326
前言 大家可以非常清晰的看到，我上一个nacos 安装和使用的博客是三个月前写的了。但是写这个播客就是为了记录一下，依赖版本的问题。 我遇到的一个奇怪的问题？ 就是我之前用的那个带有父依赖的pom文件（原因是我想尝试一下官网的demo，就复制的它的pom依赖），但是只配置注册中心配置信息还不行，还要配置配置中心的信息，不然自动连接本地的nacos，不连接服务器的那 nacos，就非常奇怪。 由于我最后没有解决，但是改了依赖就没问题了，最后只能判断为依赖版本问题。（以下是我成功的版本依赖） pom <
SpringCloud gateway +oauht2.0 password模式+jwt 实现微服务的认证和授权（二）
qq_44605317的博客
06-19 1981
1.我们把三个服务分别注册到nacos中 1.1:pom文件中加入 nacos依赖(三个服务都得加) <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency> 1.
二、Spring Cloud Alibaba环境搭建
eternal_tc的博客
05-03 1425
SpringCloud Alibaba环境搭建和分布式架构服务调用到cloud
no main manifest attribute, in spring-cloud-starter-netflix-eureka-server-2.2.6.RELEASE.jar
07-08
这个错误通常是由于缺少可执行的主清单属性引起的。您可以尝试以下解决方法： 1. 确认您下载的jar文件是否完整，没有损坏或下载错误。您可以重新下载一次jar文件并再次尝试。 2. 检查您的命令是否正确。确保在命令中指定了正确的jar文件路径和配置文件名称。例如，在启动Eureka Server时，使用以下命令： ``` java -jar spring-cloud-starter-netflix-eureka-server-2.2.6.RELEASE.jar --spring.config.name=eureka-server ``` 3. 检查您的jar文件中是否存在可执行的主清单属性。您可以使用以下命令查看jar文件的清单属性： ``` jar tf spring-cloud-starter-netflix-eureka-server-2.2.6.RELEASE.jar ``` 确保清单中包含类似于`Main-Class`的属性，指定了可执行的主类。 如果上述方法都没有解决问题，可能需要进一步检查您的环境配置和依赖项是否正确。您还可以尝试使用其他版本的Eureka Server JAR文件或者尝试使用其他可用的Eureka Server安装方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

亿只王菜菜

各位爷，赏口饭吃吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值