Gateway+nacos动态网关配置

最新推荐文章于 2024-04-28 22:04:10 发布
最新推荐文章于 2024-04-28 22:04:10 发布
阅读量3.6k 收藏 3
点赞数 1
分类专栏： springcloud 文章标签： java spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adminBfl/article/details/128819468
版权

1.添加依赖

<!-- spring cloud alibaba nacos discovery 依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>2.2.3.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

2.nacos配置内容

1.新建配置
2.Data Id:butool-cloud-gateway-router
3.Group: butool-cloud
4.配置格式: JSON
5.配置内容
//配置不需要加注释
//获取路由对象，被网关反序列化成List<RouteDefinition>

[
    {
        "id":"butool-cloud-test",   //路由配置主键唯一，自定义即可
        "order":0, //优先级越小代表的优先级越高
        "predicates":[ //路由匹配
            {
              "args":{
                  "pattern":"/api/butool-cloud-test/**"  //先映射到网关api/butool-cloud-test 工程路径前缀  server.servlet.context-path
              },
              "name":"Path"  //路径匹配
              }
        ],
        "uri":"lb://butool-test", 转发到哪个微服务serviceid  ’lb://’开头 spring.application.name
        "filters":[
            {
                "name":"HeaderToken" //header携带token验证过滤器,寻找HeaderTokenGatewayFilterFactor，GatewayFilterFactor前面的名称
            },
            {
               "name":"StripPrefix", //跳过前缀过滤器
               "args":{
                    "parts":"1" //跳过1个前缀，往后的路径实现转发
               }     
            }
        ]
    }
]

3.bootstrap.yal

server:
  port: 9001
  servlet:
    context-path: /butool
spring:
  application:
    name: butool-gateway
  cloud:
    nacos:
      # 服务注册发现
      discovery:
        enabled: true # 如果不想使用 Nacos 进行服务注册和发现, 设置为 false 即可
        server-addr: 127.0.0.1:8848
        # server-addr: 127.0.0.1:8848,127.0.0.1:8849,127.0.0.1:8850 # Nacos 集群方式服务器地址
        namespace: fdf5864c-f4da-47c3-9ef6-898a60cfff32
        # 接入到springBootAdmin
        metadata:
          management:
            context-path: ${server.servlet.context-path}/actuator
  main:
    allow-bean-definition-overriding: true  # 因为将来会引入很多依赖, 难免有重名的 bean
# 这个地方独立配置, 是网关的数据, 代码 GatewayConfig.java 中读取被监听
nacos:
  gateway:
    route:
      config:
        data-id: butool-cloud-gateway-router
        group: butool-cloud
​
# 暴露端点
management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always
​

4.配置类

package cn.butool.config;
​
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
​
/**
 * 配置类：读取Nacos相关的配置项，用于配置监听器
 */
@SuppressWarnings("all")
@Configuration
public class GatewayConfig {
    /**
     * 读取配置的超时时间
     */
    public static final long DEFAULT_TIMEOUT = 30000;
    /**
     * Nacos 服务器地址
     */
    public static String NACOS_SERVER_ADDR;
​
    /**
     * Nacos 命名空间
     */
    public static String NACOS_NAMESPACE;
    /**
     * nacos 配置列表中的dataid
     */
    public static String NACOS_ROUTE_DATE_ID;
    /**
     * nacos分组id
     */
    public static String NACOS_GROUP_ID;
​
    @Value("${spring.cloud.nacos.discovery.server-addr}")
    public void setNacosServerAddr(String nacosServerAddr) {
        NACOS_SERVER_ADDR = nacosServerAddr;
    }
​
    @Value("${spring.cloud.nacos.discovery.namespace}")
    public void setNacosNamespace(String nacosNamespace) {
        NACOS_NAMESPACE = nacosNamespace;
    }
​
    @Value("${nacos.gateway.route.config.data-id}")
    public void setNacosRouteDateId(String nacosRouteDateId) {
        NACOS_ROUTE_DATE_ID = nacosRouteDateId;
    }
​
    @Value("${nacos.gateway.route.config.group}")
    public void setNacosGroupId(String nacosGroupId) {
        NACOS_GROUP_ID = nacosGroupId;
    }
}
​

5.事件推送 Aware:

package cn.butool.config;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionLocator;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;
​
import java.util.List;
​
/**
 * 事件推送 Aware: 动态更新路由网关 Service
 * */
