gateway Redisson接口级别限流解决方案

文章目录

  • 前言
    • 1. 计数器算法（固定窗口限流器）
    • 2. 滑动窗口日志限流器
    • 3. 漏桶算法（Leaky Bucket）
    • 4. 令牌桶算法（Token Bucket）
    • 5. 限流队列
    • 应用场景
    • 实现工具
  • 一、Redisson简介
  • 二、Redisson限流器的原理
  • 三、Redisson限流器技术的应用
  • 四、gateway自定义接口限流实现
    • 1. maven
    • 2. 接口限流数据结构定义RateLimitProperties
    • 3. RedissonClient 注入
    • 4. redis 初始化写入限流配置
    • 5. 接口过滤限流规则
    • 6. nacos配置热更新redis配置
    • 7. 接口匹配工具类
  • 总结

前言

在当今互联网时代，面对快速增长的用户流量和不断扩大的系统规模，合理的限流策略变得愈发重要。针对这一问题，Redisson作为一款高性能的分布式应用开发框架，在限流方面拥有出色的技术。本文将深入探讨Redisson的限流器技术，为读者详细介绍其原理和应用。

在软件架构中，限流器（Rate Limiter）是一种用于控制资源利用、维持服务质量和防止系统过载的重要组件。限流器可以按照不同的策略和算法来实现，主要包括以下几种类型：

1. 计数器算法（固定窗口限流器）

原理：在一个固定的时间窗口内计算请求的数量，如果请求超过了预设的最大阈值，则拒绝后续的请求，直到下一个时间窗口开始。

优点：简单易理解和实现。

缺点：在窗口切换的时刻可能会发生两倍于阈值的请求量，即“窗口边缘效应”。

2. 滑动窗口日志限流器

原理：改进了固定窗口算法的边缘效应。它记录了每个请求的时间戳，将时间窗口分成多个小窗口，滑动时只统计当前时间窗口内的请求量。

优点：比固定窗口算法更平滑，减少了窗口切换时的峰值。

缺点：需要记录更多的请求信息，可能会增加系统开销。

3. 漏桶算法（Leaky Bucket）

原理：所有的请求都被放入到一个固定容量的桶里，请求按照固定的速率从桶中“漏出”（被处理）。如果桶满了，则会丢弃进来的请求。

优点：输出流量比较平滑，即使短时间内有大量请求到达，输出速率也是恒定的。

缺点：不具备突发流量的处理能力，对于突发请求仍然可能导致请求被丢弃。
请添加图片描述

4. 令牌桶算法（Token Bucket）

原理：令牌以固定速率被添加到桶中，每个请求必须消耗一个令牌才能被处理。如果桶中没有令牌，则请求被排队或丢弃，直到有令牌可用。

优点：允许一定程度的突发流量，因为桶中可以累积一些令牌。

缺点：如果突发流量持续时间较长，超过了桶的容量，那么超出的请求仍然会被丢弃或延迟处理。
请添加图片描述

5. 限流队列

原理：请求首先进入一个队列，队列根据系统的处理能力和预设的规则控制请求的进入和退出。

优点：可以根据系统负载动态调整请求的进出，对系统影响较小。

缺点：实现相对复杂，需要精确控制队列的大小和请求的处理速率。

应用场景

  • API网关：在API网关层面进行限流，可以防止过多的请求直接压垮后端服务。
  • 分布式系统：在分布式服务之间进行限流，可以协调不同服务的负载，防止某些服务成为瓶颈。
  • 微服务架构：对单个微服务的接口进行限流，保证服务的稳定性。

实现工具

  • Guava RateLimiter：基于令牌桶算法，是Java中一个广泛使用的限流实现。
  • Nginx：使用漏桶算法进行HTTP请求的限流。
  • Redis：可以使用Redis的原子性操作和脚本来实现复杂的限流策略。

选择合适的限流策略应当基于系统的具体需求，比如是否需要应对突发流量、系统的可用性要求、实现的复杂度等因素。在实际应用中，很可能会结合多种策略来实现更加精细化的流量控制。

一、Redisson简介

