从0到1 手把手搭建spring cloud alibaba 微服务大型应用框架(六)(优化篇)开发篇-如何解决微服务开发环境请求实例转发到别人机器问题

本文涉及的产品
云原生网关 MSE Higress,422元/月
服务治理 MSE Sentinel/OpenSergo,Agent数量 不受限
注册配置 MSE Nacos/ZooKeeper,118元/月
简介: 从0到1 手把手搭建spring cloud alibaba 微服务大型应用框架(六)(优化篇)开发篇-如何解决微服务开发环境请求实例转发到别人机器问题

image.png

前言:


本篇是上一篇《从0到1 手把手搭建spring cloud alibaba 微服务大型应用框架(七) 开发环境使用轻量级在线文档解决知识分享问题》的优化篇


原来是基于下图,分散处理的,分散在各个代码层并且不是统一获取version对应的instance


1.png

本篇将集成为两个共通,统一通过client 端设置version 依次传递 下去,然后各个层通过lb获取version对应的instance,该优化是借鉴了其他一些架构,觉得不错,引入进来了,如下图


image.png

源码部分


新增两个共通模块mini-cloud-common-gateaway,mini-cloud-balancer ,目录结构如下

1.png

mini-cloud-gateaway 源码


mini-cloud-common-gateaway 代码结构以及代码明细,将作为共通被mini-cloud-gateaway 使用

1.png

pom.xml   dependencies

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <!--gateway 网关依赖,内置webflux 依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-gateway-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-jwt</artifactId>
        </dependency>
        <dependency>
            <groupId>com.nimbusds</groupId>
            <artifactId>nimbus-jose-jwt</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
    </dependencies>

EnableMiniCloudRoute.java 主要作为开启引用MiniCloudRouteAutoConfiguration 自定义路由的开关,不然是无法扫描到 MiniCloudRouteAutoConfiguration 类的

package com.minicloud.common.gateaway.annotation;
import com.minicloud.common.gateaway.config.MiniCloudRouteAutoConfiguration;
import org.springframework.context.annotation.Import;
import java.lang.annotation.*;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(MiniCloudRouteAutoConfiguration.class)
public @interface EnableMiniCloudRoute {
}

MiniCloudRouteAutoConfiguration.java 主要是注入后续源码的扫描包,便于引用项目扫面到

package com.minicloud.common.gateaway.config;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.minicloud.common.gateaway")
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
public class MiniCloudRouteAutoConfiguration {
}
MiniCloudLoadBalancerClientConfiguration.java 
  如果是使用 REACTIVE 作为web引擎,则可以初始化
MiniCloudReactiveLoadBalancerClientFilter和  MiniCloudLoadBalancer 两个类 
MiniCloudReactiveLoadBalancerClientFilter :主要是重写 ReactiveLoadBalancerClientFilter 获取request中的version
VersionMiniCloudLoadBalancer: 主要是获取到version 后获取version 对应lb中的instance
import com.minicloud.common.gateaway.filter.MiniCloudReactiveLoadBalancerClientFilter;
import com.minicloud.common.gateaway.rule.MiniCloudLoadBalancer;
import com.minicloud.common.gateaway.rule.VersionMiniCloudLoadBalancer;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.gateway.config.GatewayReactiveLoadBalancerClientAutoConfiguration;
import org.springframework.cloud.gateway.config.LoadBalancerProperties;
import org.springframework.cloud.gateway.filter.ReactiveLoadBalancerClientFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableConfigurationProperties(LoadBalancerProperties.class)
@AutoConfigureBefore(GatewayReactiveLoadBalancerClientAutoConfiguration.class)
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
public class MiniCloudLoadBalancerClientConfiguration {
  @Bean
  public ReactiveLoadBalancerClientFilter gatewayLoadBalancerClientFilter(MiniCloudLoadBalancer miniCloudLoadBalancer,
                                      LoadBalancerProperties properties) {
    return new MiniCloudReactiveLoadBalancerClientFilter(properties, miniCloudLoadBalancer);
  }
  @Bean
  public MiniCloudLoadBalancer grayLoadBalancer(DiscoveryClient discoveryClient) {
    return new VersionMiniCloudLoadBalancer(discoveryClient);
  }
}