@Slf4j
@Service
@SuppressWarnings("all")
public class DynamicRouteServiceImpl implements ApplicationEventPublisherAware {
​
    /** 写路由定义 */
    private final RouteDefinitionWriter routeDefinitionWriter;
    /** 获取路由定义 */
    private final RouteDefinitionLocator routeDefinitionLocator;
​
    /** 事件发布 */
    private ApplicationEventPublisher publisher;
​
    public DynamicRouteServiceImpl(RouteDefinitionWriter routeDefinitionWriter,
                                   RouteDefinitionLocator routeDefinitionLocator) {
        this.routeDefinitionWriter = routeDefinitionWriter;
        this.routeDefinitionLocator = routeDefinitionLocator;
    }
​
    @Override
    public void setApplicationEventPublisher(
            ApplicationEventPublisher applicationEventPublisher) {
        // 完成事件推送句柄的初始化
        this.publisher = applicationEventPublisher;
    }
​
    /**
     * 从nacos读取路由配hi，写道gateway中
     * <h2>增加路由定义</h2>
     * */
    public String addRouteDefinition(RouteDefinition definition) {
​
        log.info("gateway add route: [{}]", definition);
​
        // 保存路由配置并发布
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        // 发布事件通知给 Gateway, 同步新增的路由定义
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
​
        return "success";
    }
​
    /**
     * <h2>更新路由</h2>
     * */
    public String updateList(List<RouteDefinition> definitions) {
​
        log.info("更新网关路由: [{}]", definitions);
​
        // 先拿到当前 Gateway 中存储的路由定义
        List<RouteDefinition> routeDefinitionsExits =
                routeDefinitionLocator.getRouteDefinitions().buffer().blockFirst();
        if (!CollectionUtils.isEmpty(routeDefinitionsExits)) {
            // 清除掉之前所有的 "旧的" 路由定义
            routeDefinitionsExits.forEach(rd -> {
                deleteById(rd.getId());
                log.info("清除掉之前所有的 旧的 路由定义: [{}]", rd);
            });
        }
​
        // 把更新的路由定义同步到 gateway 中
        definitions.forEach(definition -> updateByRouteDefinition(definition));
        return "success";
    }
​
    /**
     * <h2>根据路由 id 删除路由配置</h2>
     * */
    private String deleteById(String id) {
​
        try {
            log.info("要删除的路由id: [{}]", id);
            this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();
            // 发布事件通知给 gateway 更新路由定义
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "删除成功";
        } catch (Exception ex) {
            log.error("删除网关路由失败: [{}]", ex.getMessage(), ex);
            return "删除失败";
        }
    }
​
    /**
     * <h2>更新路由</h2>
     * 更新的实现策略比较简单: 删除 + 新增 = 更新
     * */
    private String updateByRouteDefinition(RouteDefinition definition) {
​
        try {
            log.info("更新网关路由: [{}]", definition);
            this.routeDefinitionWriter.delete(Mono.just(definition.getId()));
        } catch (Exception ex) {
            return "更新失败,没有查到更新的网关路由id: " + definition.getId();
        }
​
        try {
            this.routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "成功";
        } catch (Exception ex) {
            return "更新路由失败！";
        }
    }
}

6.通过Nacos下发的动态配置，监听nacos中路由配置

package cn.butool.config;
​
import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;
​
import javax.annotation.PostConstruct;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Executor;
​
/**
 * 通过Nacos下发的动态配置，监听nacos中路由配置
 */