Redisson是一个基于Redis的Java驻留内存（In-Memory）数据网格中间件，提供了丰富的分布式对象和服务，可用于开发高性能、可扩展的分布式应用。其中，Redisson的限流器技术是其重要的功能之一。

二、Redisson限流器的原理

Redisson限流器采用了一种基于令牌桶算法的策略。令牌桶算法通过维护一个固定容量的令牌桶，在每个时间段内产生若干个令牌，请求在获取令牌后才能进行处理。这种算法可以有效控制流量，并在一定程度上保护系统免受突然的高并发压力。

三、Redisson限流器技术的应用

  1. 系统流控
    Redisson的限流器技术可以用于对系统进行流量控制，确保系统在高负载情况下依然能够提供稳定可靠的服务。通过限制请求的速率和并发数，可以避免系统因为过载而崩溃或变得不可用。

  2. 接口保护
    对于一些重要的接口或某些敏感资源，我们可能希望限制用户的访问频率，以避免恶意的使用或攻击。Redisson的限流器技术可以很好地实现这一目的，通过限制请求的速率和次数，有效保护接口的安全性和可用性。

  3. 基于用户的限流
    对于一些特定用户或特定用户组，我们可能需要设置不同的限流策略。Redisson提供了基于用户的限流管理能力，可以根据用户身份信息或其他特征进行流量控制，满足个性化的限流需求。

四、gateway自定义接口限流实现

1. maven

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.16.1</version>
        </dependency>

2. 接口限流数据结构定义RateLimitProperties

gateway.yaml

gateway:
  rate-limit:
    configs:
      - name: 服务1
        option:
          - uri: 接口1/*
            matchType: 1
            size: 200
            microSecond: 1000
      - name: 服务2
        option:
          - uri: 接口1/*
            matchType: 1
            size: 1
            second: 1
          - uri: 接口2
            matchType: 0
            size: 1
            microSecond: 1000
      - name: 服务3
        option:
          - uri: 接口1
            matchType: 0
            size: 10
            microSecond: 1000
            consumer: 1
            waitTimer: 1000

限流配置类 RateLimitProperties

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * 限流配置获取，支持热更新
 */

@Data
@Component
@JsonIgnoreProperties(ignoreUnknown = true)
@ConfigurationProperties(prefix = "gateway.rate-limit")
public class RateLimitProperties {

    private List<Configs> configs;

    @Data
    @Component
    @ConfigurationProperties(prefix = "gateway.rate-limit.configs")
    public static class Configs {
        private String name;
        private List<Option> option = new ArrayList<>();

        @Data
        @Component
        @JsonIgnoreProperties(ignoreUnknown = true)
        @ConfigurationProperties(prefix = "gateway.rate-limit.configs.option")
        public static class Option {
            private String uri; //api uri
            private int matchType; // 匹配类型 0 完整匹配 1 模糊匹配
            private int size; //令牌桶 大小
            private int microSecond = 1000; //生成令牌的周期
            private int consumer = 1; //一个请求消耗令牌数量
            private int waitTimer = 0; // 等待最多xx s后再拿令牌
        }
    }
}

3. RedissonClient 注入

RedisConfig

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.TransportMode;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String redisAddress;
    @Value("${spring.redis.port}")
    private String redisPort;
    @Value("${spring.redis.password}")
    private String redisPas;
    @Value("${spring.redis.database:1}")
    private Integer redisDb;

    @Bean
    public RedissonClient redissonClient(RedisProperties redisProperties) {
        Config config = new Config();
        config.setTransportMode(TransportMode.NIO);
        config.useSingleServer().setAddress("redis://" + redisAddress + ":" + redisPort)
                .setPassword(redisPas)
                .setDatabase(redisDb);
        return Redisson.create(config);
    }

    public static void redisSerialize(RedisTemplate redisTemplate) {
        // 2.设置统一序列化规则
        RedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);

        //Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = serializer();
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setEnableTransactionSupport(false);
    }

    private static Jackson2JsonRedisSerializer serializer() {
        //Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        return jackson2JsonRedisSerializer;
    }
}

4. redis 初始化写入限流配置

ApiRateLimitInit

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;
import java.util.List;

@Configuration
@Slf4j
public class ApiRateLimitInit {

