阿里资深架构师推荐--高性能网关Soul如何设计默认的系统参数？

﹏ヽ暗。殇╰゛Y 2023-01-16 15:24 77阅读 0赞

前言  
1、在开源的高性能服务网关中如何设置系统内置的上下文信息呢？本文将为您详细陈述。

当前使用的SpringBoot版本

<parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.4.0</version>
           <relativePath/> 
       </parent>

一 引入依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>2.4.0</version>
    </dependency>
            
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.8.0</version>
    </dependency>
    
    </dependency>

二 引入依赖说明

引入commons-pools2的目的，是因为spring-boot-data-redis中使用的是lettuce，取代了旧的Jedis。spring-boot-data-redis既然取代了Jedis，那就侧面说明这个luttuce性能更好。不过为了保证稳定性、可靠性，需要引入commons-pools2（含有Jedis）。  
使用fastjson，常用的JSON转换器。  
引入spring-session-data-redis，是因为有个小Bug，在查看了源码之后，还未发现能替换这个依赖库的原生的redisTemplate，后面会有演示。  
编辑application.yml

spring:
        redis:
            host: 127.0.0.1
            port: 6379
            timeout: 3000
            password: 123456
            lettuce:
              pool:
                max-wait: 16
                max-active: 16
                max-idle: 16
                min-idle: 1
              shutdown-timeout: 10000ms  # 关闭超时时间
            database: 0

三 配置Redis配置类

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedissonCacheConfiguration {
    
        @Bean("limitRedisTemplate")
        public RedisTemplate<Object, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            redisTemplate.setConnectionFactory(connectionFactory);
            return redisTemplate;
        }
    
        @Bean("reactiveRedisTemplate")
        public ReactiveRedisTemplate dubheReactiveRedisTemplate(LettuceConnectionFactory connectionFactory) {
            connectionFactory.afterPropertiesSet();
            RedisSerializer<String> serializer = new StringRedisSerializer();
            RedisSerializationContext<String, String> serializationContext = RedisSerializationContext.<String, String>newSerializationContext().key(serializer).value(serializer).hashKey(serializer).hashValue(serializer).build();
            return new ReactiveRedisTemplate<>(dubheLettuceConnectionFactory, serializationContext);
        }
    }

四 缓存使用

package org.dromara.soul.bootstrap.filter;
    
    import lombok.SneakyThrows;
    import org.apache.commons.lang3.StringUtils;
    import org.dromara.soul.bootstrap.configuration.TrafficSourcesTagConfig;
    import org.dromara.soul.plugin.api.result.SoulResultEnum;
    import org.dromara.soul.plugin.api.result.SoulResultWrap;
    import org.dromara.soul.plugin.api.utils.WebFluxResultUtils;
    import org.dromara.soul.plugin.base.constants.SoulContextParamConstants;
    import org.dromara.soul.plugin.base.utils.DefaultContextParamUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.server.reactive.ServerHttpRequest;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    import org.springframework.web.server.WebFilter;
    import org.springframework.web.server.WebFilterChain;
    import reactor.core.publisher.Mono;
    
    import java.util.Map;
    import java.util.function.Consumer;
    
    
    @Component
    public class DefaultContextParamFilter implements WebFilter {
    
        private static Logger logger = LoggerFactory.getLogger(DefaultContextParamFilter.class);
    
        @Autowired
        private RedisTemplate<String, String> limitRedisTemplate;
    
        @SneakyThrows
        @Override
        public Mono<Void> filter(ServerWebExchange serverWebExchange, WebFilterChain webFilterChain) {
            ServerHttpRequest request = serverWebExchange.getRequest();
            HttpHeaders headers = request.getHeaders();
            String msg = checkCommonParameters(serverWebExchange);
            if (StringUtils.isNotBlank(msg)) {
                serverWebExchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
                Object error = SoulResultWrap.error(SoulResultEnum.BAD_REQUEST.getCode(), msg, null);
                return WebFluxResultUtils.result(serverWebExchange, error);
            }
            String token = DefaultContextParamUtils.getDefaultContextParam(request, SoulContextParamConstants.TOKEN);
            if (StringUtils.isNotBlank(token)) {
                String appId = DefaultContextParamUtils.getDefaultContextParam(request, SoulContextParamConstants.APP_ID);
                Map<Object, Object> loginUserInfo =  limitRedisTemplate.opsForHash().entries(DefaultContextParamUtils.getLoginCacheKey(appId, token));
                if(!loginUserInfo.isEmpty()){
                    Consumer<HttpHeaders> httpHeaders = httpHeader -> {
                        loginUserInfo.forEach((key,value)->{
                            String k = String.valueOf(key);
                            String v = String.valueOf(value);
                            if(!headers.containsKey(key)){
                                httpHeader.set(k, v);
                            }
                        });
                    };
                    request.mutate().headers(httpHeaders);
                }
            }
    
            return webFilterChain.filter(serverWebExchange);
        }
    
        private String checkCommonParameters(final ServerWebExchange exchange){
            final ServerHttpRequest request = exchange.getRequest();
            final String trafficSources = DefaultContextParamUtils.getDefaultContextParam(request, SoulContextParamConstants.TRAFFIC_SOURCES);
            String msg = "";
            if (StringUtils.isBlank(trafficSources)) {
                msg = "请在请求Header中添加traffic-sources标识";
                logger.error("DefaultContextParamFilter.checkCommonParameters: failure! msg={}}", trafficSources, msg);
                return msg;
            }
            /**
             * 过滤非法请求来源
             */
            if(TrafficSourcesTagConfig.getTrafficSourcesTags().contains(trafficSources)){
                if(StringUtils.isBlank(DefaultContextParamUtils.getDefaultContextParam(request, SoulContextParamConstants.TIMESTAMP))){
                    msg = "请在请求Header中添加"+SoulContextParamConstants.TIMESTAMP+"标识";
                    logger.error("DefaultContextParamFilter.checkCommonParameters: failure! msg={}}", msg);
                    return msg;
                }
                if(StringUtils.isBlank(DefaultContextParamUtils.getDefaultContextParam(request, SoulContextParamConstants.APPKEY))){
                    msg = "请在请求Header中添加"+SoulContextParamConstants.APPKEY+"标识";
                    logger.error("DefaultContextParamFilter.checkCommonParameters: failure! msg={}}", msg);
                    return msg;
                }
                if(StringUtils.isBlank(DefaultContextParamUtils.getDefaultContextParam(request, SoulContextParamConstants.SIGN))){
                    msg = "请在请求Header中添加"+SoulContextParamConstants.SIGN+"标识";
                    logger.error("DefaultContextParamFilter.checkCommonParameters: failure! msg={}}", msg);
                    return msg;
                }
                if(StringUtils.isBlank(DefaultContextParamUtils.getDefaultContextParam(request, SoulContextParamConstants.VERSION))){
                    msg = "请在请求Header中添加"+SoulContextParamConstants.VERSION+"标识";
                    logger.error("DefaultContextParamFilter.checkCommonParameters: failure! msg={}}", msg);
                    return msg;
                }
                return msg;
            } else {
                return msg;
            }
        }
    }

