通过自界说feignclient 的LoadBalancerFeignClient实现灵活的负载均衡计谋 ...

通过自界说feignclient 的LoadBalancerFeignClient 或IRule 能实现完全自界说的负载均衡计谋，本文重要是通过实现自界说的LoadBalancerFeignClient而达到自界说的负载均衡计谋
示例代码实现如下：

1. package cn.zuowenjun.demo;
3. import com.netflix.loadbalancer.Server;
4. import feign.Client;
5. import feign.Request;
6. import feign.Response;
7. import org.apache.commons.collections4.MapUtils;
8. import org.slf4j.Logger;
9. import org.slf4j.LoggerFactory;
10. import org.springframework.cloud.netflix.feign.FeignClient;
11. import org.springframework.cloud.netflix.feign.ribbon.CachingSpringLoadBalancerFactory;
12. import org.springframework.cloud.netflix.feign.ribbon.LoadBalancerFeignClient;
13. import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
14. import org.springframework.context.annotation.Bean;
15. import org.springframework.util.CollectionUtils;
16. import org.springframework.web.bind.annotation.RequestBody;
17. import org.springframework.web.bind.annotation.RequestMapping;
18. import org.springframework.web.bind.annotation.RequestMethod;
20. import java.io.IOException;
21. import java.net.URL;
22. import java.util.*;
23. import java.util.stream.Collectors;
25. /**
26. * FeignClient 服务BEAN（含自定义负载均衡请求机制）,注意这里指定了configuration的类型
27. */
28. @FeignClient(value ="zuowenjun-demo" , configuration = {DemoProviderDispatchService.Config.class})
29. public interface DemoProviderDispatchService {
30.     Logger LOGGER = LoggerFactory.getLogger(FileFmsDispatchService.class);
32.     //要RPC请求的接口，需要自定义负载均衡
33.     @RequestMapping(value = "/fileContent/compare", method = RequestMethod.POST)
34.     ResponseData<Integer> compare(@RequestBody FileBillCompareBO billCompareBO);
36.     /**
37.      * DemoProviderDispatchService 专用的配置类，在这个配置类里面添加的BEAN均可替换全局默认的BEAN
38.      * 注意：此处不能加上@Configuration，否则将变成全局配置了
39.      */
40.     static class Config {
41.         /**
42.          * 为FileFmsDispatchClient 重新定义专用的Client，在里面实现自定义的URL请求
43.          *
44.          * @param cachingFactory
45.          * @param clientFactory
46.          * @return
47.          */
48.         @Bean
49.         public Client requestClient(CachingSpringLoadBalancerFactory cachingFactory, SpringClientFactory clientFactory) {
51.             //获取当前节点的ID与端口
52.             String currentIpAndPort = CommonUtils.getCurrentIpAndPort();
54.             //构建返回一个完全自定义的LoadBalancerFeignClient
55.             return new LoadBalancerFeignClient(new Client.Default(null, null) {
56.                 @Override
57.                 public Response execute(Request request, Request.Options options) throws IOException {
58.                     //通过重新创建Request，将Request 中的url指向自定义负载均衡的选中的URL
59.                     Request newRequest = reCreateRequestForLoadBalance(request);
60.                     if (newRequest == null) {
61.                         return Response.builder().reason("服务器繁忙，当前无可用服务节点").status(204).build();
62.                     }
64.                     return super.execute(newRequest, options);
65.                 }
67.                 private Request reCreateRequestForLoadBalance(Request request) throws IOException {
68.                     URL url = new URL(request.url());
69.                     //获取可用的服务实例节点列表
70.                     List<Server> upServers = clientFactory.getLoadBalancer(“zuowenjun-demo”).getReachableServers();
71.                     Server bestServer = choose(url, upServers, url.getFile());
72.                     if (bestServer == null) {
73.                         //找不到最佳可用服务器节点，说明所有服务节点都压力山大
74.                         return null;
75.                     }
77.                     url = new URL(url.getProtocol(), bestServer.getHost(), bestServer.getPort(), url.getFile());
78.                     return Request.create(request.method(), url.toString(), request.headers(), request.body(), request.charset());
79.                 }
82.                 /**
83.                  * 选择最优的服务节点
84.                  * @param url
85.                  * @param upServers
86.                  * @param apiPath
87.                  * @return
88.                  */
89.                 private Server choose(URL url, List<Server> upServers, String apiPath) {
91.                     if (CollectionUtils.isEmpty(upServers)) {
92.                         throw new ApplicationException(500, "从注册中心获取不到可用的服务节点信息");
93.                     }
95.                     apiPath=apiPath.startsWith("/")?apiPath.substring(1):apiPath;
96.                     String hashKey = Constants.LOADBALANCE_API_PREFIX + apiPath.replace("/", "_");
97.                     Boolean existRequest = RedisUtils.existHashKey(hashKey, String.format("%s:%s", url.getHost(), url.getPort()));
98.                     Server bestServer = null;
99.                     if (!Boolean.TRUE.equals(existRequest)) {
100.                         //如果当前即将请求的URL的节点之前没有缓存标记请求处理中时，则可直接复用返回
101.                         bestServer = upServers.stream().filter(s -> s.getHost().equals(url.getHost()) && s.getPort() == url.getPort()).findFirst().orElse(null);
102.                         if (bestServer != null) {
103.                             return bestServer;
104.                         }
105.                     }
107.                     //先从缓存中找出当前API 的请求中的节点列表
108.                     Map<Object, Object> existRequestMap = RedisUtils.getHashEntries(hashKey);
109.                     Set<Object> existRequestIpAndPorts = new HashSet<>();
110.                     if (MapUtils.isNotEmpty(existRequestMap)) {
111.                         existRequestIpAndPorts.addAll(existRequestMap.keySet());
112.                     }
114.                     //排除API请求中的节点，保留空闲节点列表
115.                     upServers = upServers.stream().filter(s -> !existRequestIpAndPorts.contains(s.getHostPort()) && !s.getHostPort().equals(currentIpAndPort)).collect(Collectors.toList());
116.                     if (CollectionUtils.isEmpty(upServers)) {
117.                         //说明当前所有节点全部都有处理请求中，无空闲节点
118.                         return null;
119.                     }
121.                     //从空闲节点列表中随机返回一个节点
122.                     int rndNo = new Random().nextInt(upServers.size());
123.                     bestServer = upServers.get(rndNo);
124.                     LOGGER.debug("DemoProviderDispatchService.Config.requestClient.Client#choose {}", bestServer.getHostPort());
125.                     return bestServer;
126.                 }
128.             }, cachingFactory, clientFactory);
129.         }
132.     }
134. }

复制代码

调用时就正常注入DemoProviderDispatchService BEAN，并使用：demoProviderDispatchService.compare(...) 即可实现在自界说负载均衡的计谋下请求远程服务API，这种自界说的负载均衡计谋可以满足特定的性能要求

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。