Spring Cloud LoadBalancer 入门与实战

一、什么是 LoadBalancer?

LoadBalancer(负载均衡器) 是一种网络设备或软件机制，用于分发传入的网络流量负载（请求）到多个后端目标服务器上，从而实现系统资源的均衡利用和提高系统的可用性和新能。

1.1 负载均衡分类

负载均衡分为服务器端负载均衡和客户端负载均衡

1. 服务器端负载均衡指的是存放在服务器端的负载均衡器，例如 Nginx、HAProxy、F5 等。

2. 客户端负载均衡指的是嵌套在客户端的负载均衡器，例如 Ribbon、Spring Cloud LoadBalancer。

1.2 常见的负载均衡策略

  1. 询轮：按照顺序将每个新的请求分发给后端服务器，依次循环。这是一种最简单的负载均衡策略，适用于后端服务器的性能相近，且每个请求的处理时间大致相同的情况。

  2. 随机选择：随机选择一个后端服务器来处理每个新的请求。这种策略适用于后端服务器性能相似，且每个请求的处理时间相近的情况，但不保证请求的分发是均匀的。

  3. 最少连接：最少连接策略将请求分发给当前连接数最少的后端服务器。这可以确保负载均衡在后端服务器的连接负载上均衡。但需要维护连接计数。

  4. IP 哈希：IP 哈希策略使用客户端的 IP 地址来计算哈希值，然后将请求发送到与哈希值对应的后端服务器。这种策略可用于确保来自同一客户端的请求都被发送到同一台后端服务器，适用于需要会话保持的情况。

  5. 加权轮询：加权轮询给每个后端服务器分配一个权重值，然后按照权重值比例来分发请求。这可以用来处理后端服务器性能不均衡的情况，将更多的请求发给性能更高的服务器。

  6. 加权随机选择：加权随机选择与加权轮询类似，但是按照权重值来随机选择后端服务器。这也可以用来处理后端服务器性能不均衡的情况，但是分发更随机。

  7. 最短响应时间 ：最短响应时间策略会测量每个后端服务器的响应时间，并将请求发送到响应时间最短的服务器。这中策略可以确保客户端获得最快的响应，适用于要求低延迟的应用。

二、默认负载均衡策略

Spring Cloud LoadBalancer 负载均衡策略默认的是轮询，这一点可以通过 Spring Cloud LoadBalancer 的配置类 LoadBalancerClientConfiguration 中发现，它的部分源码如下：

@ConditionalOnDiscoveryEnabled
public class LoadBalancerClientConfiguration {
    private static final int REACTIVE_SERVICE_INSTANCE_SUPPLIER_ORDER = 193827465;

    public LoadBalancerClientConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean
    public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty("loadbalancer.client.name");
        return new RoundRobinLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
    //...
}

 RoundRobinLoadBalancer 核心实现源码：

private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
        if (instances.isEmpty()) {
            if (log.isWarnEnabled()) {
                log.warn("No servers available for service: " + this.serviceId);
            }

            return new EmptyResponse();
        } else if (instances.size() == 1) {
            return new DefaultResponse((ServiceInstance)instances.get(0));
        } else {
            //当有多个实例时，& Integer.MAX_VALUE 摒弃负数，确保下标为正数
            int pos = this.position.incrementAndGet() & Integer.MAX_VALUE;
            //取模进行轮询
            ServiceInstance instance = (ServiceInstance)instances.get(pos % instances.size());
            return new DefaultResponse(instance);
        }
    }

三、随机负载均衡策略

代码实现

设置局部负载均衡器：

//balancer-service：注册实例名称
//RandomLoadBalanceConfig.class 自定义负载均衡器类名
@LoadBalancerClient(name = "balancer-service",configuration = RandomLoadBalanceConfig.class)
public class RandomLoadBalanceConfig {
    @Bean
    public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty("loadbalancer.client.name");
        return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

设置全局负载均衡器：

@SpringBootApplication
@EnableFeignClients
@LoadBalancerClients(defaultConfiguration= RandomLoadBalanceConfig.class)
public class ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }

}