五 工具服务

package org.dromara.soul.plugin.base.utils;
    
    import org.apache.commons.lang3.StringUtils;
    import org.dromara.soul.common.enums.WeiEaseAppEnum;
    import org.dromara.soul.plugin.api.context.SoulContext;
    import org.dromara.soul.plugin.base.constants.SoulContextParamConstants;
    import org.springframework.http.HttpCookie;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.server.reactive.ServerHttpRequest;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Mono;
    
    import java.util.Map;
    
    
    public class DefaultContextParamUtils {
    
        private static String getValueFromHeaders(final ServerHttpRequest request, final String key){
            final HttpHeaders headers = request.getHeaders();
            final String value = headers.getFirst(key);
            if (StringUtils.isBlank(value)) {
                return null;
            } else {
                return value;
            }
        }
    
        private static String getValueFromCookie(final ServerHttpRequest request, final String key) {
            HttpCookie cookie = request.getCookies().getFirst(key);
            if (cookie == null) {
                return null;
            } else {
                return cookie.getValue();
            }
        }
    
        public static String getDefaultContextParam(ServerHttpRequest request, String key) {
            String value = getValueFromHeaders(request, key);
            return StringUtils.isBlank(value) ? getValueFromCookie(request, key) : value;
        }
    
    
        public static String getLoginCacheKey(String appId, String token){
     
            String cacheKey = SoulContextParamConstants.USER_SERVICE_USER_INFO_KEY_BY_TOKEN + appId + "_" + token;
            return cacheKey;
        }
    }

六 转换上下文信息

import org.apache.commons.lang3.StringUtils;
    import org.dromara.soul.common.constant.Constants;
    import org.dromara.soul.plugin.api.SoulPlugin;
    import org.dromara.soul.plugin.api.SoulPluginChain;
    import org.dromara.soul.plugin.api.context.SoulContext;
    import org.dromara.soul.plugin.api.context.SoulContextBuilder;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.server.reactive.ServerHttpRequest;
    import org.springframework.util.MultiValueMap;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Mono;
    
    /**
     * The type Global plugin.
     */
    public class GlobalPlugin implements SoulPlugin {
        
        private final SoulContextBuilder builder;
        
        /**
         * Instantiates a new Global plugin.
         *
         * @param builder the builder
         */
        public GlobalPlugin(final SoulContextBuilder builder) {
            this.builder = builder;
        }
        
        @Override
        public Mono<Void> execute(final ServerWebExchange exchange, final SoulPluginChain chain) {
            final ServerHttpRequest request = exchange.getRequest();
            final HttpHeaders headers = request.getHeaders();
            final String upgrade = headers.getFirst("Upgrade");
            SoulContext soulContext;
            if (StringUtils.isBlank(upgrade) || !"websocket".equals(upgrade)) {
                soulContext = builder.build(exchange);
            } else {
                final MultiValueMap<String, String> queryParams = request.getQueryParams();
                soulContext = transformMap(queryParams);
            }
            exchange.getAttributes().put(Constants.CONTEXT, soulContext);
            return chain.execute(exchange);
        }
        
        @Override
        public int getOrder() {
            return 0;
        }
        
        private SoulContext transformMap(final MultiValueMap<String, String> queryParams) {
            SoulContext soulContext = new SoulContext();
            soulContext.setModule(queryParams.getFirst(Constants.MODULE));
            soulContext.setMethod(queryParams.getFirst(Constants.METHOD));
            soulContext.setRpcType(queryParams.getFirst(Constants.RPC_TYPE));
            return soulContext;
        }
        
        @Override
        public String named() {
            return "global";
        }
    }