MiniCloudReactiveLoadBalancerClientFilter.java

@Slf4j
public class MiniCloudReactiveLoadBalancerClientFilter extends ReactiveLoadBalancerClientFilter {
  private static final int LOAD_BALANCER_CLIENT_FILTER_ORDER = 10150;
  private LoadBalancerProperties properties;
  private MiniCloudLoadBalancer miniCloudLoadBalancer;
  public MiniCloudReactiveLoadBalancerClientFilter(LoadBalancerProperties properties, MiniCloudLoadBalancer miniCloudLoadBalancer) {
    super(null, properties);
    this.properties = properties;
    this.miniCloudLoadBalancer = miniCloudLoadBalancer;
  }
  @Override
  public int getOrder() {
    return LOAD_BALANCER_CLIENT_FILTER_ORDER;
  }
  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    URI url = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
    String schemePrefix = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_SCHEME_PREFIX_ATTR);
    if (url == null
        || (!"lb".equals(url.getScheme()) && !"lb".equals(schemePrefix))) {
      return chain.filter(exchange);
    }
    // preserve the original url
    ServerWebExchangeUtils.addOriginalRequestUrl(exchange, url);
    if (log.isTraceEnabled()) {
      log.trace(ReactiveLoadBalancerClientFilter.class.getSimpleName()
          + " url before: " + url);
    }
    return choose(exchange).doOnNext(response -> {
      if (!response.hasServer()) {
        throw NotFoundException.create(properties.isUse404(),
            "Unable to find instance for " + url.getHost());
      }
      URI uri = exchange.getRequest().getURI();
      // if the `lb:<scheme>` mechanism was used, use `<scheme>` as the default,
      // if the loadbalancer doesn't provide one.
      String overrideScheme = null;
      if (schemePrefix != null) {
        overrideScheme = url.getScheme();
      }
      DelegatingServiceInstance serviceInstance = new DelegatingServiceInstance(
          response.getServer(), overrideScheme);
      URI requestUrl = LoadBalancerUriTools.reconstructURI(serviceInstance, uri);
      if (log.isTraceEnabled()) {
        log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
      }
      exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, requestUrl);
    }).then(chain.filter(exchange));
  }
  private Mono<Response<ServiceInstance>> choose(ServerWebExchange exchange) {
    URI uri = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
    ServiceInstance serviceInstance = miniCloudLoadBalancer.choose(uri.getHost(),exchange.getRequest());
    return Mono.just(new DefaultResponse(serviceInstance));
  }

MiniCloudLoadBalancer

package com.minicloud.common.gateaway.rule;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.http.server.reactive.ServerHttpRequest;
public interface MiniCloudLoadBalancer {
  ServiceInstance choose(String serviceId, ServerHttpRequest request);
}

VersionMiniCloudLoadBalancer.java

@Slf4j
@AllArgsConstructor
public class VersionMiniCloudLoadBalancer implements MiniCloudLoadBalancer {
  private DiscoveryClient discoveryClient;
  @Override
  public ServiceInstance choose(String serviceId, ServerHttpRequest request) {
    List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
    //注册中心无实例 抛出异常
    if (CollUtil.isEmpty(instances)) {
      log.warn("No instance available for {}", serviceId);
      throw new NotFoundException("No instance available for " + serviceId);
    }
    // 获取请求version,无则随机返回可用实例
    String reqVersion = request.getHeaders().getFirst("version");
    if (StrUtil.isBlank(reqVersion)) {
      return instances.get(RandomUtil.randomInt(instances.size()));
    }
    // 遍历可以实例元数据,若匹配则返回此实例
    for (ServiceInstance instance : instances) {
      Map<String, String> metadata = instance.getMetadata();
      String targetVersion = MapUtil.getStr(metadata, "version");
      if (reqVersion.equalsIgnoreCase(targetVersion)) {
        log.info("gray requst match success :{} {}", reqVersion, instance);
        return instance;
      }
    }
    return instances.get(RandomUtil.randomInt(instances.size()));
  }
}

mini-cloud-common-balancer 源码


mini-cloud-common-balancer 代码结构以及代码明细,将作为共通被各个业务端使用

1.png

