【idea版】springcloud微服务（6）之整合gateway网关使用

最新推荐文章于 2024-06-06 14:29:28 发布

binggoling

最新推荐文章于 2024-06-06 14:29:28 发布

阅读量2.3k

点赞数 1

分类专栏： springcloud微服务文章标签：网关 java gateway 微服务 springcloud

本文链接：https://blog.csdn.net/qq_30442207/article/details/117332768

版权

springcloud微服务专栏收录该内容

11 篇文章 6 订阅

订阅专栏

文章目录

前言
【idea版】springcloud微服务（6）之整合gateway网关使用

前言

【idea版】springcloud微服务系列搭建教程，包括整合nacos、mybatisplus、redis、gateway、ribbion、Rocketmq等

【idea版】springcloud微服务（6）之整合gateway网关使用

1.什么是网关

简单来说就是服务调用的入口，在微服务架构里，服务的粒度被进一步细分，各个业务服务可以被独立的设计、开发、测试、部署和管理。这时，各个独立部署单元可以用不同的开发测试团队维护，可以使用不同的编程语言和技术平台进行设计，这就要求必须使用一种语言和平台无关的服务协议作为各个单元间的通讯方式。

2.API 网关的职能

请求接入，作为所有API接口服务请求的接入点
业务聚合，作为所有后端业务服务的集合点
中介策略，实现安全校验，过滤，路由，控流等

3.Gateway是什么

Spring Cloud Gateway是Spring官方基于Spring 5.0，Spring Boot 2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供一种简单而有效的统一的API路由管理方式。Spring Cloud Gateway作为Spring Cloud生态系中的网关，目标是替代ZUUL，其不仅提供统一的路由方式，并且基于Filter链的方式提供了网关基本的功能，例如：安全，监控/埋点，和限流等。

4.环境要求

如果要实现服务之间的负载均衡的调用，需要一个注册中心，我这个使用是nacos

5.创建项目

根据教程：【idea版】springcloud微服务（1）之多模块版本新建一个springcloud项目
创建一个子模块：springcloud-gateway-example
注：我这个使用会使用到之前的创建的子模块，不明白的可以看看我之前的文章

6.引包

1）父pom.xml依赖

<properties>
    <spring-boot.version>2.4.3</spring-boot.version>
    <spring-cloud.version>2020.0.2</spring-cloud.version>
    <spring-cloud-alibaba.version>2.2.1.RELEASE</spring-cloud-alibaba.version>
    <java.version>11</java.version>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <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>

2）pom.xml的引入核心包spring-cloud-starter-gateway

<?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-example</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-gateway-example</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- nacos服务注册中心 begin-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- nacos服务注册中心 begin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.5.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

7.新建配置文件

在resources里新建文件application.yml

server:
  port: 9005
# 设置应用名称，便于在注册中心中查看
spring:
  application:
    name: gateway-server
  # 设置注册中心
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      routes:
        - id: example-server
          uri: https://example.org/
          predicates:
            - Path=/test
        - id: ribbonA-server
          uri: http://localhost:9003/
          predicates:
            - Path=/a/**
          filters:
            - StripPrefix=1
        - id: ribbonB-server
          uri: lb://ribbonB-server
          predicates:
            - Path=/b/**
          filters:
            - StripPrefix=1

规则就是在predicates断言，如果判断断言为true，就会路由并打多出来的path拼接到uri的后面转发
主要配置说明

spring.cloud:
    gateway:
      routes:
        - id: example-server
          uri: https://example.org/
          predicates:
            - Path=/test
        - id: ribbonA-server
          uri: http://localhost:9003/
          predicates:
            - Path=/a/**
          filters:
            - StripPrefix=1
        - id: ribbonB-server
          uri: lb://ribbonB-server
          predicates:
            - Path=/b/**
          filters:
            - StripPrefix=1

id：就是唯一值，可以随便写，确保唯一就行
uri：就是你的请求需要转发后的地址
predicates：断言，就是满足条件，满足就转发到uri
filters：拦截，StripPrefix是截取，当http://127.0.0.1:9004/b/b，就会转发到服务ribbonB-server，因为有截取，实际转发的url是http://ribbonB-server/b

注：lb://ribbonB-server
在注册中心才能使用，lb是LoadBalanced的缩写，负载均衡的意思，后面是服务名ribbonB-server

8.创建入口GatewayApplication.java

@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {

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

9.启动服务

访问

浏览器直接输入：http://127.0.0.1:9006/test 就会转发到：https://example.org/test
浏览器直接输入：http://127.0.0.1:9006/a/a 就会转发到： http://127.0.0.1:9003/a

10.全局拦截GlobalFilter

在GatewayApplication.java加入GlobalFilter

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

    @Bean
    public GlobalFilter customFilter() {
        return new CustomGlobalFilter();
    }
}

拦截类CustomGlobalFilter.java，实现了会话拦截

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import io.jsonwebtoken.Claims;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
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.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 自定义全局拦截器
 *
 * @author libingwei
 */
@Log4j2
public class CustomGlobalFilter implements GlobalFilter, Ordered {

    @Autowired
    private UrlWhiteListConfig urlWhiteListConfig;

    @Autowired
    private RedisUtil redisUtil;

    private static final String START_TIME = "startTime";

