SpringCloud Naocs 自定义负载均衡配置
SpringCloud Naocs 自定义负载均衡配置
场景：本地开发中，所有开发人员都启动了多个微服务，在进行远程调用时，可能请求的是其他开发人员的服务，导致本地联调debug效率低下。
SpringCloud Naocs 提供的负载均衡策略
SpringCloud新版本中负载均衡器由原来的ribbon替换为Spring自己开发的Loadbalancer，默认只提供了2中负载均衡策略：RandomLoadBalancer 和 RoundRobinLoadBalancer。SpringCloud Alibaba Nacos 2021.1版本提供了基于Nacos注册中心的轮询策略 NacosLoadBalancer 是基于权重的策略。
NacosLoadBalancer的权重策略默认是关闭的，如果要使用基于权重的负载策略要手动开启。
如果未给服务器设置权重，建议不要使用基于权重的策略，因为如果微服务的权重都相同，相当于随机
修改配置文件配置
#开启nacos的负载均衡策略
spring.cloud.loadbalancer.nacos.enabled=true
基于NacosLoadBalancer扩展功能
/**
* 修改Nacos的负载均衡策略，主要是为了将请求路由到本地服务中，方便开发
* @author guojunwang
* @date 2022-05-18 14:17
*/
public class CustomNacosLoadBalancer extends NacosLoadBalancer implements ReactorServiceInstanceLoadBalancer {
@Value("${spring.profiles.active}")
private String profilesActive;
private static final Logger log = LoggerFactory.getLogger(NacosLoadBalancer.class);
private final String serviceId;
private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
private final NacosDiscoveryProperties nacosDiscoveryProperties;
public CustomNacosLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
String serviceId, NacosDiscoveryProperties nacosDiscoveryProperties) {
super(serviceInstanceListSupplierProvider,serviceId,nacosDiscoveryProperties);
this.serviceId = serviceId;
this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
this.nacosDiscoveryProperties = nacosDiscoveryProperties;
}
@Override
public Mono<Response<ServiceInstance>> choose(Request request) {
ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
.getIfAvailable(NoopServiceInstanceListSupplier::new);
return supplier.get().next().map(this::getInstanceResponse);
}
private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> serviceInstances) {
if (serviceInstances.isEmpty()) {
log.warn("No servers available for service: " + this.serviceId);
return new EmptyResponse();
}
try {
String clusterName = this.nacosDiscoveryProperties.getClusterName();
List<ServiceInstance> instancesToChoose = serviceInstances;
if (StringUtils.isNotBlank(clusterName)) {
List<ServiceInstance> sameClusterInstances = serviceInstances.stream()
.filter(serviceInstance -> {
String cluster = serviceInstance.getMetadata()
.get("nacos.cluster");
return StringUtils.equals(cluster, clusterName);
}).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(sameClusterInstances)) {
instancesToChoose = sameClusterInstances;
}
} else {
log.warn(
"A cross-cluster call occurs，name = {}, clusterName = {}, instance = {}",
serviceId, clusterName, serviceInstances);
}
//本地开发模式路由会本机
if(StrUtil.equals(SpringUtil.getProperty("spring.profiles.active"),"dev")){
//如果有本机的服务，优先选择本地服务
List<ServiceInstance> localServiceInstance = instancesToChoose.stream().filter(i -> IpUtil.isLocal(i.getHost())).collect(Collectors.toList());
//使用本地服务进行选举
if (CollUtil.isNotEmpty(localServiceInstance)) {
instancesToChoose = localServiceInstance;
log.info("开发模式，负载均衡器优先选择本机服务调用==>{}", instancesToChoose.stream().map( is ->{
String msg =" serviceId=%s,host=%s,port=%s ";
return String.format(msg, is.getServiceId(), is.getHost(), is.getPort());
}).collect(Collectors.toList()));
}
}
//权重选取
ServiceInstance instance = NacosBalancer.getHostByRandomWeight3(instancesToChoose);
return new DefaultResponse(instance);
}
catch (Exception e) {
log.warn("NacosLoadBalancer error", e);
return null;
}
}
}
用到的IpUtil工具类
需要在pom加入依赖
<dependency>
<groupId>javax.servletgroupId>
<artifactId>servlet-apiartifactId>
<version>2.5version>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webartifactId>
<optional>trueoptional>
dependency>
@Slf4j
public class IpUtil {
/**
* localAddresses 减少运行耗时，初始化时吧本机地址缓存起来
* 缺点，网络改变时，需要重启
*/
private static List<String> localAddresses = new ArrayList<>();
static {
try {
Enumeration<NetworkInterface> enumNI = NetworkInterface.getNetworkInterfaces();
while ( enumNI.hasMoreElements() ){
NetworkInterface ifc = enumNI.nextElement();
if( ifc.isUp() ){
Enumeration<InetAddress> enumAdds = ifc.getInetAddresses();
while ( enumAdds.hasMoreElements() ){
InetAddress addr = enumAdds.nextElement();
localAddresses.add(addr.getHostAddress());
}
}
}
localAddresses.add("localhost");
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 判断是否同一个地址，无论是主机名还是ip地址
* @param host1
* @param host2
* @return
*/
public static boolean sameAddress(String host1,String host2){
if(StrUtil.isBlank(host1) || StrUtil.isBlank(host2)){
return false;
}
try {
if(isLocal(host1)){
host1 = InetAddress.getLocalHost().getHostName();
}
if(isLocal(host2)){
host2 = InetAddress.getLocalHost().getHostName();
}
InetAddress addr1 = InetAddress.getByName(host1);
InetAddress addr2 = InetAddress.getByName(host2);
return addr1.getHostAddress().equals(addr2.getHostAddress());
} catch (UnknownHostException e) {
e.printStackTrace();
return false;
}
}
public static boolean isLocal(String host){
return localAddresses.contains(host);
}
/***
* 获取客户端ip地址(可以穿透代理)
* @param request
* @return
*/
public static String getClientIpAddr(HttpServletRequest request) {
String ip = request.getHeader("X-Forwarded-For");
if (!isValidIp(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (!isValidIp(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (!isValidIp(ip)) {
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
}
if (!isValidIp(ip)) {
ip = request.getHeader("HTTP_X_FORWARDED");
}
if (!isValidIp(ip)) {
ip = request.getHeader("HTTP_X_CLUSTER_CLIENT_IP");
}
if (!isValidIp(ip)) {
ip = request.getHeader("HTTP_CLIENT_IP");
}
if (!isValidIp(ip)) {
ip = request.getHeader("HTTP_FORWARDED_FOR");
}
if (!isValidIp(ip)) {
ip = request.getHeader("HTTP_FORWARDED");
}
if (!isValidIp(ip)) {
ip = request.getHeader("HTTP_VIA");
}
if (!isValidIp(ip)) {
ip = request.getHeader("REMOTE_ADDR");
}
if (!isValidIp(ip)) {
ip = request.getRemoteAddr();
}
return ip;
}
public static String getClientIpAddr(ServerHttpRequest request) {
String ip = request.getHeaders().getFirst("X-Forwarded-For");
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("Proxy-Client-IP");
}
if (!isValidIp(ip)) {
ip =request.getHeaders().getFirst("WL-Proxy-Client-IP");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("HTTP_X_FORWARDED_FOR");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("HTTP_X_FORWARDED");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("HTTP_X_CLUSTER_CLIENT_IP");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("HTTP_CLIENT_IP");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("HTTP_FORWARDED_FOR");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("HTTP_FORWARDED");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("HTTP_VIA");
}
if (!isValidIp(ip)) {
ip = request.getHeaders().getFirst("REMOTE_ADDR");
}
if (!isValidIp(ip)) {
ip = request.getRemoteAddress().getHostName();
}
return ip;
}
private static boolean isValidIp(String ip){
return !(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip));
}
/**
* 获取tomcat内置服务监听端口
* @return
*/
public static int getTomcatPort() {
try{
MBeanServer beanServer = ManagementFactory.getPlatformMBeanServer();
Set<ObjectName> objectNames = beanServer.queryNames(new ObjectName("*:type=Connector,*"),
Query.match(Query.attr("protocol"), Query.value("HTTP/1.1")));
String port = objectNames.iterator().next().getKeyProperty("port");
return Integer.valueOf(port);
}catch (Exception e){
log.error("get tomcat port fail", e);
}
return 0;
}
}
还需要编写配置类：
@LoadBalancerClients(defaultConfiguration = NacosLoadBalancerConfig.class)
public class NacosLoadBalancerConfig {
@Bean
public ReactorLoadBalancer<ServiceInstance> nacosLoadBalancer(Environment environment,
LoadBalancerClientFactory loadBalancerClientFactory,NacosDiscoveryProperties configProperties)
{
String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
return new CustomNacosLoadBalancer(loadBalancerClientFactory
.getLazyProvider(name, ServiceInstanceListSupplier.class), name,configProperties);
}
}