@Slf4j
@Component
//再另外一个Bean初始化之后再去初始化当前类
@DependsOn({"gatewayConfig"})
@SuppressWarnings("all")
public class DynamicRouteServiceImplNacos {
​
    private ConfigService configService;
​
    private final DynamicRouteServiceImpl dynamicRouteService;
​
    public DynamicRouteServiceImplNacos(DynamicRouteServiceImpl dynamicRouteService) {
        this.dynamicRouteService = dynamicRouteService;
    }
​
    /**
     * 初始化ConfigService
     *
     * @return
     */
    private ConfigService initConfigService() {
        try {
            Properties properties = new Properties();
            properties.setProperty("serverAddr", GatewayConfig.NACOS_SERVER_ADDR);
            properties.setProperty("namespace", GatewayConfig.NACOS_NAMESPACE);
            return configService = NacosFactory.createConfigService(properties);
        } catch (Exception ex) {
            log.error("初始化配置服务:[{}]", ex.getMessage());
            return null;
        }
    }
​
    /**
     * bean在容器中构造完成之后会立即执行当前的init方法
     * 加载路由信息，注册监听器
     */
    @PostConstruct
    public void init(){
        log.info("网关路由初始化...");
​
        try {
            //初始化nacos配置客户端
            configService = initConfigService();
            if(configService==null){
                log.error("初始化配置服务异常,配置服务是null!");
                return;
            }
            //通过 nacos config 并指定路由配置路径去获取路由配置
            String configInfo = configService.getConfig(GatewayConfig.NACOS_ROUTE_DATE_ID,
                    GatewayConfig.NACOS_GROUP_ID,
                    GatewayConfig.DEFAULT_TIMEOUT);
            log.info("当前网关配置信息:[{}]:",configInfo);
            //反序列化
            List<RouteDefinition> routeDefinitions = JSON.parseArray(configInfo, RouteDefinition.class);
            if(CollectionUtil.isNotEmpty(routeDefinitions)){
                //新增
                for (RouteDefinition routeDefinition : routeDefinitions) {
                    log.info("初始化 路由定义对象 信息:[{}]:",routeDefinition);
                    dynamicRouteService.addRouteDefinition(routeDefinition);
                }
​
            }
        } catch (Exception e) {
            log.error("网关路由初始化失败:[{}]",e.getMessage());
        }
        //设置监听器
        dynamicRouteServiceImplNacosByListener(GatewayConfig.NACOS_ROUTE_DATE_ID,GatewayConfig.NACOS_GROUP_ID);
    }
​
    /**
     * 监听 Nacos下发的动态路由配置
     *
     * @param dataId
     * @param group
     */
    private void dynamicRouteServiceImplNacosByListener(String dataId, String group) {
        try {
            //给Nacos config 客户端增加一个监听器
            configService.addListener(dataId, group, new Listener() {
                /**
                 * 自己提供线程池执行操作
                 * @return
                 */
                @Override
                public Executor getExecutor() {
                    return null;
                }
​
                /**
                 * 监听器收到接收到配置变更信息
                 * @param configInfo nacos 中最新配置信息
                 */
                @Override
                public void receiveConfigInfo(String configInfo) {
                    log.info("接收的配置信息:[{}]", configInfo);
                    List<RouteDefinition> routeDefinitions = JSON.parseArray(configInfo, RouteDefinition.class);
                    dynamicRouteService.updateList(routeDefinitions);
                    log.info("更新后的路由配置信息:[{}]", routeDefinitions.toString());
                }
            });
        } catch (Exception e) {
            log.error("监听 Nacos下发的动态路由配置异常:[{}]", e.getMessage());
        }
    }
}
​

7.局部过滤器

7.1过滤器实现

package cn.butool.filter;
​
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
​
/**
 * header携带token验证过滤器
 */
public class HeaderTokenGateWayFilter implements GatewayFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //从HttpHeader中寻找key为token，value为butool的键值对
        String token = exchange.getRequest().getHeaders().getFirst("token");
        if("butool".equals(token)){
            return chain.filter(exchange);
        }
        // 标记此次请求没有权限，并且结束这次请求
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        //请求结束
        return exchange.getResponse().setComplete();
    }
​
    /**
     * 优先级
     * @return
     */
    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE+2;
    }
}

7.2工厂实现类

package cn.butool.filter.factory;
​
import cn.butool.filter.HeaderTokenGateWayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
​
@Component
public class HeaderTokenGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {
    @Override
    public GatewayFilter apply(Object config) {
        return new HeaderTokenGateWayFilter();
    }
}

7.3配置文件中进行配置

//注意命名规则 
"filters":[
            {
                "name":"HeaderToken" //header携带token验证过滤器,寻找HeaderTokenGatewayFilterFactor，GatewayFilterFactor前面的名称
            },
            {
               "name":"StripPrefix", //跳过前缀过滤器
               "args":{
                    "parts":"1" //跳过1个前缀，往后的路径实现转发
               }     
            }
        ]

7.4局部过滤器步骤

1.新建过滤器实现
2.新建工厂类实现
3.配置文件中进行配置

8.缓存请求body的全局过滤器

package cn.butool.constan;
​
/**
 * 网关常量定于
 */