    /**
     * 过滤器业务逻辑
     *
     * @param exchange
     * @param chain
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        exchange.getAttributes().put(START_TIME, System.currentTimeMillis());

        ServerHttpRequest request = exchange.getRequest();
        //获取请求uri
        String uriPath = request.getURI().getPath();

        log.info("请求,Method:{}, host:{}, path:{}, query: {}",
                request.getMethod().name(),
                request.getURI().getHost(),
                uriPath,
                request.getQueryParams()
        );

        uriPath = uriPath.substring(uriPath.indexOf("/", 1));

        //如果在白名单的URL，请求则放行
        if (urlWhiteListConfig.getPathList().contains(uriPath)) {
            return chainFilter(exchange, chain);
        }

        //请求头中获取令牌
        String token = request.getHeaders().getFirst("token");

        //判断请求头中是否有令牌
        if (StringUtils.isEmpty(token)) {
            return responseWrite(exchange, "没有权限，请登录");
        }

        //如果请求头中有令牌则解析令牌
        try {
            Claims claims = JwtUtil.parseJWT(token);
            LoginInfoEntity loginInfo = JSON.parseObject(claims.getSubject(), LoginInfoEntity.class);
            if (redisUtil.get(loginInfo.getName()) == null) {
                return responseWrite(exchange, "鉴权失效，请重新登录");
            }

            String tokenStr = (String) redisUtil.get(loginInfo.getName());
            if (!token.equals(tokenStr)) {
                return responseWrite(exchange, "鉴权失效，请重新登录");
            }
            //刷新缓存时间
//            redisUtil.expire(loginInfo.getName(), 30 * 60);
        } catch (Exception e) {
            log.error("jwt解析异常：", e);
            return responseWrite(exchange, "没有权限，请登录");
        }

        //放行
        return chainFilter(exchange, chain);
    }

    public Mono<Void> chainFilter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            Long startTime = exchange.getAttribute(START_TIME);
            if (startTime != null) {
                Long executeTime = System.currentTimeMillis() - startTime;
                log.info(exchange.getRequest().getURI().getRawPath() + " : " + executeTime + "ms");
            }
        }));
    }

    /**
     * 错误返回信息
     *
     * @param exchange
     * @param message
     * @return
     */
    public Mono<Void> responseWrite(ServerWebExchange exchange, String message) {
        Long startTime = exchange.getAttribute(START_TIME);
        log.info("url:{}, message:{}, {}ms",
                exchange.getRequest().getURI().getPath(),
                message,
                (System.currentTimeMillis() - startTime));

        ServerHttpResponse response = exchange.getResponse();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", "-1");
        jsonObject.put("message", message);

        byte[] bits = jsonObject.toJSONString().getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        response.getHeaders().add("Content-Type", "text/plain;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }

    /**
     * 过滤器执行顺序，数值越小，优先级越高
     *
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
}

工具类：
UrlWhiteListConfig.java

@Data
@Component
@ConfigurationProperties(prefix = "urlwhit.filter")
public class UrlWhiteListConfig {

    private List<String> pathList;
}

RedisUtil.java

RedisUtil.java 地址

JwtUtil.java


import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.Date;

/**
 * @author libingwei
 * @title: JwtUtil  JWT工具类
 */
public class JwtUtil {

    /**
     * 设置有效期为 60 * 60 秒
     */
    private static final Long JWT_TTL = 3600000L;
    /**
     * 设置秘钥明文
     */
    private static final String JWT_KEY = "jjwt-joyoh-token";

    /**
     * 创建toke
     *
     * @param id
     * @param subject
     * @return
     */
    public static String createJWT(String id, String subject) {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
//        if (ttlMillis == null) {
//            ttlMillis = JwtUtil.JWT_TTL;
//        }
//        long expMillis = nowMillis + ttlMillis;
//        Date expDate = new Date(expMillis);
        SecretKey secretKey = generalKey();

        JwtBuilder builder = Jwts.builder()
                //唯一的ID
                .setId(id)
                // 主题  可以是JSON数据
                .setSubject(subject)
                // 签发者
                .setIssuer("admin")
                // 签发时间
                .setIssuedAt(now)
                //使用HS256对称加密算法签名, 第二个参数为秘钥
                .signWith(signatureAlgorithm, secretKey);
                // 设置过期时间
//                .setExpiration(expDate);
        return builder.compact();
    }

    /**
     * 解析JWT
     *
     * @param compactJwt
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String compactJwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(compactJwt).getBody();
    }

    /**
     * 生成加密后的秘钥 secretKey
     *
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getEncoder().encode(JwtUtil.JWT_KEY.getBytes());
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

//    public static void main(String[] args) throws Exception {
//        Claims claims = JwtUtil.parseJWT("eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxOWI3NjU3OS1hYjYwLTRkNzYtYTE1ZS1lZWM2NmI4MzViMzEiLCJzdWIiOiJ7XCJlbWFpbEFkZHJlc3NcIjpcIlwiLFwibmFtZVwiOlwidGVzdFwifSIsImlzcyI6ImFkbWluIiwiaWF0IjoxNjA2MjkxNjgxfQ.XwEnKVnN-bJDQQ6hGniPfZD-W8LlpgnUl5WOGuSLba8");
//        System.out.println(claims.getSubject());
//    }
}