如何设计一个高性能网关？-

沙海

3185
文章

2
评论

2021年3月19日01:55:54杂谈 Java评论23字数 28435阅读94分47秒阅读模式

摘要

速读摘要

速读摘要文章源自JAVA秀-https://www.javaxiu.com/5348.html

最近在github上看了soul网关的设计，突然就来了兴趣准备自己从零开始写一个高性能的网关。经过两周时间的开发，我的网关ship-gate核心功能基本都已完成，最大的缺陷就是前端功底太差没有管理后台。20个线程，500个连接数，吞吐量大概每秒9400个请求。千里之行始于足下，开始以为写一个网关会很难，但当你实际开始行动时就会发现其实没那么难，所以迈出第一步很重要。过程中也遇到了很多问题，还在github上给soul和nacos这两个开源项目提了两个issue，后来发现是自己的问题文章源自JAVA秀-https://www.javaxiu.com/5348.html

原文约 4115 字 | 图片 11 张 | 建议阅读 9 分钟 | 评价反馈文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？

程序IT圈文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

- 背景 -文章源自JAVA秀-https://www.javaxiu.com/5348.html

最近在github上看了soul网关的设计，突然就来了兴趣准备自己从零开始写一个高性能的网关。经过两周时间的开发，我的网关ship-gate核心功能基本都已完成，最大的缺陷就是前端功底太差没有管理后台。文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

- 设计 -文章源自JAVA秀-https://www.javaxiu.com/5348.html

1、技术选型

网关是所有请求的入口，所以要求有很高的吞吐量，为了实现这点可以使用请求异步化来解决。目前一般有以下两种方案：文章源自JAVA秀-https://www.javaxiu.com/5348.html

Tomcat/Jetty+NIO+Servlet3文章源自JAVA秀-https://www.javaxiu.com/5348.html

Servlet3已经支持异步，这种方案使用比较多，京东，有赞和Zuul，都用的是这种方案。文章源自JAVA秀-https://www.javaxiu.com/5348.html

Netty+NIO文章源自JAVA秀-https://www.javaxiu.com/5348.html

Netty为高并发而生，目前唯品会的网关使用这个策略，在唯品会的技术文章中在相同的情况下Netty是每秒30w+的吞吐量，Tomcat是13w+,可以看出是有一定的差距的，但是Netty需要自己处理HTTP协议，这一块比较麻烦。文章源自JAVA秀-https://www.javaxiu.com/5348.html

后面发现Soul网关是基于Spring WebFlux（底层Netty）的，不用太关心HTTP协议的处理，于是决定也用Spring WebFlux。文章源自JAVA秀-https://www.javaxiu.com/5348.html

网关的第二个特点是具备可扩展性，比如Netflix Zuul有preFilters，postFilters等在不同的阶段方便处理不同的业务，基于责任链模式将请求进行链式处理即可实现。文章源自JAVA秀-https://www.javaxiu.com/5348.html

在微服务架构下，服务都会进行多实例部署来保证高可用，请求到达网关时，网关需要根据URL找到所有可用的实例，这时就需要服务注册和发现功能，即注册中心。文章源自JAVA秀-https://www.javaxiu.com/5348.html

现在流行的注册中心有Apache的Zookeeper和阿里的Nacos两种（consul有点小众），因为之前写RPC框架时已经用过了Zookeeper，所以这次就选择了Nacos。文章源自JAVA秀-https://www.javaxiu.com/5348.html

2、需求清单

首先要明确目标，即开发一个具备哪些特性的网关，总结下后如下：文章源自JAVA秀-https://www.javaxiu.com/5348.html

自定义路由规则文章源自JAVA秀-https://www.javaxiu.com/5348.html

可基于version的路由规则设置，路由对象包括DEFAUL,HEADER和QUERY三种，匹配方式包括=、regex、like三种。文章源自JAVA秀-https://www.javaxiu.com/5348.html

跨语言文章源自JAVA秀-https://www.javaxiu.com/5348.html

HTTP协议天生跨语言文章源自JAVA秀-https://www.javaxiu.com/5348.html

高性能文章源自JAVA秀-https://www.javaxiu.com/5348.html

Netty本身就是一款高性能的通信框架，同时server将一些路由规则等数据缓存到JVM内存避免请求admin服务。文章源自JAVA秀-https://www.javaxiu.com/5348.html

高可用文章源自JAVA秀-https://www.javaxiu.com/5348.html

支持集群模式防止单节点故障，无状态。文章源自JAVA秀-https://www.javaxiu.com/5348.html

灰度发布文章源自JAVA秀-https://www.javaxiu.com/5348.html