    @Resource
    private RateLimitProperties properties;

    @Resource
    private RedisTemplate<String, RateLimitProperties.Configs> redisTemplate;

    @Resource
    private RedissonClient redissonClient;

    @Bean
    public void initApis() {
        List<RateLimitProperties.Configs> configs = properties.getConfigs();
        //将最新的配置放到redis中，在做限流判断的代码中，直接从redis中读取最新的配置
        redisLimitConfig(configs);
    }

    public void redisLimitConfig(List<RateLimitProperties.Configs> configs) {
        RedisConfig.redisSerialize(redisTemplate);
        redisTemplate.delete("ApiRateLimitFilter");
        RKeys keys = redissonClient.getKeys();
        keys.deleteByPattern("*buslimiters*");
        if (ObjectUtil.isNotNull(configs)) {
            redisTemplate.opsForList().leftPushAll("ApiRateLimitFilter", configs);
            //重新初始化所有limiter
            for (RateLimitProperties.Configs temp : configs) {
                temp.getOption().forEach(o -> {
                    RRateLimiter limiter = redissonClient.getRateLimiter(StrUtil.format("buslimiters:{}:{}", temp.getName(), o.getUri()));
                    limiter.trySetRate(RateType.OVERALL, o.getSize(), o.getMicroSecond(), RateIntervalUnit.MILLISECONDS);
                });
            }
        }
    }
}

5. 接口过滤限流规则

ApiRateLimitFilter

import cn.hutool.core.util.StrUtil;
import com.gsafety.bg.gsdss.gateway.contants.CommonConstant;
import com.gsafety.bg.gsdss.gateway.utils.ResponseUtils;
import com.gsafety.bg.gsdss.gateway.utils.WebUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RRateLimiter;
import org.redisson.api.RedissonClient;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class ApiRateLimitFilter implements GlobalFilter, Ordered {
    @Resource
    private RedissonClient redissonClient;
    @Resource
    private RedisTemplate<String, RateLimitProperties.Configs> redisTemplate;

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String uri = exchange.getRequest().getURI().getPath().substring(1);
        int index = uri.indexOf("/");
        String microServiceName = StringUtils.substringBefore(uri, "/");
        String apiPath = uri.substring(index);
        List<RateLimitProperties.Configs> configs = redisTemplate.opsForList().range("ApiRateLimitFilter", 0, -1);
        List<RateLimitProperties.Configs.Option> option = configs.stream()
                .filter(s -> microServiceName.equals(s.getName()))
                .findFirst().orElse(new RateLimitProperties.Configs()).getOption();
        RateLimitProperties.Configs.Option thisOption = WebUtils.matchesRateLimit(apiPath, option);
        //不在限流配置中
        if (thisOption == null) {
            return chain.filter(exchange);
        }
        RRateLimiter limiter = redissonClient.getRateLimiter(StrUtil.format("buslimiters:{}:{}", microServiceName, thisOption.getUri()));
        boolean acquire = limiter.tryAcquire(thisOption.getConsumer(), thisOption.getWaitTimer(), TimeUnit.MICROSECONDS);
        if (acquire) {
            return chain.filter(exchange);
        }
        log.info(uri + "限流");
        //exchange 信息放入kafka中，等待消费
        return ResponseUtils.error(exchange.getResponse(), CommonConstant.ErrorResp.BUSY_ERROR);
    }
}

6. nacos配置热更新redis配置

RateLimitNacosListener

import cn.hutool.json.JSONUtil;
import com.alibaba.cloud.nacos.NacosConfigManager;
import com.alibaba.cloud.nacos.NacosConfigProperties;
import com.alibaba.nacos.api.config.listener.Listener;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.Executor;

@Slf4j
@Configuration
public class RateLimitNacosListener implements InitializingBean {

    @Value("${spring.application.name}")
    private String appName;
    @Resource
    private NacosConfigManager nacosConfigManager;
    @Resource
    private NacosConfigProperties configProperties;
    @Resource
    private ApiRateLimitInit rateLimitInit;