四、设置Nacos权重负载均衡器

Nacos 中支持两种负载均衡器，一种是权重负载均衡器，另一种是第三方 CMDB（地域就近访问）标签负载均衡器，我们可以将 Spring Cloud Loadbalancer 直接配置为 Nacos 的负载均衡器，它默认就是权重负载均衡策略。

它的配置有以下两步：

1. 创建 Nacos 负载均衡器

@LoadBalancerClient(name = "balancer-service",configuration = NacosLoadBalanceConfig.class)
public class NacosLoadBalanceConfig {
    @Resource
    private NacosDiscoveryProperties nacosDiscoveryProperties;
    @Bean
    public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty("loadbalancer.client.name");
        return new NacosLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name,nacosDiscoveryProperties);
    }
}

五、创建自定义负载均衡器 

5.1 创建自定义负载均衡器

自定义负载均衡器只需要参考官方负载均衡器写就可

public class CustomizeLoadBalance implements ReactorServiceInstanceLoadBalancer {
    private static final Logger log = LoggerFactory.getLogger(NacosLoadBalancer.class);
    private final String serviceId;
    private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    private final NacosDiscoveryProperties nacosDiscoveryProperties;
    private static final String IPV4_REGEX = "((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})(.((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})){3}";
    private static final String IPV6_KEY = "IPv6";
    public static String ipv6;
    @Autowired
    private InetIPv6Utils inetIPv6Utils;

    @PostConstruct
    public void init() {
        String ip = this.nacosDiscoveryProperties.getIp();
        if (StringUtils.isNotEmpty(ip)) {
            ipv6 = Pattern.matches("((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})(.((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})){3}", ip) ? (String)this.nacosDiscoveryProperties.getMetadata().get("IPv6") : ip;
        } else {
            ipv6 = this.inetIPv6Utils.findIPv6Address();
        }

    }

    private List<ServiceInstance> filterInstanceByIpType(List<ServiceInstance> instances) {
        if (StringUtils.isNotEmpty(ipv6)) {
            List<ServiceInstance> ipv6InstanceList = new ArrayList();
            Iterator var3 = instances.iterator();

            while(var3.hasNext()) {
                ServiceInstance instance = (ServiceInstance)var3.next();
                if (Pattern.matches("((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})(.((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})){3}", instance.getHost())) {
                    if (StringUtils.isNotEmpty((CharSequence)instance.getMetadata().get("IPv6"))) {
                        ipv6InstanceList.add(instance);
                    }
                } else {
                    ipv6InstanceList.add(instance);
                }
            }

            if (ipv6InstanceList.size() == 0) {
                return (List)instances.stream().filter((instancex) -> {
                    return Pattern.matches("((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})(.((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})){3}", instancex.getHost());
                }).collect(Collectors.toList());
            } else {
                return ipv6InstanceList;
            }
        } else {
            return (List)instances.stream().filter((instancex) -> {
                return Pattern.matches("((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})(.((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})){3}", instancex.getHost());
            }).collect(Collectors.toList());
        }
    }

    public CustomizeLoadBalance(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId, NacosDiscoveryProperties nacosDiscoveryProperties) {
        this.serviceId = serviceId;
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
        this.nacosDiscoveryProperties = nacosDiscoveryProperties;
    }

    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServiceInstanceListSupplier supplier = (ServiceInstanceListSupplier)this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
        return supplier.get(request).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();
        } else {
            try {
                String clusterName = this.nacosDiscoveryProperties.getClusterName();
                List<ServiceInstance> instancesToChoose = serviceInstances;
                if (StringUtils.isNotBlank(clusterName)) {
                    List<ServiceInstance> sameClusterInstances = (List)serviceInstances.stream().filter((serviceInstance) -> {
                        String cluster = (String)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 = {}", new Object[]{this.serviceId, clusterName, serviceInstances});
                }
                //获取request 对象
                ServletRequestAttributes attributes= (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
                HttpServletRequest request= attributes.getRequest();
                String ipAddress=request.getRemoteAddr();
                System.out.println(ipAddress);
                int hash=ipAddress.hashCode();
                //自定义负载据衡器策略，通过ip hash后，取模获取下标
                int index=(hash&Integer.MAX_VALUE)%serviceInstances.size();
                System.out.println(index);
                //获取服务实例
                ServiceInstance instance=serviceInstances.get(index);
                return new DefaultResponse(instance);
            } catch (Exception var5) {
                log.warn("NacosLoadBalancer error", var5);
                return null;
            }
        }
    }
}

5.2 封装并设置自定义负载均衡器

@LoadBalancerClient(name = "balancer-service" ,configuration = CoustomizeHashLoadBalanceConfig.class)
public class CoustomizeHashLoadBalanceConfig {
    @Resource
    private NacosDiscoveryProperties nacosDiscoveryProperties;
    @Bean
    public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty("loadbalancer.client.name");
        return  new CustomizeLoadBalance(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name,nacosDiscoveryProperties);
    }
}