灰度发布（又名金丝雀发布）是指在黑与白之间，能够平滑过渡的一种发布方式。在其上可以进行A/B testing，即让一部分用户继续用产品特性A，一部分用户开始用产品特性B，如果用户对B没有什么反对意见，那么逐步扩大范围，把所有用户都迁移到B上面来。通过特性一可以实现。文章源自JAVA秀-https://www.javaxiu.com/5348.html

接口鉴权文章源自JAVA秀-https://www.javaxiu.com/5348.html

基于责任链模式，用户开发自己的鉴权插件即可。文章源自JAVA秀-https://www.javaxiu.com/5348.html

负载均衡文章源自JAVA秀-https://www.javaxiu.com/5348.html

支持多种负载均衡算法，如随机，轮询，加权轮询等。利用SPI机制可以根据配置进行动态加载。文章源自JAVA秀-https://www.javaxiu.com/5348.html

3、架构设计

在参考了一些优秀的网关Zuul,Spring Cloud Gateway,Soul后，将项目划分为以下几个模块。文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

它们之间的关系如图：文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

网关设计文章源自JAVA秀-https://www.javaxiu.com/5348.html

注意：这张图与实际实现有点出入，Nacos push到本地缓存的那个环节没有实现，目前只有ship-sever定时轮询pull的过程。ship-admin从Nacos获取注册服务信息的过程，也改成了ServiceA启动时主动发生HTTP请求通知ship-admin。文章源自JAVA秀-https://www.javaxiu.com/5348.html

4、表结构设计

文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

- 编码 -文章源自JAVA秀-https://www.javaxiu.com/5348.html

1、ship-client-spring-boot-starter文章源自JAVA秀-https://www.javaxiu.com/5348.html

首先创建一个spring-boot-starter命名为ship-client-spring-boot-starter，不知道如何自定义starter的可以看我以前写的《开发自己的starter》。文章源自JAVA秀-https://www.javaxiu.com/5348.html

其核心类 AutoRegisterListener 就是在项目启动时做了两件事：文章源自JAVA秀-https://www.javaxiu.com/5348.html

1.将服务信息注册到Nacos注册中心文章源自JAVA秀-https://www.javaxiu.com/5348.html

2.通知ship-admin服务上线了并注册下线hook。文章源自JAVA秀-https://www.javaxiu.com/5348.html

代码如下：文章源自JAVA秀-https://www.javaxiu.com/5348.html