@SuppressWarnings("all")
public class GatewayConstant {
    /**登录的url*/
    public static final String LOGIN_URL = "/butool/login";
​
    /** 注册的url*/
    public static final String REGISTER_URL = "/butool/register";
​
    /** 去授权中心拿到登录 token 的 uri 格式化接口 */
    public static final String AUTHORITY_CENTER_TOKEN_URL_FORMAT =
            "http://%s:%s/butool-cloud-Authority-center/authority/token";
​
    /** 去授权中心注册并拿到 token 的 uri 格式化接口 */
    public static final String AUTHORITY_CENTER_REGISTER_URL_FORMAT =
            "http://%s:%s/butool-cloud-Authority-center/authority/register";
​
​
}
​


package cn.butool.filter;
​
import cn.butool.constan.GatewayConstant;
import lombok.extern.slf4j.Slf4j;
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.core.io.buffer.DataBufferUtils;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
​
/**
 * <h1>全局缓存请求Body过滤器</h1>
 * 将请求数据缓存方便后面的过滤器拿取
 * spring WebFlux
 */
@Slf4j
@Component
public class GlobalCacheRequestBodyFilter implements GlobalFilter, Ordered {
​
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange
                .getRequest()
                .getURI()
                .getPath();
        boolean isLoginOrRegister =
                path.contains(GatewayConstant.LOGIN_URL) || path.contains(GatewayConstant.REGISTER_URL);
        // 如果没有请求头或者不是登录注册接口，不用去缓存了，往下走下面的过滤器
        if (null == exchange.getRequest().getHeaders().getContentType() || !isLoginOrRegister) {
            return chain.filter(exchange);
        }
        return DataBufferUtils
                .join(exchange.getRequest().getBody()) //获取请求数据
                .flatMap(dataBuffer -> {
                    // 确保数据缓冲区不被释放, 必须要 DataBufferUtils.retain
                    DataBufferUtils.retain(dataBuffer);
                    // defer、just 都是去创建数据源, 得到当前数据的副本
                    Flux<DataBuffer> cachedFlux = Flux.defer(() ->
                            Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount())));
                    // 重新包装 ServerHttpRequest, 重写 getBody 方法, 能够返回请求数据
                    ServerHttpRequest mutatedRequest =
                            new ServerHttpRequestDecorator(exchange.getRequest()) {
                                @Override
                                public Flux<DataBuffer> getBody() {
                                    return cachedFlux;
                                }
                            };
                    // 将包装之后的 ServerHttpRequest 向下继续传递
                    return chain.filter(exchange.mutate().request(mutatedRequest).build());
                });
    }
​
    /**
     * 下面过滤器要拿到当前过滤器缓存内容优先级要比当前返回数值要大
     *
     * @return
     */
    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE + 1;
    }
}
​

9.全局登录、鉴权过滤器

9.1注入RestTemplate对象

package cn.butool.conf;
​
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
​
/**
 * 网关需要注入到容器中的bean
 */
@Configuration
public class GatewayBeanConf {
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}
​

9.2鉴权授权登陆注册接口常量

package cn.butool.constan;
​
/**
 * 网关常量定于
 */
@SuppressWarnings("all")
public class GatewayConstant {
    /**登录的url*/
    public static final String LOGIN_URL = "/butool/login";
    public static final String LOGINL = "/authority/login";
​
    /** 注册的url*/
    public static final String REGISTER_URL = "/butool/register";
    public static final String REGISTER = "/authority/register";
​
    /** 去授权中心拿到登录 token 的 uri 格式化接口 */
    public static final String AUTHORITY_CENTER_TOKEN_URL_FORMAT =
            "http://%s:%s/butool-cloud-Authority-center/authority/token";
​
    /** 去授权中心注册并拿到 token 的 uri 格式化接口 */
    public static final String AUTHORITY_CENTER_REGISTER_URL_FORMAT =
            "http://%s:%s/butool-cloud-Authority-center/authority/register";
​
​
}
​

9.3登录鉴权过滤器

package cn.butool.filter;
​
import cn.butool.constan.GatewayConstant;
import cn.butool.constant.CommonConstant;
import cn.butool.util.TokenParseUtil;
import cn.butool.vo.JwtToken;
import cn.butool.vo.LoginUserInfo;
import cn.butool.vo.UserRegisterInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
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.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
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.client.RestTemplate;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
​
import java.nio.CharBuffer;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.atomic.AtomicReference;
​
/**
 * <h1>全局登录、鉴权过滤器</h1>
 * spring WebFlux
 */