六、缓存

Spring Cloud LoadBalancer 在获取实例时有两种选择：

  1. 即时获取：每次从注册中心得到最新的健康实例，效果好、开销大
  2. 缓存服务列表：每次得到服务列表之后，缓存一段时间，这样既能保证性能，同时也能兼容一定的及时性。

Spring Cloud LoadBalancer 中默认开启了缓存服务列表的功能。

Spring Cloud LoadBalancer 默认缓存的重要特性有两项：

  1. 缓存的过期时间为 35s
  2. 缓存保存个数为 256 个
spring:
  cloud:
    loadbalancer:
      cache:
        ttl: 10
        capacity: 128
        #不开启缓存
        enabled:false

注意：尽管在不开启缓存对于开发和测试很有用，但其效率远低于将缓存开启，因此建议在生产环境中始终启用缓存

七、执行原理

OpenFeign 底层是通过 HTTP 客户端对象 RestTemplate 实现接口请求的，而负载均衡器的作用只是在请求客户端发送请求之前，得到一个服务的地址给到 RestTemplate 对象，而 Spring Cloud LoadBalancer 的整体类图如下：

通过查看 Spring Cloud LoadBalancer 源码可以发现，@LoadBalancer 注解由 spring-cloud-commons 实现，查看实现逻辑我们发现 spring-cloud-commons 存在自动配置类 LoadBalancerAutoConfiguration，当满足条件时，将自动创建 LoadBalancerInterceptor 并注入到RestTemplate 中，部分源码如下： 

    @Configuration(
        proxyBeanMethods = false
    )
    @Conditional({RetryMissingOrDisabledCondition.class})
    static class LoadBalancerInterceptorConfig {
        LoadBalancerInterceptorConfig() {
        }

        @Bean
        public LoadBalancerInterceptor loadBalancerInterceptor(LoadBalancerClient loadBalancerClient, LoadBalancerRequestFactory requestFactory) {
            return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
        }

        @Bean
        @ConditionalOnMissingBean
        public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) {
            return (restTemplate) -> {
                List<ClientHttpRequestInterceptor> list = new ArrayList(restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            };
        }
    }

LoadBalancerInterceptor 又实现了 ClientHttpRequestInterceptor 接口，并实现 Intercept 方法，用于实现负载均衡的拦截处理，实现源码：

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
    private LoadBalancerClient loadBalancer;
    private LoadBalancerRequestFactory requestFactory;

    public LoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory) {
        this.loadBalancer = loadBalancer;
        this.requestFactory = requestFactory;
    }

    public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
        this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
    }

    public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
        URI originalUri = request.getURI();
        String serviceName = originalUri.getHost();
        Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
        return (ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution));
    }
}