* Created by 2YSP on 2020/12/21*/public class AutoRegisterListener implements ApplicationListener<ContextRefreshedEvent> {   private final static Logger LOGGER = LoggerFactory.getLogger(AutoRegisterListener.class);   private volatile AtomicBoolean registered = new AtomicBoolean(false);   private final ClientConfigProperties properties;   @NacosInjected   private NamingService namingService;   @Autowired   private RequestMappingHandlerMapping handlerMapping;   private final ExecutorService pool;   /*** url list to ignore*/   private static List<String> ignoreUrlList = new LinkedList<>();   static {       ignoreUrlList.add("/error");   }   public AutoRegisterListener(ClientConfigProperties properties) {       if (!check(properties)) {           LOGGER.error("client config port,contextPath,appName adminUrl and version can't be empty!");           throw new ShipException("client config port,contextPath,appName adminUrl and version can't be empty!");       }       this.properties = properties;       pool = new ThreadPoolExecutor(1, 4, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());   }   /*** check the ClientConfigProperties** @param properties* @return*/   private boolean check(ClientConfigProperties properties) {       if (properties.getPort() == null| properties.getContextPath() == null              | properties.getVersion() == null| properties.getAppName() == null              | properties.getAdminUrl() == null) {           return false;       }       return true;   }   @Override   public void onApplicationEvent(ContextRefreshedEvent event) {       if (!registered.compareAndSet(false, true)) {           return;       }       doRegister();       registerShutDownHook();   }   /*** send unregister request to admin when jvm shutdown*/   private void registerShutDownHook() {       final String url = "http://" + properties.getAdminUrl() + AdminConstants.UNREGISTER_PATH;       final UnregisterAppDTO unregisterAppDTO = new UnregisterAppDTO();       unregisterAppDTO.setAppName(properties.getAppName());       unregisterAppDTO.setVersion(properties.getVersion());       unregisterAppDTO.setIp(IpUtil.getLocalIpAddress());       unregisterAppDTO.setPort(properties.getPort());       Runtime.getRuntime().addShutdownHook(new Thread(() -> {           OkhttpTool.doPost(url, unregisterAppDTO);           LOGGER.info("[{}:{}] unregister from ship-admin success!", unregisterAppDTO.getAppName(), unregisterAppDTO.getVersion());       }));   }   /*** register all interface info to register center*/   private void doRegister() {       Instance instance = new Instance();       instance.setIp(IpUtil.getLocalIpAddress());       instance.setPort(properties.getPort());       instance.setEphemeral(true);       Map<String, String> metadataMap = new HashMap<>();       metadataMap.put("version", properties.getVersion());       metadataMap.put("appName", properties.getAppName());       instance.setMetadata(metadataMap);       try {           namingService.registerInstance(properties.getAppName(), NacosConstants.APP_GROUP_NAME, instance);       } catch (NacosException e) {           LOGGER.error("register to nacos fail", e);           throw new ShipException(e.getErrCode(), e.getErrMsg());       }       LOGGER.info("register interface info to nacos success!");       // send register request to ship-admin       String url = "http://" + properties.getAdminUrl() + AdminConstants.REGISTER_PATH;       RegisterAppDTO registerAppDTO = buildRegisterAppDTO(instance);       OkhttpTool.doPost(url, registerAppDTO);       LOGGER.info("register to ship-admin success!");   }   private RegisterAppDTO buildRegisterAppDTO(Instance instance) {       RegisterAppDTO registerAppDTO = new RegisterAppDTO();       registerAppDTO.setAppName(properties.getAppName());       registerAppDTO.setContextPath(properties.getContextPath());       registerAppDTO.setIp(instance.getIp());       registerAppDTO.setPort(instance.getPort());       registerAppDTO.setVersion(properties.getVersion());       return registerAppDTO;   }}

2、ship-server文章源自JAVA秀-https://www.javaxiu.com/5348.html

ship-sever项目主要包括了两个部分内容， 1.请求动态路由的主流程 2.本地缓存数据和ship-admin及nacos同步，这部分在后面3.3再讲。文章源自JAVA秀-https://www.javaxiu.com/5348.html

ship-server实现动态路由的原理是利用WebFilter拦截请求，然后将请求教给plugin chain去链式处理。文章源自JAVA秀-https://www.javaxiu.com/5348.html

PluginFilter根据URL解析出appName，然后将启用的plugin组装成plugin chain。文章源自JAVA秀-https://www.javaxiu.com/5348.html

public class PluginFilter implements WebFilter {   private ServerConfigProperties properties;   public PluginFilter(ServerConfigProperties properties) {       this.properties = properties;   }   @Override   public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {       String appName = parseAppName(exchange);       if (CollectionUtils.isEmpty(ServiceCache.getAllInstances(appName))) {           throw new ShipException(ShipExceptionEnum.SERVICE_NOT_FIND);       }       PluginChain pluginChain = new PluginChain(properties, appName);       pluginChain.addPlugin(new DynamicRoutePlugin(properties));       pluginChain.addPlugin(new AuthPlugin(properties));       return pluginChain.execute(exchange, pluginChain);   }   private String parseAppName(ServerWebExchange exchange) {       RequestPath path = exchange.getRequest().getPath();       String appName = path.value().split("/")[1];       return appName;   }}```PluginChain继承了AbstractShipPlugin并持有所有要执行的插件。```java* @Author: Ship* @Description:* @Date: Created in 2020/12/25*/public class PluginChain extends AbstractShipPlugin {   /*** the pos point to current plugin*/   private int pos;   /*** the plugins of chain*/   private List<ShipPlugin> plugins;   private final String appName;   public PluginChain(ServerConfigProperties properties, String appName) {       super(properties);       this.appName = appName;   }   /*** add enabled plugin to chain** @param shipPlugin*/   public void addPlugin(ShipPlugin shipPlugin) {       if (plugins == null) {           plugins = new ArrayList<>();       }       if (!PluginCache.isEnabled(appName, shipPlugin.name())) {           return;       }       plugins.add(shipPlugin);       // order by the plugin's order       plugins.sort(Comparator.comparing(ShipPlugin::order));   }   @Override   public Integer order() {       return null;   }   @Override   public String name() {       return null;   }   @Override   public Mono<Void> execute(ServerWebExchange exchange, PluginChain pluginChain) {       if (pos == plugins.size()) {           return exchange.getResponse().setComplete();       }       return pluginChain.plugins.get(pos++).execute(exchange, pluginChain);   }   public String getAppName() {       return appName;   }}

AbstractShipPlugin实现了ShipPlugin接口，并持有ServerConfigProperties配置对象。文章源自JAVA秀-https://www.javaxiu.com/5348.html

public abstract class AbstractShipPlugin implements ShipPlugin {   protected ServerConfigProperties properties;   public AbstractShipPlugin(ServerConfigProperties properties) {       this.properties = properties;   }}```ShipPlugin接口定义了所有插件必须实现的三个方法order(),name()和execute()。```javapublic interface ShipPlugin {   /*** lower values have higher priority** @return*/   Integer order();   /*** return current plugin name** @return*/   String name();   Mono<Void> execute(ServerWebExchange exchange,PluginChain pluginChain);}```DynamicRoutePlugin继承了抽象类AbstractShipPlugin，包含了动态路由的主要业务逻辑。```java* @Author: Ship* @Description:* @Date: Created in 2020/12/25*/public class DynamicRoutePlugin extends AbstractShipPlugin {   private final static Logger LOGGER = LoggerFactory.getLogger(DynamicRoutePlugin.class);   private static WebClient webClient;   private static final Gson gson = new GsonBuilder().create();   static {       HttpClient httpClient = HttpClient.create()               .tcpConfiguration(client ->                       client.doOnConnected(conn ->                               conn.addHandlerLast(new ReadTimeoutHandler(3))                                       .addHandlerLast(new WriteTimeoutHandler(3)))                               .option(ChannelOption.TCP_NODELAY, true)               );       webClient = WebClient.builder().clientConnector(new ReactorClientHttpConnector(httpClient))               .build();   }   public DynamicRoutePlugin(ServerConfigProperties properties) {       super(properties);   }   @Override   public Integer order() {       return ShipPluginEnum.DYNAMIC_ROUTE.getOrder();   }   @Override   public String name() {       return ShipPluginEnum.DYNAMIC_ROUTE.getName();   }   @Override   public Mono<Void> execute(ServerWebExchange exchange, PluginChain pluginChain) {       String appName = pluginChain.getAppName();       ServiceInstance serviceInstance = chooseInstance(appName, exchange.getRequest());//        LOGGER.info("selected instance is [{}]", gson.toJson(serviceInstance));       // request service       String url = buildUrl(exchange, serviceInstance);       return forward(exchange, url);   }   /*** forward request to backend service** @param exchange* @param url* @return*/   private Mono<Void> forward(ServerWebExchange exchange, String url) {       ServerHttpRequest request = exchange.getRequest();       ServerHttpResponse response = exchange.getResponse();       HttpMethod method = request.getMethod();       WebClient.RequestBodySpec requestBodySpec = webClient.method(method).uri(url).headers((headers) -> {           headers.addAll(request.getHeaders());       });       WebClient.RequestHeadersSpec<?> reqHeadersSpec;       if (requireHttpBody(method)) {           reqHeadersSpec = requestBodySpec.body(BodyInserters.fromDataBuffers(request.getBody()));       } else {           reqHeadersSpec = requestBodySpec;       }       // nio->callback->nio       return reqHeadersSpec.exchange().timeout(Duration.ofMillis(properties.getTimeOutMillis()))               .onErrorResume(ex -> {                   return Mono.defer(() -> {                       String errorResultJson = "";                       if (ex instanceof TimeoutException) {                           errorResultJson = "{\"code\":5001,\"message\":\"network timeout\"}";                       } else {                           errorResultJson = "{\"code\":5000,\"message\":\"system error\"}";                       }                       return ShipResponseUtil.doResponse(exchange, errorResultJson);                   }).then(Mono.empty());               }).flatMap(backendResponse -> {                   response.setStatusCode(backendResponse.statusCode());                   response.getHeaders().putAll(backendResponse.headers().asHttpHeaders());                   return response.writeWith(backendResponse.bodyToFlux(DataBuffer.class));               });   }   /*** weather the http method need http body** @param method* @return*/   private boolean requireHttpBody(HttpMethod method) {       if (method.equals(HttpMethod.POST)| method.equals(HttpMethod.PUT)| method.equals(HttpMethod.PATCH)) {           return true;       }       return false;   }   private String buildUrl(ServerWebExchange exchange, ServiceInstance serviceInstance) {       ServerHttpRequest request = exchange.getRequest();       String query = request.getURI().getQuery();       String path = request.getPath().value().replaceFirst("/" + serviceInstance.getAppName(), "");       String url = "http://" + serviceInstance.getIp() + ":" + serviceInstance.getPort() + path;       if (!StringUtils.isEmpty(query)) {           url = url + "?" + query;       }       return url;   }   /*** choose an ServiceInstance according to route rule config and load balancing algorithm** @param appName* @param request* @return*/   private ServiceInstance chooseInstance(String appName, ServerHttpRequest request) {       List<ServiceInstance> serviceInstances = ServiceCache.getAllInstances(appName);       if (CollectionUtils.isEmpty(serviceInstances)) {           LOGGER.error("service instance of {} not find", appName);           throw new ShipException(ShipExceptionEnum.SERVICE_NOT_FIND);       }       String version = matchAppVersion(appName, request);       if (StringUtils.isEmpty(version)) {           throw new ShipException("match app version error");       }       // filter serviceInstances by version       List<ServiceInstance> instances = serviceInstances.stream().filter(i -> i.getVersion().equals(version)).collect(Collectors.toList());       //Select an instance based on the load balancing algorithm       LoadBalance loadBalance = LoadBalanceFactory.getInstance(properties.getLoadBalance(), appName, version);       ServiceInstance serviceInstance = loadBalance.chooseOne(instances);       return serviceInstance;   }   private String matchAppVersion(String appName, ServerHttpRequest request) {       List<AppRuleDTO> rules = RouteRuleCache.getRules(appName);       rules.sort(Comparator.comparing(AppRuleDTO::getPriority).reversed());       for (AppRuleDTO rule : rules) {           if (match(rule, request)) {               return rule.getVersion();           }       }       return null;   }   private boolean match(AppRuleDTO rule, ServerHttpRequest request) {       String matchObject = rule.getMatchObject();       String matchKey = rule.getMatchKey();       String matchRule = rule.getMatchRule();       Byte matchMethod = rule.getMatchMethod();       if (MatchObjectEnum.DEFAULT.getCode().equals(matchObject)) {           return true;       } else if (MatchObjectEnum.QUERY.getCode().equals(matchObject)) {           String param = request.getQueryParams().getFirst(matchKey);           if (!StringUtils.isEmpty(param)) {               return StringTools.match(param, matchMethod, matchRule);           }       } else if (MatchObjectEnum.HEADER.getCode().equals(matchObject)) {           HttpHeaders headers = request.getHeaders();           String headerValue = headers.getFirst(matchKey);           if (!StringUtils.isEmpty(headerValue)) {               return StringTools.match(headerValue, matchMethod, matchRule);           }       }       return false;   }}

3、数据同步

app数据同步文章源自JAVA秀-https://www.javaxiu.com/5348.html

后台服务（如订单服务）启动时，只将服务名，版本，ip地址和端口号注册到了Nacos，并没有实例的权重和启用的插件信息怎么办？文章源自JAVA秀-https://www.javaxiu.com/5348.html

一般在线的实例权重和插件列表都是在管理界面配置，然后动态生效的，所以需要ship-admin定时更新实例的权重和插件信息到注册中心。文章源自JAVA秀-https://www.javaxiu.com/5348.html

对应代码ship-admin的NacosSyncListener：文章源自JAVA秀-https://www.javaxiu.com/5348.html

* @Author: Ship* @Description:* @Date: Created in 2020/12/30*/@Configurationpublic class NacosSyncListener implements ApplicationListener<ContextRefreshedEvent> {   private static final Logger LOGGER = LoggerFactory.getLogger(NacosSyncListener.class);   private static ScheduledThreadPoolExecutor scheduledPool = new ScheduledThreadPoolExecutor(1,           new ShipThreadFactory("nacos-sync", true).create());   @NacosInjected   private NamingService namingService;   @Value("${nacos.discovery.server-addr}")   private String baseUrl;   @Resource   private AppService appService;   @Override   public void onApplicationEvent(ContextRefreshedEvent event) {       if (event.getApplicationContext().getParent() != null) {           return;       }       String url = "http://" + baseUrl + NacosConstants.INSTANCE_UPDATE_PATH;       scheduledPool.scheduleWithFixedDelay(new NacosSyncTask(namingService, url, appService), 0, 30L, TimeUnit.SECONDS);   }   class NacosSyncTask implements Runnable {       private NamingService namingService;       private String url;       private AppService appService;       private Gson gson = new GsonBuilder().create();       public NacosSyncTask(NamingService namingService, String url, AppService appService) {           this.namingService = namingService;           this.url = url;           this.appService = appService;       }       /*** Regular update weight,enabled plugins to nacos instance*/       @Override       public void run() {           try {               // get all app names               ListView<String> services = namingService.getServicesOfServer(1, Integer.MAX_VALUE, NacosConstants.APP_GROUP_NAME);               if (CollectionUtils.isEmpty(services.getData())) {                   return;               }               List<String> appNames = services.getData();               List<AppInfoDTO> appInfos = appService.getAppInfos(appNames);               for (AppInfoDTO appInfo : appInfos) {                   if (CollectionUtils.isEmpty(appInfo.getInstances())) {                       continue;                   }                   for (ServiceInstance instance : appInfo.getInstances()) {                       Map<String, Object> queryMap = buildQueryMap(appInfo, instance);                       String resp = OkhttpTool.doPut(url, queryMap, "");                       LOGGER.debug("response :{}", resp);                   }               }           } catch (Exception e) {               LOGGER.error("nacos sync task error", e);           }       }       private Map<String, Object> buildQueryMap(AppInfoDTO appInfo, ServiceInstance instance) {           Map<String, Object> map = new HashMap<>();           map.put("serviceName", appInfo.getAppName());           map.put("groupName", NacosConstants.APP_GROUP_NAME);           map.put("ip", instance.getIp());           map.put("port", instance.getPort());           map.put("weight", instance.getWeight().doubleValue());           NacosMetadata metadata = new NacosMetadata();           metadata.setAppName(appInfo.getAppName());           metadata.setVersion(instance.getVersion());           metadata.setPlugins(String.join(",", appInfo.getEnabledPlugins()));           map.put("metadata", StringTools.urlEncode(gson.toJson(metadata)));           map.put("ephemeral", true);           return map;       }   }}

ship-server再定时从Nacos拉取app数据更新到本地Map缓存。文章源自JAVA秀-https://www.javaxiu.com/5348.html

* @Author: Ship* @Description: sync data to local cache* @Date: Created in 2020/12/25*/@Configurationpublic class DataSyncTaskListener implements ApplicationListener<ContextRefreshedEvent> {   private static ScheduledThreadPoolExecutor scheduledPool = new ScheduledThreadPoolExecutor(1,           new ShipThreadFactory("service-sync", true).create());   @NacosInjected   private NamingService namingService;   @Autowired   private ServerConfigProperties properties;   @Override   public void onApplicationEvent(ContextRefreshedEvent event) {       if (event.getApplicationContext().getParent() != null) {           return;       }       scheduledPool.scheduleWithFixedDelay(new DataSyncTask(namingService)               , 0L, properties.getCacheRefreshInterval(), TimeUnit.SECONDS);       WebsocketSyncCacheServer websocketSyncCacheServer = new WebsocketSyncCacheServer(properties.getWebSocketPort());       websocketSyncCacheServer.start();   }   class DataSyncTask implements Runnable {       private NamingService namingService;       public DataSyncTask(NamingService namingService) {           this.namingService = namingService;       }       @Override       public void run() {           try {               // get all app names               ListView<String> services = namingService.getServicesOfServer(1, Integer.MAX_VALUE, NacosConstants.APP_GROUP_NAME);               if (CollectionUtils.isEmpty(services.getData())) {                   return;               }               List<String> appNames = services.getData();               // get all instances               for (String appName : appNames) {                   List<Instance> instanceList = namingService.getAllInstances(appName, NacosConstants.APP_GROUP_NAME);                   if (CollectionUtils.isEmpty(instanceList)) {                       continue;                   }                   ServiceCache.add(appName, buildServiceInstances(instanceList));                   List<String> pluginNames = getEnabledPlugins(instanceList);                   PluginCache.add(appName, pluginNames);               }               ServiceCache.removeExpired(appNames);               PluginCache.removeExpired(appNames);           } catch (NacosException e) {               e.printStackTrace();           }       }       private List<String> getEnabledPlugins(List<Instance> instanceList) {           Instance instance = instanceList.get(0);           Map<String, String> metadata = instance.getMetadata();           // plugins: DynamicRoute,Auth           String plugins = metadata.getOrDefault("plugins", ShipPluginEnum.DYNAMIC_ROUTE.getName());           return Arrays.stream(plugins.split(",")).collect(Collectors.toList());       }       private List<ServiceInstance> buildServiceInstances(List<Instance> instanceList) {           List<ServiceInstance> list = new LinkedList<>();           instanceList.forEach(instance -> {               Map<String, String> metadata = instance.getMetadata();               ServiceInstance serviceInstance = new ServiceInstance();               serviceInstance.setAppName(metadata.get("appName"));               serviceInstance.setIp(instance.getIp());               serviceInstance.setPort(instance.getPort());               serviceInstance.setVersion(metadata.get("version"));               serviceInstance.setWeight((int) instance.getWeight());               list.add(serviceInstance);           });           return list;       }   }}

路由规则数据同步文章源自JAVA秀-https://www.javaxiu.com/5348.html

同时，如果用户在管理后台更新了路由规则，ship-admin需要推送规则数据到ship-server，这里参考了soul网关的做法利用websocket在第一次建立连接后进行全量同步，此后路由规则发生变更就只作增量同步。文章源自JAVA秀-https://www.javaxiu.com/5348.html

服务端WebsocketSyncCacheServer：文章源自JAVA秀-https://www.javaxiu.com/5348.html

* @Author: Ship* @Description:* @Date: Created in 2020/12/28*/public class WebsocketSyncCacheServer extends WebSocketServer {   private final static Logger LOGGER = LoggerFactory.getLogger(WebsocketSyncCacheServer.class);   private Gson gson = new GsonBuilder().create();   private MessageHandler messageHandler;   public WebsocketSyncCacheServer(Integer port) {       super(new InetSocketAddress(port));       this.messageHandler = new MessageHandler();   }   @Override   public void onOpen(WebSocket webSocket, ClientHandshake clientHandshake) {       LOGGER.info("server is open");   }   @Override   public void onClose(WebSocket webSocket, int i, String s, boolean b) {       LOGGER.info("websocket server close...");   }   @Override   public void onMessage(WebSocket webSocket, String message) {       LOGGER.info("websocket server receive message:\n[{}]", message);       this.messageHandler.handler(message);   }   @Override   public void onError(WebSocket webSocket, Exception e) {   }   @Override   public void onStart() {       LOGGER.info("websocket server start...");   }   class MessageHandler {       public void handler(String message) {           RouteRuleOperationDTO operationDTO = gson.fromJson(message, RouteRuleOperationDTO.class);           if (CollectionUtils.isEmpty(operationDTO.getRuleList())) {               return;           }           Map<String, List<AppRuleDTO>> map = operationDTO.getRuleList()                   .stream().collect(Collectors.groupingBy(AppRuleDTO::getAppName));           if (OperationTypeEnum.INSERT.getCode().equals(operationDTO.getOperationType())                  | OperationTypeEnum.UPDATE.getCode().equals(operationDTO.getOperationType())) {               RouteRuleCache.add(map);           } else if (OperationTypeEnum.DELETE.getCode().equals(operationDTO.getOperationType())) {               RouteRuleCache.remove(map);           }       }   }}

客户端WebsocketSyncCacheClient：文章源自JAVA秀-https://www.javaxiu.com/5348.html

* @Author: Ship* @Description:* @Date: Created in 2020/12/28*/@Componentpublic class WebsocketSyncCacheClient {   private final static Logger LOGGER = LoggerFactory.getLogger(WebsocketSyncCacheClient.class);   private WebSocketClient client;   private RuleService ruleService;   private Gson gson = new GsonBuilder().create();   public WebsocketSyncCacheClient(@Value("${ship.server-web-socket-url}") String serverWebSocketUrl,RuleService ruleService) {       if (StringUtils.isEmpty(serverWebSocketUrl)) {           throw new ShipException(ShipExceptionEnum.CONFIG_ERROR);       }       this.ruleService = ruleService;       ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1,               new ShipThreadFactory("websocket-connect", true).create());       try {           client = new WebSocketClient(new URI(serverWebSocketUrl)) {               @Override               public void onOpen(ServerHandshake serverHandshake) {                   LOGGER.info("client is open");                   List<AppRuleDTO> list = ruleService.getEnabledRule();                   String msg = gson.toJson(new RouteRuleOperationDTO(OperationTypeEnum.INSERT, list));                   send(msg);               }               @Override               public void onMessage(String s) {               }               @Override               public void onClose(int i, String s, boolean b) {               }               @Override               public void onError(Exception e) {                   LOGGER.error("websocket client error", e);               }           };           client.connectBlocking();           //使用调度线程池进行断线重连，30秒进行一次           executor.scheduleAtFixedRate(() -> {               if (client != null && client.isClosed()) {                   try {                       client.reconnectBlocking();                   } catch (InterruptedException e) {                       LOGGER.error("reconnect server fail", e);                   }               }           }, 10, 30, TimeUnit.SECONDS);       } catch (Exception e) {           LOGGER.error("websocket sync cache exception", e);           throw new ShipException(e.getMessage());       }   }   public <T> void send(T t) {       while (!client.getReadyState().equals(ReadyState.OPEN)) {           LOGGER.debug("connecting ...please wait");       }       client.send(gson.toJson(t));   }}

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

- 测试 -文章源自JAVA秀-https://www.javaxiu.com/5348.html

1、动态路由测试

本地启动nacos ,sh startup.sh -m standalone；文章源自JAVA秀-https://www.javaxiu.com/5348.html
启动ship-admin；文章源自JAVA秀-https://www.javaxiu.com/5348.html
本地启动两个ship-example实例。文章源自JAVA秀-https://www.javaxiu.com/5348.html

实例1配置：文章源自JAVA秀-https://www.javaxiu.com/5348.html

ship: http:   app-name: order   version: gray_1.0   context-path: /order   port: 8081   admin-url: 127.0.0.1:9001 server: port: 8081 nacos: discovery:   server-addr: 127.0.0.1:8848

实例2配置：文章源自JAVA秀-https://www.javaxiu.com/5348.html

ship: http:   app-name: order   version: prod_1.0   context-path: /order   port: 8082   admin-url: 127.0.0.1:9001 server: port: 8082 nacos: discovery:   server-addr: 127.0.0.1:8848

在数据库添加路由规则配置，该规则表示当http header 中的name=ship时请求路由到gray_1.0版本的节点。文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

启动ship-server,看到以下日志时则可以进行测试了。文章源自JAVA秀-https://www.javaxiu.com/5348.html

2021-01-02 19:57:09.159  INFO 30413 --- [SocketWorker-29] cn.sp.sync.WebsocketSyncCacheServer      : websocket server receive message: [{"operationType":"INSERT","ruleList":[{"id":1,"appId":5,"appName":"order","version":"gray_1.0","matchObject":"HEADER","matchKey":"name","matchMethod":1,"matchRule":"ship","priority":50}]}]

用Postman请求http://localhost:9000/order/user/add,POST方式，header设置name=ship，可以看到只有实例1有日志显示。文章源自JAVA秀-https://www.javaxiu.com/5348.html

==========add user,version:gray_1.0

2、性能压测

压测环境：文章源自JAVA秀-https://www.javaxiu.com/5348.html

MacBook Pro 13英寸文章源自JAVA秀-https://www.javaxiu.com/5348.html
处理器 2.3 GHz 四核Intel Core i7文章源自JAVA秀-https://www.javaxiu.com/5348.html
内存 16 GB 3733 MHz LPDDR4X文章源自JAVA秀-https://www.javaxiu.com/5348.html
后端节点个数一个文章源自JAVA秀-https://www.javaxiu.com/5348.html
压测工具：wrk文章源自JAVA秀-https://www.javaxiu.com/5348.html
压测结果：20个线程，500个连接数，吞吐量大概每秒9400个请求。文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

压测结果文章源自JAVA秀-https://www.javaxiu.com/5348.html

如何设计一个高性能网关？文章源自JAVA秀-https://www.javaxiu.com/5348.html

- 总结 -文章源自JAVA秀-https://www.javaxiu.com/5348.html

千里之行始于足下，开始以为写一个网关会很难，但当你实际开始行动时就会发现其实没那么难，所以迈出第一步很重要。过程中也遇到了很多问题，还在github上给soul和nacos这两个开源项目提了两个issue，后来发现是自己的问题，尴尬。文章源自JAVA秀-https://www.javaxiu.com/5348.html

本文代码已全部上传到：https://github.com/2YSP/ship-gate 。文章源自JAVA秀-https://www.javaxiu.com/5348.html

内容来源于网络，版权归原作者所有。文章源自JAVA秀-https://www.javaxiu.com/5348.html

最近面试BAT，整理一份面试资料《Java面试BAT通关手册》，覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。获取方式：关注公众号并回复 java 领取，更多内容陆续奉上。

文章源自JAVA秀-https://www.javaxiu.com/5348.html

明天见(｡･ω･｡)ﾉ♡文章源自JAVA秀-https://www.javaxiu.com/5348.html

继续阅读

速蛙云 - 极致体验，强烈推荐！！！购买套餐就免费送各大视频网站会员！快速稳定、独家福利社、流媒体稳定解锁！速度快，全球上网、视频、游戏加速、独立IP均支持！基础套餐性价比很高！这里不多说，我一直正在使用，推荐购买：https://www.javaxiu.com/59919.html

资源分享QQ群

本站是JAVA秀团队的技术分享社区, 会经常分享资源和教程; 分享的时代, 请别再沉默！

如何设计一个高性能网关？

如何设计一个高性能网关？

1、技术选型

2、需求清单

3、架构设计

4、表结构设计

3、数据同步

1、动态路由测试

2、性能压测

图解用户登录验证流程，写得太好了！

SpringBoot+ShardingSphereJDBC实现读写分离！

Spring Boot 实现接口幂等性的 4 种方案

从 JDK 8 到 JDK 18，Java 垃圾回收的十次进化

Java池化技术你了解多少？

https://mp.weixin.qq.com/s/cSgPU

面试官：你对 Java线程池了解多少？

图解 SQL，这也太形象了吧！

太强了，一个注解搞定接口返回数据脱敏

涨姿势，Java 重构设计模式，厉害！

发表评论

在线咨询

微信