    @Override
    public void afterPropertiesSet() throws Exception {
        nacosConfigManager.getConfigService().addListener(appName + ".yaml", configProperties.getGroup(),
                new Listener() {
                    @Override
                    public Executor getExecutor() {
                        return null;
                    }

                    @Override
                    public void receiveConfigInfo(String configInfo) {
                        YAMLMapper yamlMapper = new YAMLMapper();
                        try {
                            JsonNode jsonNode = yamlMapper.readTree(configInfo);
                            String configStr = jsonNode.get("gateway").get("rate-limit").get("configs").toPrettyString();
                            List<RateLimitProperties.Configs> configs = JSONUtil.toList(configStr, RateLimitProperties.Configs.class);
                            //将最新的配置放到redis中，在做限流判断的代码中，直接从redis中读取最新的配置
                            rateLimitInit.redisLimitConfig(configs);
                            log.info("config更新:" + configStr);
                        } catch (JsonProcessingException e) {
                            throw new RuntimeException(e);
                        }
                    }
                });
    }
}

7. 接口匹配工具类

WebUtils

/**
 * WebUtils 工具类
 *
 */
public class WebUtils {

    /**
     * 获取限流接口对象
     */
    public static RateLimitProperties.Configs.Option matchesRateLimit(String uri, List<RateLimitProperties.Configs.Option> all) {
        PathMatcher matcher = new AntPathMatcher();
        List<RateLimitProperties.Configs.Option> allMatch = all.stream().filter(o -> !o.getUri().endsWith("*")).collect(Collectors.toList());
        for (RateLimitProperties.Configs.Option option : allMatch) {
            if (StringUtils.equals(option.getUri(), uri)) {
                return option;
            }
        }
        List<RateLimitProperties.Configs.Option> fuzzyMatch = all.stream().filter(o -> o.getUri().endsWith("*")).collect(Collectors.toList());
        for (RateLimitProperties.Configs.Option option : fuzzyMatch) {
            if (matcher.match(option.getUri(), uri)) {
                return option;
            }
        }
        return null;
    }
}

总结

其他方案尝试：
gateway自带限流器：令牌桶算法实现，支持自定义key-resolver，即限流规则（用户、ip、请求地址等），但是只支持服务级别限流，无法限制到具体接口

Redisson的限流器技术是一项用于控制系统流量并保护重要接口的强大工具。它通过令牌桶算法，提供了灵活的流控策略和个性化的限流管理，帮助开发者有效应对高负载和突发流量的挑战。在实际应用中，合理利用Redisson的限流器技术，可以提高系统的稳定性、安全性和可用性，为用户提供更好的体验。

在这里插入图片描述

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

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

相关文章

Docker实战06｜深入剖析Docker Run命令

Docker实战06｜深入剖析Docker Run命令

前几篇文章中&#xff0c;重点讲解了Linux Namespace、Cgroups、AUFS的核心原理&#xff0c;同样也是Docker的底层原理实现。目录如下&#xff1a; • 《Docker实战01&#xff5c;容器与开发语言》 • 《Docker实战02&#xff5c;Namespace》 • 《Docker实战03&#xff5c;C…
阅读更多...
RPA与通知机器人的完美结合

RPA与通知机器人的完美结合

写在前面 在现代快节奏的工作环境中&#xff0c;我们经常会面临多个任务同时进行的情况&#xff0c;你还在为时间不够用、忙碌而惆怅吗&#xff1f;你还在为时刻盯着电脑流程而烦恼吗&#xff1f;你还在为及时收不到自己的自动化任务进度而焦躁吗&#xff1f;别担心&#xff0…
阅读更多...
6K star! 100%本地运行LLM的AI助手

6K star! 100%本地运行LLM的AI助手

AI套壳千千万万&#xff0c;你最喜欢哪一款&#xff1f;现在各种ChatGPT替代品层出不穷&#xff0c;但是大部分都是使用OpenAI的API&#xff0c;也就说离不开网络。 今天我们推荐的开源项目它就是要帮你100%在本地运行大模型&#xff0c;进而构建一个属于自己的ChatGPT&#x…
阅读更多...
直播岗位认知

直播岗位认知