@Slf4j
@Component
public class GlobalLoginOrRegisterFilter implements GlobalFilter, Ordered {
    /**
     * 注册中心客户端, 可以从注册中心中获取服务实例信息
     */
    private final LoadBalancerClient loadBalancerClient;
    /**
     * 发送http请求
     */
    private final RestTemplate restTemplate;
​
    public GlobalLoginOrRegisterFilter(LoadBalancerClient loadBalancerClient,
                                       RestTemplate restTemplate) {
        this.loadBalancerClient = loadBalancerClient;
        this.restTemplate = restTemplate;
    }
​
    /**
     * 登录注册鉴权
     * 1.如果时登录注册，则去授权中心拿到token 并返回给客户端
     * 2.如果是访问其他服务，则鉴权，没权限返回 401
     * @param exchange
     * @param chain
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        //1.如果是登录
        if(request.getURI().getPath().contains(GatewayConstant.LOGIN_URL)){
            //去授权中心拿token
            String token = getTokenFromAuthorityCenter(request, GatewayConstant.AUTHORITY_CENTER_TOKEN_URL_FORMAT);
            // header   中不能设置 null
            response.getHeaders()
                    .add(CommonConstant.JWT_USER_INFO_KEY,null==token?"null":token);
            response.setStatusCode(HttpStatus.OK);
            return response.setComplete();
        }else if(request.getURI().getPath().contains(GatewayConstant.REGISTER_URL)){
            //去授权中心拿token
            String token = getTokenFromAuthorityCenter(request, GatewayConstant.AUTHORITY_CENTER_REGISTER_URL_FORMAT);
            // header   中不能设置 null
            response.getHeaders()
                    .add(CommonConstant.JWT_USER_INFO_KEY,null==token?"null":token);
            response.setStatusCode(HttpStatus.OK);
            return response.setComplete();
        }
        // 3.访问其他服务，则鉴权，校验是否能从token中解析出用户信息
        HttpHeaders headers = request.getHeaders();
        String token = headers.getFirst(CommonConstant.JWT_USER_INFO_KEY);
        LoginUserInfo loginUserInfo = null;
        try {
            loginUserInfo = TokenParseUtil.parseUserInfoFromToken(token);
        } catch (Exception ex) {
            log.error("parse user info from token error: [{}]", ex.getMessage(), ex);
        }
        if(null == loginUserInfo){
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        //解析通过则放行
        return chain.filter(exchange);
    }
​
    /**
     * <h2>从授权中心获取 Token</h2>
     */
    private String getTokenFromAuthorityCenter(ServerHttpRequest request, String uriFormat) {
​
        // service id 就是服务名字, 负载均衡
        ServiceInstance serviceInstance = loadBalancerClient.choose(
                CommonConstant.AUTHORITY_CENTER_SERVICE_ID
        );
        log.info("Nacos Client Info: [{}], [{}], [{}]",
                serviceInstance.getServiceId(), serviceInstance.getInstanceId(),
                JSON.toJSONString(serviceInstance.getMetadata()));
​
        String requestUrl = String.format(
                uriFormat, serviceInstance.getHost(), serviceInstance.getPort()
        );
        JwtToken token = null;
        if(uriFormat.contains(GatewayConstant.LOGINL)){
            LoginUserInfo requestBody = JSON.parseObject(
                    parseBodyFromRequest(request), LoginUserInfo.class
            );
            log.info("login request url and body: [{}], [{}]", requestUrl,
                    JSON.toJSONString(requestBody));
​
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            token = restTemplate.postForObject(
                    requestUrl,
                    new HttpEntity<>(JSON.toJSONString(requestBody), headers),
                    JwtToken.class
            );
        }else if(uriFormat.contains(GatewayConstant.REGISTER)){
            UserRegisterInfo requestBody = JSON.parseObject(
                    parseBodyFromRequest(request), UserRegisterInfo.class
            );
            log.info("注册请求url地址和请求body: [{}], [{}]", requestUrl,
                    JSON.toJSONString(requestBody));
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            token = restTemplate.postForObject(
                    requestUrl,
                    new HttpEntity<>(JSON.toJSONString(requestBody), headers),
                    JwtToken.class
            );
        }
        if (null != token) {
            return token.getToken();
        }
        return null;
    }
​
    /**
     * 从post请求中获取请数据
     *
     * @param request
     * @return
     */
    private String parseBodyFromRequest(ServerHttpRequest request) {
        // 获取请求体
        Flux<DataBuffer> body = request.getBody();
        AtomicReference<String> bodyRef = new AtomicReference<>();
​
        // 订阅缓冲区去消费请求体中的数据
        body.subscribe(buffer -> {
            CharBuffer charBuffer = StandardCharsets.UTF_8.decode(buffer.asByteBuffer());
            // 一定要使用 DataBufferUtils.release 释放掉, 否则, 会出现内存泄露
            DataBufferUtils.release(buffer);
            bodyRef.set(charBuffer.toString());
        });
​
        // 获取 request body
        return bodyRef.get();
    }
​
    /**
     * 下面过滤器要拿到当前过滤器缓存内容优先级要比当前返回数值要大
     *
     * @return
     */
    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE + 2;
    }
}

