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

     

     

    前言：
    ​​​​​

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

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

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

     

     源码部分

     

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

     

    mini-cloud-gateaway 源码

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

     

    pom.xml   dependencies

     

    1. <dependency>
    2.             <groupId>org.springframework.cloudgroupId>
    3.             <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
    4.         dependency>
    5.  
    6.         
    7.         <dependency>
    8.             <groupId>org.springframework.cloudgroupId>
    9.             <artifactId>spring-cloud-starter-gatewayartifactId>
    10.         dependency>
    11.         <dependency>
    12.             <groupId>javax.servletgroupId>
    13.             <artifactId>javax.servlet-apiartifactId>
    14.         dependency>
    15.  
    16.  
    17.         <dependency>
    18.             <groupId>org.springframework.cloudgroupId>
    19.             <artifactId>spring-cloud-gateway-coreartifactId>
    20.         dependency>
    21.         <dependency>
    22.             <groupId>com.alibaba.cloudgroupId>
    23.             <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    24.             <scope>compilescope>
    25.         dependency>
    26.         <dependency>
    27.             <groupId>cn.hutoolgroupId>
    28.             <artifactId>hutool-allartifactId>
    29.         dependency>
    30.         <dependency>
    31.             <groupId>com.alibaba.cloudgroupId>
    32.             <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    33.             <scope>compilescope>
    34.         dependency>
    35.         <dependency>
    36.             <groupId>org.springframework.securitygroupId>
    37.             <artifactId>spring-security-jwtartifactId>
    38.         dependency>
    39.         <dependency>
    40.             <groupId>com.nimbusdsgroupId>
    41.             <artifactId>nimbus-jose-jwtartifactId>
    42.         dependency>
    43.         <dependency>
    44.             <groupId>org.springframework.cloudgroupId>
    45.             <artifactId>spring-cloud-starter-loadbalancerartifactId>
    46.         dependency>
    47.     dependencies>

     

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

     

    1. package com.minicloud.common.gateaway.annotation;
    2.  
    3. import com.minicloud.common.gateaway.config.MiniCloudRouteAutoConfiguration;
    4. import org.springframework.context.annotation.Import;
    5.  
    6. import java.lang.annotation.*;
    7.  
    8.  
    9. @Target({ElementType.TYPE})
    10. @Retention(RetentionPolicy.RUNTIME)
    11. @Documented
    12. @Inherited
    13. @Import(MiniCloudRouteAutoConfiguration.class)
    14. public @interface EnableMiniCloudRoute {
    15. }

     

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

     

    1. package com.minicloud.common.gateaway.config;
    2.  
    3. import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
    4. import org.springframework.context.annotation.ComponentScan;
    5. import org.springframework.context.annotation.Configuration;
    6.  
    7.  
    8. @Configuration
    9. @ComponentScan("com.minicloud.common.gateaway")
    10. @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
    11. public class MiniCloudRouteAutoConfiguration {
    12. }

     

     

    MiniCloudLoadBalancerClientConfiguration.java

      如果是使用 REACTIVE 作为web引擎，则可以初始化

    MiniCloudReactiveLoadBalancerClientFilter和  MiniCloudLoadBalancer 两个类 
    MiniCloudReactiveLoadBalancerClientFilter ：主要是重写 ReactiveLoadBalancerClientFilter 获取request中的version

     

    VersionMiniCloudLoadBalancer： 主要是获取到version 后获取version 对应lb中的instance
    1. import com.minicloud.common.gateaway.filter.MiniCloudReactiveLoadBalancerClientFilter;
    2. import com.minicloud.common.gateaway.rule.MiniCloudLoadBalancer;
    3. import com.minicloud.common.gateaway.rule.VersionMiniCloudLoadBalancer;
    4. import org.springframework.boot.autoconfigure.AutoConfigureBefore;
    5. import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
    6. import org.springframework.boot.context.properties.EnableConfigurationProperties;
    7. import org.springframework.cloud.client.discovery.DiscoveryClient;
    8. import org.springframework.cloud.gateway.config.GatewayReactiveLoadBalancerClientAutoConfiguration;
    9. import org.springframework.cloud.gateway.config.LoadBalancerProperties;
    10. import org.springframework.cloud.gateway.filter.ReactiveLoadBalancerClientFilter;
    11. import org.springframework.context.annotation.Bean;
    12. import org.springframework.context.annotation.Configuration;
    13.  
    14.  
    15. @Configuration
    16. @EnableConfigurationProperties(LoadBalancerProperties.class)
    17. @AutoConfigureBefore(GatewayReactiveLoadBalancerClientAutoConfiguration.class)
    18. @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
    19. public class MiniCloudLoadBalancerClientConfiguration {
    20.  
    21. 	@Bean
    22. 	public ReactiveLoadBalancerClientFilter gatewayLoadBalancerClientFilter(MiniCloudLoadBalancer miniCloudLoadBalancer,
    23. 																			LoadBalancerProperties properties) {
    24. 		return new MiniCloudReactiveLoadBalancerClientFilter(properties, miniCloudLoadBalancer);
    25. 	}
    26.  
    27. 	@Bean
    28. 	public MiniCloudLoadBalancer grayLoadBalancer(DiscoveryClient discoveryClient) {
    29. 		return new VersionMiniCloudLoadBalancer(discoveryClient);
    30. 	}
    31. }

     

    MiniCloudReactiveLoadBalancerClientFilter.java

     

     

    1. @Slf4j
    2. public class MiniCloudReactiveLoadBalancerClientFilter extends ReactiveLoadBalancerClientFilter {
    3. 	private static final int LOAD_BALANCER_CLIENT_FILTER_ORDER = 10150;
    4. 	private LoadBalancerProperties properties;
    5.  
    6. 	private MiniCloudLoadBalancer miniCloudLoadBalancer;
    7.  
    8. 	public MiniCloudReactiveLoadBalancerClientFilter(LoadBalancerProperties properties, MiniCloudLoadBalancer miniCloudLoadBalancer) {
    9. 		super(null, properties);
    10. 		this.properties = properties;
    11. 		this.miniCloudLoadBalancer = miniCloudLoadBalancer;
    12. 	}
    13.  
    14. 	@Override
    15. 	public int getOrder() {
    16. 		return LOAD_BALANCER_CLIENT_FILTER_ORDER;
    17. 	}
    18.  
    19. 	@Override
    20. 	public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    21. 		URI url = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
    22. 		String schemePrefix = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_SCHEME_PREFIX_ATTR);
    23. 		if (url == null
    24. 				|| (!"lb".equals(url.getScheme()) && !"lb".equals(schemePrefix))) {
    25. 			return chain.filter(exchange);
    26. 		}
    27. 		// preserve the original url
    28. 		ServerWebExchangeUtils.addOriginalRequestUrl(exchange, url);
    29.  
    30. 		if (log.isTraceEnabled()) {
    31. 			log.trace(ReactiveLoadBalancerClientFilter.class.getSimpleName()
    32. 					+ " url before: " + url);
    33. 		}
    34.  
    35. 		return choose(exchange).doOnNext(response -> {
    36.  
    37. 			if (!response.hasServer()) {
    38. 				throw NotFoundException.create(properties.isUse404(),
    39. 						"Unable to find instance for " + url.getHost());
    40. 			}
    41.  
    42. 			URI uri = exchange.getRequest().getURI();
    43.  
    44. 			// if the `lb:` mechanism was used, use `` as the default,
    45. 			// if the loadbalancer doesn't provide one.
    46. 			String overrideScheme = null;
    47. 			if (schemePrefix != null) {
    48. 				overrideScheme = url.getScheme();
    49. 			}
    50.  
    51. 			DelegatingServiceInstance serviceInstance = new DelegatingServiceInstance(
    52. 					response.getServer(), overrideScheme);
    53.  
    54. 			URI requestUrl = LoadBalancerUriTools.reconstructURI(serviceInstance, uri);
    55.  
    56. 			if (log.isTraceEnabled()) {
    57. 				log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
    58. 			}
    59. 			exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, requestUrl);
    60. 		}).then(chain.filter(exchange));
    61. 	}
    62.  
    63. 	private Mono> choose(ServerWebExchange exchange) {
    64. 		URI uri = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
    65. 		ServiceInstance serviceInstance = miniCloudLoadBalancer.choose(uri.getHost(),exchange.getRequest());
    66. 		return Mono.just(new DefaultResponse(serviceInstance));
    67. 	}
    MiniCloudLoadBalancer

     

    1. package com.minicloud.common.gateaway.rule;
    2.  
    3. import org.springframework.cloud.client.ServiceInstance;
    4. import org.springframework.http.server.reactive.ServerHttpRequest;
    5.  
    6.  
    7. public interface MiniCloudLoadBalancer {
    8.  
    9.  
    10. 	ServiceInstance choose(String serviceId, ServerHttpRequest request);
    11. }

     

     

    VersionMiniCloudLoadBalancer.java

     

    1. @Slf4j
    2. @AllArgsConstructor
    3. public class VersionMiniCloudLoadBalancer implements MiniCloudLoadBalancer {
    4. 	private DiscoveryClient discoveryClient;
    5.  
    6.  
    7.  
    8. 	@Override
    9. 	public ServiceInstance choose(String serviceId, ServerHttpRequest request) {
    10. 		List instances = discoveryClient.getInstances(serviceId);
    11.  
    12. 		//注册中心无实例 抛出异常
    13. 		if (CollUtil.isEmpty(instances)) {
    14. 			log.warn("No instance available for {}", serviceId);
    15. 			throw new NotFoundException("No instance available for " + serviceId);
    16. 		}
    17.  
    18. 		// 获取请求version，无则随机返回可用实例
    19. 		String reqVersion = request.getHeaders().getFirst("version");
    20. 		if (StrUtil.isBlank(reqVersion)) {
    21. 			return instances.get(RandomUtil.randomInt(instances.size()));
    22. 		}
    23.  
    24. 		// 遍历可以实例元数据，若匹配则返回此实例
    25. 		for (ServiceInstance instance : instances) {
    26. 			Map metadata = instance.getMetadata();
    27. 			String targetVersion = MapUtil.getStr(metadata, "version");
    28. 			if (reqVersion.equalsIgnoreCase(targetVersion)) {
    29. 				log.info("gray requst match success :{} {}", reqVersion, instance);
    30. 				return instance;
    31. 			}
    32. 		}
    33. 		return instances.get(RandomUtil.randomInt(instances.size()));
    34. 	}
    35. }

     

    mini-cloud-common-balancer 源码

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

     

    pom.xml 

    1.  
    2.  
    3.         
    4.             org.mini-cloud
    5.             mini-cloud-common-core
    6.             1.0-SNAPSHOT
    7.         
    8.         
    9.             com.alibaba.cloud
    10.             spring-cloud-starter-alibaba-nacos-discovery
    11.         
    12.         
    13.             io.github.openfeign
    14.             feign-core
    15.         
    16.

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

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

     

    MiniCloudRibbonLoadBalancerConfiguration.java

    主要为了注入bean: MiniCloudRibbonLoadBalancerRule ,RequestInterceptor

    1.  
    2.  
    3. import com.minicloud.common.balancer.fegin.MiniCloudFeignRequestInterceptor;
    4. import com.minicloud.common.balancer.rule.MiniCloudRibbonLoadBalancerRule;
    5. import feign.RequestInterceptor;
    6. import org.springframework.beans.factory.config.ConfigurableBeanFactory;
    7. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10. import org.springframework.context.annotation.Scope;
    11.  
    12.  
    13. @Configuration
    14. public class MiniCloudRibbonLoadBalancerConfiguration {
    15.  
    16. 	@Bean
    17. 	@ConditionalOnMissingBean
    18. 	@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    19. 	public MiniCloudRibbonLoadBalancerRule ribbonLoadBalancerRule() {
    20. 		return new MiniCloudRibbonLoadBalancerRule();
    21. 	}
    22.  
    23. 	@Bean
    24. 	public RequestInterceptor grayFeignRequestInterceptor() {
    25. 		return new MiniCloudFeignRequestInterceptor();
    26. 	}
    27. }

     

     

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

     

    1.  
    2. @Slf4j
    3. public class MiniCloudFeignRequestInterceptor implements RequestInterceptor {
    4.  
    5.  
    6. 	@Override
    7. 	public void apply(RequestTemplate template) {
    8. 		String reqVersion = WebUtils.getRequest() != null
    9. 				? WebUtils.getRequest().getHeader("version") : null;
    10.  
    11. 		if (StrUtil.isNotBlank(reqVersion)) {
    12. 			log.debug("feign gray add header version :{}", reqVersion);
    13. 			template.header("version", reqVersion);
    14. 		}
    15. 	}

     

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

     

    1.  
    2. @Slf4j
    3. public class MiniCloudRibbonLoadBalancerRule extends AbstractLoadBalancerRule {
    4. 	@Override
    5. 	public void initWithNiwsConfig(IClientConfig iClientConfig) {
    6. 	}
    7.  
    8. 	@Override
    9. 	public Server choose(Object key) {
    10. 		return choose(getLoadBalancer(), key);
    11. 	}
    12.  
    13.  
    14. 	public Server choose(ILoadBalancer lb, Object key) {
    15. 		List reachableServers = lb.getReachableServers();
    16.  
    17. 		//注册中心无可用实例 抛出异常
    18. 		if (CollUtil.isEmpty(reachableServers)) {
    19. 			log.warn("No instance available for {}", key);
    20. 			return null;
    21. 		}
    22.  
    23. 		// 获取请求version，无则随机返回可用实例
    24. 		String reqVersion = WebUtils.getRequest() != null
    25. 				? WebUtils.getRequest().getHeader("version") : null;
    26. 		if (StrUtil.isBlank(reqVersion)) {
    27. 			return reachableServers.get(RandomUtil.randomInt(reachableServers.size()));
    28. 		}
    29.  
    30. 		// 遍历可以实例元数据，若匹配则返回此实例
    31. 		for (Server server : reachableServers) {
    32. 			NacosServer nacosServer = (NacosServer) server;
    33. 			Map metadata = nacosServer.getMetadata();
    34. 			String targetVersion = MapUtil.getStr(metadata,"version");
    35. 			if (reqVersion.equalsIgnoreCase(targetVersion)) {
    36. 				log.debug("gray requst match success :{} {}", reqVersion, nacosServer);
    37. 				return nacosServer;
    38. 			}
    39. 		}
    40. 		return reachableServers.get(RandomUtil.randomInt(reachableServers.size()));
    41. 	}
    42.  
    43. }

     

     

     

     

     

     

     

     

     

     

     

     

  • 相关阅读:
    Nomad 系列-快速上手
    高并发、多线程、分布式都不懂，你拿什么跳槽阿里、腾讯、京东？还不好好学习啊
    MongoDB ObjectId 详解
    【Arma3脚本教程】一、基本介绍
    Python实现自动重新运行指定python脚本
    【python】ModuleNotFoundError: No module named ‘skimage‘...
    部署LVS-NAT群集实验
    网络安全——Goolge Hacking的使用
    1326_ADC模块以及功能参数初步
    破局数据库“卡脖子”：专精特新“小巨人”偶数科技迎风成长
  • 原文地址：https://blog.csdn.net/madness1010/article/details/125996102