一、直播平台特性与规则 作为直播岗位的一员&#xff0c;首先要了解所使用的直播平台的特性与规则。不同的平台有着不同的用户群体和特点&#xff0c;同时也有各自的运营规则和规范。熟悉平台的操作界面、功能特点、用户行为规范、广告和版权等方面的规定&#xff0c;对于保证…
阅读更多...
Vue Axios——前端技术栈

Vue Axios——前端技术栈

文章目录 基本介绍Vue是什么&#xff1f; MVVMVue的使用快速入门注意事项和使用细节 Vue 数据绑定机制分析数据单向渲染注意事项和细节 双向数据绑定事件绑定示例&#xff1a;注意事项和使用细节课后作业1课后作业2 修饰符示例 条件渲染/控制: v-if v-showv-if VS v-show课后作…
阅读更多...
[HTML]Web前端开发技术12（HTML5、CSS3、JavaScript ）——喵喵画网页

[HTML]Web前端开发技术12（HTML5、CSS3、JavaScript ）——喵喵画网页

希望你开心&#xff0c;希望你健康&#xff0c;希望你幸福&#xff0c;希望你点赞&#xff01; 最后的最后&#xff0c;关注喵&#xff0c;关注喵&#xff0c;关注喵&#xff0c;佬佬会看到更多有趣的博客哦&#xff01;&#xff01;&#xff01; 喵喵喵&#xff0c;你对我真的…
阅读更多...
ArcGIS Pro中怎么加载在线地图

ArcGIS Pro中怎么加载在线地图

当我们在制图的时候&#xff0c;有的时候需要加载在线地图&#xff0c;在ArcGIS Pro中加载在线地图的方式有很多&#xff0c;这里为大家介绍一下加载的方法&#xff0c;希望能对你有所帮助。 加载底图 在菜单栏上选择地图&#xff0c;点击底图&#xff0c;可以看到所有可加载…
阅读更多...
【PyQt小知识 - 7】：QLineEdit设置输入的文本以圆点或星号等方式显示

【PyQt小知识 - 7】：QLineEdit设置输入的文本以圆点或星号等方式显示

文章目录 setEchoMode setEchoMode 在PyQt中&#xff0c;QLineEdit是一种用于接收用户输入的小部件&#xff08;widget&#xff09;。setEchoMode是QLineEdit类中的一个方法&#xff0c;可以用于设置文本输入框中的文本显示模式。它接受一个参数来指定要使用的模式。 setEcho…
阅读更多...
「JavaSE」类和对象2

「JavaSE」类和对象2

&#x1f387;个人主页&#xff1a;Ice_Sugar_7 &#x1f387;所属专栏&#xff1a;快来卷Java啦 &#x1f387;欢迎点赞收藏加关注哦&#xff01; 类和对象2 &#x1f349;匿名对象&#x1f349;关键字static&#x1f34c;static修饰成员变量&#x1f34c;static修饰成员方法&…
阅读更多...
JavaScript switch case语句

JavaScript switch case语句

JS switch case 语句与 if else 语句的多分支结构类似&#xff0c;都可以根据不同的条件来执行不同的代码&#xff1b;但是与 if else 多分支结构相比&#xff0c;switch case 语句更加简洁和紧凑&#xff0c;执行效率更高。 JavaScript switch case 语句的语法格式如下&#…
阅读更多...
认识SpringBoot中的条件注解

认识SpringBoot中的条件注解

✅作者简介：大家好，我是Leo，热爱Java后端开发者，一个想要与大家共同进步的男人😉😉 🍎个人主页：Leo的博客 💞当前专栏： 循序渐进学SpringBoot ✨特色专栏： MySQL学习 🥭本文内容：认识SpringBoot中的条件注解 📚个人知识库： Leo知识库，欢迎大家访问 1.前…
阅读更多...
实人认证（人像三要素）API：加强用户身份验证

实人认证（人像三要素）API：加强用户身份验证

前言 在当今数字化时代&#xff0c;随着互联网应用的广泛普及&#xff0c;用户身份验证的重要性日益凸显。实人认证&#xff08;人像三要素&#xff09;API作为一种新型的身份验证方式&#xff0c;凭借其高效、安全和便捷的特性&#xff0c;正在成为加强用户身份验证的强大工具…
阅读更多...
微调您的Embedding模型以最大限度地提高RAG管道中的相关性检索