9.4配置登录请求过滤器

package cn.butool.config;
​
import cn.butool.constan.GatewayConstant;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
/**
 * 配置登录请求转发规则
 */
@Configuration
public class RouteLocatorConfig {
    /**
     * port
     */
    public static String port;
    @Value("${server.port}")
    public void setNacosGroupId(String port) {
        port = port;
    }
​
    /**
     * 使用代码定义路由规则，再网关层面拦截下登录和注册
     * @param builder
     * @return
     */
    @Bean
    public RouteLocator loginRouteLocator(RouteLocatorBuilder builder){
        // 手工定义gateway需要指定id、path和url
        return builder.routes()
                .route(
                        "butool-cloud-authority-center",
                        r->r.path("/butool"+GatewayConstant.LOGIN_URL,
                                "/butool"+GatewayConstant.REGISTER_URL)
                .uri("http://localhost:"+port+"/")
        ).build();
    }
}
​

10.全局接口耗时过滤器

package cn.butool.filter;
​
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.StopWatch;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
​
import java.util.concurrent.TimeUnit;
​
/**
 * <h1>全局接口耗时日志过滤器</h1>
 * */
@Slf4j
@Component
public class GlobalElapsedLogFilter implements GlobalFilter, Ordered {
​
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
​
        // 前置逻辑
        StopWatch sw = StopWatch.createStarted();
        String uri = exchange.getRequest().getURI().getPath();
​
        return chain.filter(exchange).then(
                // 后置逻辑
                Mono.fromRunnable(() ->
                        log.info("[{}] elapsed: [{}ms]",
                                uri, sw.getTime(TimeUnit.MILLISECONDS)))
        );
    }
    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE;
    }
}

11.注册登录测试

### 获取 Token -- 登录功能实现
POST http://127.0.0.1:9001/butool/manage/login
Content-Type: application/json
​
{
  "loginType": 1,
  "mobile": "18033664455",
  "password":"0192023a7bbd73250516f069df18b500",
  "expire":0
}
​
### 注册用户并返回 Token -- 注册功能实现
POST http://127.0.0.1:9001/butool/manage/register
Content-Type: application/json
​
{
  "loginType": 1,
  "mobile": "18033664455",
  "nickname": "busl",
  "password":"0192023a7bbd73250516f069df18b500",
  "Expire":0
}
 


                

        

        

    




            

                    
            

    

      

        

            

              
                
                  别浪呀
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    3
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
nacos中gateway配置详解

				
			

			

				

					学海无涯,我用JAVA
				

				

					08-11
					
					3275
					
				

			

		

		

			
				
最近忙的不行
本地安装nacos ,它既是注册中心,又是配置中心 默认端口8848(珠穆朗玛峰的高度)
下载安装自行百度,我是在windos中安装的  用的是1.4.1,
下载地址：
https://github.com/alibaba/nacos/releases/tag/1.4.1




image.png
下载后解压
解压的文件中的conf中有个sql文件




image.png
解压...

			
		

	



                

              
                



	

		

			

				
					
spring cloud nacos整合gateway

				
			

			

				

					个人博客，记录了本人学习的各种有趣的技术。
				

				

					12-05
					
					2429
					
				

			

		

		

			
				
过滤器的作用是：① 对路由的请求或响应做加工处理，比如添加请求头② 配置在路由下的过滤器只对当前路由的请求生效defaultFilters的作用是什么？① 对所有路由都生效的过滤器需求：定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：参数中是否有authorization，authorization参数值是否为admin如果同时满足则放行，否则拦截实现：import org。

			
		

	



                


  
              

                


	

		

			

				
					
SpringCloud Gateway的使用 + Nacos动态路由

				
			

			

				

					知道的越多 不知道的就越多
				

				

					07-21
					
					2万+
					
				

			

		

		

			
				