其中有一个 LoadBalancerClient 负载均衡客户端，用于进行负载均衡逻辑，从服务列表中选择出一个服务进行地址进行调用，默认实现为 BlockingLoadBalancerClient,源码如下：

    public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
        String hint = this.getHint(serviceId);
        LoadBalancerRequestAdapter<T, TimedRequestContext> lbRequest = new LoadBalancerRequestAdapter(request, this.buildRequestContext(request, hint));
        Set<LoadBalancerLifecycle> supportedLifecycleProcessors = this.getSupportedLifecycleProcessors(serviceId);
        supportedLifecycleProcessors.forEach((lifecycle) -> {
            lifecycle.onStart(lbRequest);
        });
        ServiceInstance serviceInstance = this.choose(serviceId, lbRequest);
        if (serviceInstance == null) {
            supportedLifecycleProcessors.forEach((lifecycle) -> {
                lifecycle.onComplete(new CompletionContext(Status.DISCARD, lbRequest, new EmptyResponse()));
            });
            throw new IllegalStateException("No instances available for " + serviceId);
        } else {
            return this.execute(serviceId, serviceInstance, lbRequest);
        }
    }

public <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException {
        DefaultResponse defaultResponse = new DefaultResponse(serviceInstance);
        Set<LoadBalancerLifecycle> supportedLifecycleProcessors = this.getSupportedLifecycleProcessors(serviceId);
        Request lbRequest = request instanceof Request ? (Request)request : new DefaultRequest();
        supportedLifecycleProcessors.forEach((lifecycle) -> {
            lifecycle.onStartRequest(lbRequest, new DefaultResponse(serviceInstance));
        });

        try {
            T response = request.apply(serviceInstance);
            Object clientResponse = this.getClientResponse(response);
            supportedLifecycleProcessors.forEach((lifecycle) -> {
                lifecycle.onComplete(new CompletionContext(Status.SUCCESS, lbRequest, defaultResponse, clientResponse));
            });
            return response;
        } catch (IOException var9) {
            supportedLifecycleProcessors.forEach((lifecycle) -> {
                lifecycle.onComplete(new CompletionContext(Status.FAILED, var9, lbRequest, defaultResponse));
            });
            throw var9;
        } catch (Exception var10) {
            supportedLifecycleProcessors.forEach((lifecycle) -> {
                lifecycle.onComplete(new CompletionContext(Status.FAILED, var10, lbRequest, defaultResponse));
            });
            ReflectionUtils.rethrowRuntimeException(var10);
            return null;
        }
    }

    public ServiceInstance choose(String serviceId) {
        return this.choose(serviceId, ReactiveLoadBalancer.REQUEST);
    }

    //通过不同的负载均衡器选择不同的服务
    public <T> ServiceInstance choose(String serviceId, Request<T> request) {
        //获取负载均衡器
        ReactiveLoadBalancer<ServiceInstance> loadBalancer = this.loadBalancerClientFactory.getInstance(serviceId);
        if (loadBalancer == null) {
            return null;
        } else {
            //根据负载均衡器得到一个请求实例
            Response<ServiceInstance> loadBalancerResponse = (Response)Mono.from(loadBalancer.choose(request)).block();
            return loadBalancerResponse == null ? null : (ServiceInstance)loadBalancerResponse.getServer();
        }
    }

 小结：OpenFeign 通过拦截器调用 RestTemplate 实现和服务的交互，RestTemplate 通过HttpClient 进行请求，而在交互之前通过调用 Spring Cloud LoadBalancer中的LoadBalancerClient中的choose 方法 ,根据服务 id 和负载均衡策略得到某个服务地址，再进行调用。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/790825.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

解决打印PDF文本不清楚的处理办法

解决打印PDF文本不清楚的处理办法

之前打印PDF格式的电子书&#xff0c;不清晰&#xff0c;影响看书的心情&#xff0c;有时看到打印的书的质量&#xff0c;根本不想看&#xff0c;今天在打印一本页数不多&#xff0c;但PDF格式的书感觉也不太清楚&#xff0c;我想应该有办法解决&#xff0c;我使用的是解决福昕…
阅读更多...
FPGA程序设计

FPGA程序设计

在设计FPGA时&#xff0c;多运用模块化的思想取设计模块&#xff0c;将某一功能设计成module。 设计之前要先画一下模块设计图&#xff0c;列出输入输出接口&#xff0c;再进一步设计内部功能。 状态机要画图&#xff0c;确定每个状态和状态之间怎么切换。状态用localparam定…
阅读更多...
东方通Tongweb发布vue前端