微调您的Embedding模型以最大限度地提高RAG管道中的相关性检索

英文原文地址&#xff1a;https://betterprogramming.pub/fine-tuning-your-embedding-model-to-maximize-relevance-retrieval-in-rag-pipeline-2ea3fa231149 微调您的Embedding模型以最大限度地提高RAG管道中的相关性检索 微调嵌入前后的 NVIDIA SEC 10-K 文件分析 2023 年…
阅读更多...
护眼灯有蓝光吗？防蓝光护眼台灯推荐

护眼灯有蓝光吗？防蓝光护眼台灯推荐

护眼台灯是家长为孩子购买的常见用品之一&#xff0c;但对于它的了解却不够深入&#xff0c;很多人购买之后反而容易出现眼睛疲劳、不适的情况&#xff01;据了解&#xff0c;主要的原因是因为在选择护眼台灯时&#xff0c;大多数人没有专业知识&#xff0c;没有买到合适的护眼…
阅读更多...
Web3与环保：区块链如何推动可持续发展

Web3与环保：区块链如何推动可持续发展

随着气候变化和环境问题日益严峻&#xff0c;社会对可持续发展的需求变得愈发迫切。在这个背景下&#xff0c;Web3技术和区块链崭露头角&#xff0c;成为推动可持续发展的关键力量。本文将深入探讨Web3技术如何与环保理念相结合&#xff0c;引领我们迈向更加可持续的未来。 1. …
阅读更多...
统计学习 复习（知识点+习题）

统计学习 复习（知识点+习题）

复习资料&#xff1a;https://github.com/RuijieZhu94/StatisticalLearning_USTC 第一章 线性回归 1. From one to two 最小二乘 课后题 有偏/无偏估计 加权最小二乘 2. Regularization 线性回归&#xff08;二维情况&#xff09; 求解有约束优化问题 正则化最小加权二乘…
阅读更多...
博客摘录「 性能优化：__builtin_expect详解」2024年1月15日

博客摘录「 性能优化：__builtin_expect详解」2024年1月15日

性能优化&#xff1a;__builtin_expect详解___builtin_expect对性能的影响-CSDN博客https://blog.csdn.net/chudongfang2015/article/details/75710848 #define LIKELY(x) __builtin_expect(!!(x), 1) __builtin_expect宏定义中为何写成!!(x)&#xff1f; 首先__buildin_expec…
阅读更多...
遥测终端机选择要点：功能、稳定性与成本的综合考量

遥测终端机选择要点：功能、稳定性与成本的综合考量

在当今的智能化时代&#xff0c;遥测终端机作为数据采集、传输和处理的关键设备&#xff0c;广泛应用于水利、气象、环保等领域。然而&#xff0c;面对市场上琳琅满目的遥测终端机产品&#xff0c;如何选择一款性能优良、稳定性高且成本合理的设备成为摆在用户面前的一大难题。…
阅读更多...
实战演练：利用XSS漏洞执行CSRF攻击

实战演练：利用XSS漏洞执行CSRF攻击

1. 选择目标站点 为了方便举例&#xff0c;这里我们选择portswigger默认搭建好的实验室环境。 PS&#xff1a;其他站点类似操作即可。 1.1 实验环境介绍 该实验室在博客评论功能中包含存储的XSS漏洞。要解决实验室问题&#xff0c;可利用该漏洞执行CSRF攻击&#xff0c;并更…
阅读更多...
项目乱、管控难？低代码CRM+助力广告行业数字化运营

项目乱、管控难？低代码CRM+助力广告行业数字化运营

广告行业涉及的是多环节、多角色、把控难的复杂项目&#xff0c;传统的广告行业普遍存在客户资源分散、项目协同难、账目不清晰、数据信息滞后等问题。 基于广告行业场景痛点&#xff0c;道一云结合七巧低代码开发平台&#xff0c;打造了广告行业CRM解决方案&#xff0c;围绕销…
阅读更多...
最新文章

Copyright @ 2022~2023