本文详细的分析gateway是如何使用和如何实现的，以及动态路由在gateway中的应用

			
		

	





	

		

			

				
					
Gateway结合Nacos使用！！！

					
最新发布

				
			

			

				

					qq_64847107的博客
				

				

					04-28
					
					2032
					
				

			

		

		

			
				
欢迎登录阿里云，全球领先的云计算及人工智能科技公司，阿里云为200多个国家和地区的企业、开发者和政府机构提供云计算基础服务及解决方案。阿里云云计算、安全、大数据、人工智能、企业应用、物联网等云计算服务。如果Nacos中配置使用yaml格式，一定要在这里配置file-extension：yaml。CICD流水线（发布后端代码）！_后端cicd配置-CSDN博客。1、Docker部署。dockerfile文件：你只需要改变打包的架包的名称即可。阿里云登录 - 欢迎登录阿里云，安全稳定的云计算服务平台。

			
		

	



		

			
		



	

		

			

				
					
【SpringCloud Alibaba】Nacos Config配置管理与Gateway 网关

				
			

			

				

					让优秀成为一种习惯！
				

				

					01-11
					
					5514
					
				

			

		

		

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

			
		

	





	

		

			

				
					
微服务nacos简单部署+网关设置+日志管理

				
			

			

				

					大鱼
				

				

					07-09
					
					5618
					
				

			

		

		

			
				
目录

1.nacos简单部署

2.网关设置

3日志管理.

1.nacos简单部署

nacos引用的主要依赖是然后在配置文件进行注册（需要提前启动nacos插件，默认密码都是nacos）


      <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-disc.

			
		

	





	

		

			

				
					
微服务学习笔记--(Gateway网关)

				
			

			

				

					weixin_42594143的博客
				

				

					05-16
					
					1057
					
				

			

		

		

			
				
网关功能：身份认证和权限校验服务路由、负载均衡请求限流需求：定义全局过滤器，拦截请求，判断请求的参数是否满足下面条件：参数中是否有authorizationauthorization参数值是否为admin如果同时满足则放行，否则拦截// 1.获取请求参数 MultiValueMap < String , String > params = exchange . getRequest() . getQueryParams();

			
		

	





	

		

			

				
					
springCloud-11 gateWay网关：动态路由配置

				
			

			

				

					阿涩的博客
				

				

					02-20
					
					4163
					
				

			

		

		

			
				
目录

一，动态路由

    1.1添加注册中心依赖

    1.2 配置动态路由

二，重写转发路径

    2.1 修改application.yml 文件

    2.2添加RewritePath重写转发路径



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

			
		

	





	

		

			

				
					
微服务——Nacos配置管理

				
			

			

				

					测试
				

				

					07-22
					
					1362
					
				

			

		

		

			
				
nacos配置篇

			
		

	





	

		

			

				
					
Spring Cloud Gateway Nacos 实现动态路由

				
			

			

				

					魂-淡
				

				

					02-22
					
					2198
					
				

			

		

		

			
				
微服务都是互相独立的，假如我们的网关和其他服务都在线上已经运行了好久，这个时候增加了一个微服务，这个时候要通过网关访问的话需要通过修改配置文件来增加路由规则，并且需要重启项目，所以我们需要实现动态路由。

			
		

	





	

		

			

				
					
calm-cloud:实践搭建：springcloud + nacos +网关+ springsecurity

				
			

			

				

					03-30
				

			

		

		

			
				
 mybatis-plus的动态数据源###替代实践的版本：spring-boot版本：2.3.8.RELEASE  春云版本：Hoxton.SR9 工程的端口号 平静的网络：81  平静的通道：82  用户服务：83  平静管理员：84  平静认证：85 工程的结构 冷静...

			
		

	





	

		

			

				
					
cloud-nacos-gateway-knife4j:swagger聚合文档！使用技术为：Spring cloud + nacos + gateway + knife4j

				
			

			

				

					03-08
				

			

		

		

			
				
春云+ nacos +网关+ knife4j 这是一个微服务聚合文档 项目文档访问地址：  什么是knife4j？  knife4j就是swagger的升级版，除了美化了swagger的界面。而且还有其他的增强功能 增强功能有哪些？  标签分组标签排序，...

			
		

	





	

		

			

				
					
8.nacos+gateway 动态路由

				
			

			

				

					01-01
				

			

		

		

			
				