东方通Tongweb发布vue前端

一、前端包中添加文件 1、解压vue打包文件 以dist.zip为例&#xff0c;解压之后得到dist文件夹&#xff0c;进入dist文件夹&#xff0c;新建WEB-INF文件夹&#xff0c;进入WEB-INF文件夹&#xff0c;新建web.xml文件&#xff0c; 打开web.xml文件&#xff0c;输入以下内容 …
阅读更多...
开启HIVE中分区表支持中文字段

开启HIVE中分区表支持中文字段

进入hive表&#xff1a; use hive; #修改hive database编码 alter database hive default character set utf8; #修改table编码 alter table PARTITIONS default character set utf8; alter table PARTITION_KEY_VALS default character set utf8; alter table SDS default cha…
阅读更多...
泛型

泛型

背景 优点 类型绝对安全避免强制类型转换 泛型类 定义 使用 举例 泛型类 // 泛型类 T就是类型参数 public class Generic<T>{// key这个成员变量的类型为T,T的类型由外部指定private T t;public void set(T t){this.t t;}public T get(){return t;} }使用 // 创建一个泛…
阅读更多...
前端JS特效第28集：JQuery电影选座插件

前端JS特效第28集：JQuery电影选座插件

JQuery电影选座插件&#xff0c;先来看看效果&#xff1a; 部分核心的代码如下(全部代码在文章末尾)&#xff1a; <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">&l…
阅读更多...
ch552g中使用SPI进行主从机通信时发现的问题

ch552g中使用SPI进行主从机通信时发现的问题

参考 基本硬件准备 两块独立的ch552g的板子&#xff0c;开始连接时数据传输出现数据错误&#xff0c;本来猜想是通信线连接问题&#xff0c;后来用了较短的连接线依然没有改善。 SPI通信的认知 SPI一般都是全双工实时通信&#xff0c;所以在发送数据时一般有短暂的停留使得…
阅读更多...
【测试开发】--安全渗透测试

【测试开发】--安全渗透测试

1. 安全渗透 1.1 分类 web数据库安全web应用服务器安全&#xff08;文件上传漏洞、文件包含漏洞&#xff09;web客户端安全&#xff08;XSS跨站攻击&#xff09; 2. sql注入 2.1 sql注入介绍 sql注入在安全问题中排行榜首sql注入攻击是输入参数未经过滤&#xff0c;然后直…
阅读更多...
DBeaver操作MySQL无法同时执行多条语句的解决方法

DBeaver操作MySQL无法同时执行多条语句的解决方法

DBeaver选择数据库连接&#xff0c;在【驱动属性】中将allowMultiQueries允许执行多条语句置为True
阅读更多...
JS进阶-构造函数

JS进阶-构造函数

学习目标&#xff1a; 掌握构造函数 学习内容&#xff1a; 构造函数 构造函数&#xff1a; 封装是面向对象思想中比较重要的一部分&#xff0c;js面向对象可以通过构造函数实现的封装。 同样的将变量和函数组合到了一起并能通过this实现数据的共享&#xff0c;所不同的是借助…
阅读更多...
MySQL之基本查询(下)-表的增删查改

MySQL之基本查询(下)-表的增删查改

表的增删查改&#xff1a;CRUD : Create(创建), Retrieve(读取)&#xff0c;Update(更新)&#xff0c;Delete&#xff08;删除&#xff09; Update(更新) 语法&#xff1a; UPDATE table_name SET column expr [, column expr ...] [WHERE ...] [ORDER BY ...] [LIMIT ...] …
阅读更多...
嘎嘎详细的三维变换详细讲解，包括视图变换、投影变换等，超级通俗易懂！

嘎嘎详细的三维变换详细讲解，包括视图变换、投影变换等，超级通俗易懂！

前置二维空间的各种变换笔记&#xff1a;二维变换 三维空间中的齐次坐标 从二维变换开始引申&#xff0c;可得到三维中的一个点的表达方式为 ( x , y , z , 1 ) ⊤ (\mathbf{x}, \mathbf{y}, \mathbf{z}, 1)^{\top} (x,y,z,1)⊤&#xff0c;也就是w1&#xff0c;而三维的向量…
阅读更多...
WPF 制作一个文字漂浮提示框