pom.xml

 <dependencies>
        <dependency>
            <groupId>org.mini-cloud</groupId>
            <artifactId>mini-cloud-common-core</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-core</artifactId>
        </dependency>
    </dependencies>

spring.factories spring-boot 约定文件,也就是传说的“约定大于配置”

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.minicloud.common.balancer.config.MiniCloudRibbonLoadBalancerConfiguration

MiniCloudRibbonLoadBalancerConfiguration.java

主要为了注入bean: MiniCloudRibbonLoadBalancerRule ,RequestInterceptor

import com.minicloud.common.balancer.fegin.MiniCloudFeignRequestInterceptor;
import com.minicloud.common.balancer.rule.MiniCloudRibbonLoadBalancerRule;
import feign.RequestInterceptor;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
@Configuration
public class MiniCloudRibbonLoadBalancerConfiguration {
  @Bean
  @ConditionalOnMissingBean
  @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
  public MiniCloudRibbonLoadBalancerRule ribbonLoadBalancerRule() {
    return new MiniCloudRibbonLoadBalancerRule();
  }
  @Bean
  public RequestInterceptor grayFeignRequestInterceptor() {
    return new MiniCloudFeignRequestInterceptor();
  }
}

MiniCloudFeignRequestInterceptor.java 为了拦截fegin请求并设置上游发来的 version