Nacos+Gateway 动态路由是 SpringCloud Gateway 中的一种实现方法，主要基于 Nacos 的配置中心和 Gateway 的路由机制，实现了动态路由的配置和更新。  1. Nacos 配置中心  Nacos 是一个开源的配置中心，提供了统一的...

			
		

	





	

		

			

				
					
源码（springCloud+nacos+gateWay）

				
			

			

				

					02-20
				

			

		

		

			
				
里面采用了SpringCloud、springBoot和nacos以及springCloud GateWay,其中还涉及了一部分的sentinel的部分知识点。  主要用来测试网关和注册中心的功能，其中order模块有两个实例，主要用来测试网关权重。

			
		

	





	

		

			

				
					
ims_nacos_gateway+shiro完成认证权限、日志等-Nacos版.rar

				
			

			

				

					06-09
				

			

		

		

			
				
2.spring-gateway作为网关，具备熔断，负载，限流，统一操作日志，认证权限拦截等功能 ； 3.shiro+redis作为认证授权服务 oaa,提供为网关feign接口，用来验证权限 。 注意: 1.nacos1.1.4的安装包和naocs的配置文件也...

			
		

	





	

		

			

				
					
SpringCloudGateway Nacos配置中心与注册中心，动态路由

					
热门推荐

				
			

			

				

					u014087208的博客
				

				

					09-02
					
					30万+
					
				

			

		

		

			
				
SpringCloudGateway+Nacos 集成应用
1. 应用集成(配置中心+应用中心)
参见(SpringCloud+Nacos 配置中心与注册中心应用)
2. 启动服务

3. API文档访问
4. 动态路由
只需要修改对应的配置文件即可，nacos会发起刷新
附录

网关配置

TIMEOUT.IN.MILLISECONDS: 60000
hystrix:
  command:
    fallbackcmd:
      execution:
        isolation:
     

			
		

	





	

		

			

				
					
Nacos集成GateWay网关实现动态路由、全局过滤、跨域请求等

				
			

			

				

					hkl_Forever的博客
				

				

					09-22
					
					3147
					
				

			

		

		

			
				
【3】当 Gateway  用 Pre Filter、Post Filter 来区分过滤器时，如果这个过滤器是Pre Filter，那么执行顺序和排序顺序相同，如果这个过滤器是Post Filter则执行顺序和排序顺序相反。4、特别注意，使用 lb 方式的前提是本网关服务和 lb 路由的服务必须在同一命名空间、同一分组下，否则无法路由。【1】如果在路由配置文件中配置了 order 的值，会按照Route中定义的路由顺序依次排序执行。【1】GatewayFilter：应用到指定路由路由上的过滤器。

			
		

	





	

		

			

				
					
Nacos配置中心优雅配置JSON数据格式

				
			

			

				

					神秘的凯
				

				

					03-24
					
					2687
					
				

			

		

		

			
				
具体使用 只需要 在 NacosConfig 中nacosConfigLocalCacheInfoMap方法添加对应配置映射即可，如下。默认不支持Json格式配置，需要搭配监听器获取配置中心Json数据，返回给客户端。Nacos配置代码： feign-demo→order-service-nacos。6. NacosConfigLocalCatch 核心监听触发类。在我业务开发中，需要在配置中心配置Json数据，返回给前端。二、搭配Nacos配置Josn数据。2. nacos配置-测试案例。

			
		

	





	

		

			

				
					
Gateway高可用集群与动态网关

				
			

			

				

					人生几度秋凉
				

				

					06-23
					
					905
					
				

			

		

		

			
				
https://www.cnblogs.com/ylcc-zyq/p/13156526.html?ivk_sa=1024320u


			
		

	





	

		

			

				
					
IDEA中整合gateway+nacos

				
			

			

				

					04-28
				

			

		

		

			
				
可以按照以下步骤在 IntelliJ IDEA 中整合 Gateway 和 Nacos：

1. 在 pom.xml 文件中添加 Spring Cloud Gateway 和 Spring Cloud Alibaba Nacos 的依赖。

2. 在 application.yml 文件中配置 Gateway 和 Nacos 的相关参数，包括网关路由规则、Nacos 服务注册中心地址等。

3. 在 IDEA 中创建一个 Spring Boot 项目，并添加 Gateway 和 Nacos 的启动注解。

4. 在 IDEA 中启动项目，并检查 Gateway 和 Nacos 是否正常运行。

需要注意的是，整合 Gateway 和 Nacos 的具体步骤可能会根据你的项目需求而有所不同。如果你遇到了问题，可以查看相关文档或向社区寻求帮助。

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值