WPF 制作一个文字漂浮提示框

WPF好像没有自带的文字提示漂浮&#xff0c;我们可以定制一个。 效果如下&#xff1a; xaml xaml如下&#xff1a; <Window x:Class"GroupServer.MsgTip"xmlns"http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x"http://sc…
阅读更多...
【三维向量旋转】基于Matlab的三维坐标旋转

【三维向量旋转】基于Matlab的三维坐标旋转

一、问题描述 若空间中存在三个点A,B,C&#xff0c;其中A点是不动点&#xff0c;B点是当前方向向量上的一个点&#xff0c;C是目标方向上的一个点。如果要让AB向量沿着BC方向进行旋转&#xff0c;使得AB最终旋转到AC。这个过程就是三维向量的旋转过程。我们关注的是这个过程&am…
阅读更多...
【音频特征提取】傅里叶变换算法源码学习记录

【音频特征提取】傅里叶变换算法源码学习记录

目录 背景快速理解FFT&#xff08;快速傅里叶变换&#xff09;IFFT&#xff08;逆傅里叶变换&#xff09;STFT&#xff08;短时傅里叶变换&#xff09; 代码实现FFT源代码IFFT源代码FFT、IFFT自己实验STFT源代码STFT自己实验 总结 背景 最近用到了相关操作提取音频信号特征&am…
阅读更多...
松下的台灯值得入手吗？书客|飞利浦护眼台灯真实测评PK

松下的台灯值得入手吗？书客|飞利浦护眼台灯真实测评PK

在追求高效阅读与舒适生活的今天&#xff0c;一盏好的台灯不仅是照明的工具&#xff0c;更是呵护双眼的伴侣。它不仅能够提供额外的光线&#xff0c;还能减少眼睛疲劳&#xff0c;提高我们的工作和学习效率。随着市场的不断发展&#xff0c;护眼台灯品牌款式愈发丰富。因此我们…
阅读更多...
MYSQL 四、mysql进阶 8（索引优化与查询优化）

MYSQL 四、mysql进阶 8（索引优化与查询优化）

都有哪些维度可以进行数据库调优&#xff1f;简言之&#xff1a; 索引失效、没有充分利用到索引——建立索引关联查询太多JOIN&#xff08;设计缺陷或不得已的需求&#xff09;——SQL优化服务器调优及各个参数设置&#xff08;缓冲、线程数等&#xff09;——调整my.cnf数据过…
阅读更多...
【C++】C++11（三）

【C++】C++11（三）

我们在C11&#xff08;2&#xff09;中已经很好的解释了右值引用&#xff0c;这次来看看右值引用剩余的一些话题&#xff1a;可变参数包与emplace_back。 目录 可变参数模板&#xff1a;可变参数的sizeof&#xff1a;可变参数的展开&#xff1a;递归函数方式展开参数包&#x…
阅读更多...
通过Arcgis从逐月平均气温数据中提取并计算年平均气温

通过Arcgis从逐月平均气温数据中提取并计算年平均气温

通过Arcgis快速将逐月平均气温数据生成年平均气温数据。本次用2020年逐月平均气温数据操作说明。 一、准备工作 &#xff08;1&#xff09;准备Arcmap桌面软件&#xff1b; &#xff08;2&#xff09;准备2020年逐月平均气温数据&#xff08;NC格式&#xff09;、范围图层数据&…
阅读更多...
k8s 部署RuoYi-Vue-Plus之server部署

k8s 部署RuoYi-Vue-Plus之server部署

1.先使用项目编排构建镜像, 修改prod使用的mysql, redis地址 获取运行的服务 kubectl get svc -n ruoyi对应连接修改 然后运行打包package命令, 生成jar包, 再打包为docker容器, 上传到所有节点上, 也可以上传到个人私有仓库 2.部署server-deploy.yaml 镜像名自行修改, apiV…
阅读更多...
最新文章

Copyright @ 2022~2023