@Slf4j
public class MiniCloudFeignRequestInterceptor implements RequestInterceptor {
  @Override
  public void apply(RequestTemplate template) {
    String reqVersion = WebUtils.getRequest() != null
        ? WebUtils.getRequest().getHeader("version") : null;
    if (StrUtil.isNotBlank(reqVersion)) {
      log.debug("feign gray add header version :{}", reqVersion);
      template.header("version", reqVersion);
    }
  }

MiniCloudRibbonLoadBalancerRule.java 自定义使用端ribbon loadbalance 路由

@Slf4j
public class MiniCloudRibbonLoadBalancerRule extends AbstractLoadBalancerRule {
  @Override
  public void initWithNiwsConfig(IClientConfig iClientConfig) {
  }
  @Override
  public Server choose(Object key) {
    return choose(getLoadBalancer(), key);
  }
  public Server choose(ILoadBalancer lb, Object key) {
    List<Server> reachableServers = lb.getReachableServers();
    //注册中心无可用实例 抛出异常
    if (CollUtil.isEmpty(reachableServers)) {
      log.warn("No instance available for {}", key);
      return null;
    }
    // 获取请求version,无则随机返回可用实例
    String reqVersion = WebUtils.getRequest() != null
        ? WebUtils.getRequest().getHeader("version") : null;
    if (StrUtil.isBlank(reqVersion)) {
      return reachableServers.get(RandomUtil.randomInt(reachableServers.size()));
    }
    // 遍历可以实例元数据,若匹配则返回此实例
    for (Server server : reachableServers) {
      NacosServer nacosServer = (NacosServer) server;
      Map<String, String> metadata = nacosServer.getMetadata();
      String targetVersion = MapUtil.getStr(metadata,"version");
      if (reqVersion.equalsIgnoreCase(targetVersion)) {
        log.debug("gray requst match success :{} {}", reqVersion, nacosServer);
        return nacosServer;
      }
    }
    return reachableServers.get(RandomUtil.randomInt(reachableServers.size()));
  }
}


相关实践学习
SLB负载均衡实践
本场景通过使用阿里云负载均衡 SLB 以及对负载均衡 SLB 后端服务器 ECS 的权重进行修改,快速解决服务器响应速度慢的问题
负载均衡入门与产品使用指南
负载均衡(Server Load Balancer)是对多台云服务器进行流量分发的负载均衡服务,可以通过流量分发扩展应用系统对外的服务能力,通过消除单点故障提升应用系统的可用性。 本课程主要介绍负载均衡的相关技术以及阿里云负载均衡产品的使用方法。
相关文章
|
20天前
|
人工智能 前端开发 Java
基于开源框架Spring AI Alibaba快速构建Java应用
本文旨在帮助开发者快速掌握并应用 Spring AI Alibaba,提升基于 Java 的大模型应用开发效率和安全性。
基于开源框架Spring AI Alibaba快速构建Java应用
|
7天前
|
存储 人工智能 Java
Spring AI Alibaba 配置管理,用 Nacos 就够了
本文通过一些实操案例展示了 Spring AI Alibaba + Nacos 在解决 AI 应用中一系列复杂配置管理挑战的方案,从动态 Prompt 模板的灵活调整、模型参数的即时优化,到敏感信息的安全加密存储。Spring AI Alibaba 简化了对接阿里云通义大模型的流程,内置 Nacos 集成也为开发者提供了无缝衔接云端配置托管的捷径,整体上极大提升了 AI 应用开发的灵活性和响应速度。
|
11天前
|
存储 NoSQL 分布式数据库
微服务架构下的数据库设计与优化策略####
本文深入探讨了在微服务架构下,如何进行高效的数据库设计与优化,以确保系统的可扩展性、低延迟与高并发处理能力。不同于传统单一数据库模式,微服务架构要求更细粒度的服务划分,这对数据库设计提出了新的挑战。本文将从数据库分片、复制、事务管理及性能调优等方面阐述最佳实践,旨在为开发者提供一套系统性的解决方案框架。 ####
|
1月前
|
人工智能 Java API
阿里云开源 AI 应用开发框架:Spring AI Alibaba
近期,阿里云重磅发布了首款面向 Java 开发者的开源 AI 应用开发框架:Spring AI Alibaba(项目 Github 仓库地址:alibaba/spring-ai-alibaba),Spring AI Alibaba 项目基于 Spring AI 构建,是阿里云通义系列模型及服务在 Java AI 应用开发领域的最佳实践,提供高层次的 AI API 抽象与云原生基础设施集成方案,帮助开发者快速构建 AI 应用。本文将详细介绍 Spring AI Alibaba 的核心特性,并通过「智能机票助手」的示例直观的展示 Spring AI Alibaba 开发 AI 应用的便利性。示例源
|
1月前
|
人工智能 开发框架 Java
总计 30 万奖金,Spring AI Alibaba 应用框架挑战赛开赛
Spring AI Alibaba 应用框架挑战赛邀请广大开发者参与开源项目的共建,助力项目快速发展,掌握 AI 应用开发模式。大赛分为《支持 Spring AI Alibaba 应用可视化调试与追踪本地工具》和《基于 Flow 的 AI 编排机制设计与实现》两个赛道,总计 30 万奖金。
|
30天前
|
监控 API 开发者
后端开发中的微服务架构实践与优化
【10月更文挑战第17天】 本文深入探讨了微服务架构在后端开发中的应用及其优化策略。通过分析微服务的核心理念、设计原则及实际案例,揭示了如何构建高效、可扩展的微服务系统。文章强调了微服务架构对于提升系统灵活性、降低耦合度的重要性,并提供了实用的优化建议,帮助开发者更好地应对复杂业务场景下的挑战。
22 7
|
1月前
|
Dubbo Java 应用服务中间件
Dubbo学习圣经:从入门到精通 Dubbo3.0 + SpringCloud Alibaba 微服务基础框架
尼恩团队的15大技术圣经,旨在帮助开发者系统化、体系化地掌握核心技术,提升技术实力,从而在面试和工作中脱颖而出。本文介绍了如何使用Dubbo3.0与Spring Cloud Gateway进行整合,解决传统Dubbo架构缺乏HTTP入口的问题,实现高性能的微服务网关。
|
1月前
|
Cloud Native API 持续交付
利用云原生技术优化微服务架构
【10月更文挑战第13天】云原生技术通过容器化、动态编排、服务网格和声明式API,优化了微服务架构的可伸缩性、可靠性和灵活性。本文介绍了云原生技术的核心概念、优势及实施步骤,探讨了其在自动扩展、CI/CD、服务发现和弹性设计等方面的应用,并提供了实战技巧。
|
1月前
|
人工智能 Java API
阿里云开源 AI 应用开发框架:Spring AI Alibaba
阿里云开源 Spring AI Alibaba,旨在帮助 Java 开发者快速构建 AI 应用,共同构建物理新世界。
|
29天前
|
存储 Kubernetes 监控
深度解析Kubernetes在微服务架构中的应用与优化
【10月更文挑战第18天】深度解析Kubernetes在微服务架构中的应用与优化
106 0
下一篇
无影云桌面