《Python Web网站部署应知应会》No4:基于Flask的调用AI大模型的高性能博客网站的设计思路和实战(上)

news2025/3/31 21:34:02

基于Flask的调用AI大模型的高性能博客网站的设计思路和实战(上)

摘要

本文详细探讨了一个基于Flask框架的高性能博客系统的设计与实现,该系统集成了本地AI大模型生成内容的功能。我们重点关注如何在高并发、高负载状态下保持系统的高性能和稳定性.用代码写一个网站现在越来越容易,但是要让网站在实际场景中保持稳定和高性能,尤其在大模型AI接口调用高并发背景下,真的需要一定的技术。文章详细介绍了多层次缓存策略、异步处理机制、请求批处理技术以及全面的性能监控系统的实现。通过多种性能测试工具的实战应用,包括负载测试、缓存性能测试和并发性能测试,我们不仅验证了系统的性能表现,还收集了关键数据指导持续优化。文章同时分享了在开发过程中遇到的各种挑战及解决方案,为类似系统的开发提供了实用的参考。

项目背景

随着内容创作需求的爆发性增长,AI辅助写作成为一种趋势。我们开发的这个Flask博客系统不仅支持传统的内容发布功能,还集成了本地部署的Ollama大模型,提供内容生成服务。然而,AI模型推理往往需要大量计算资源,容易成为系统的性能瓶颈,特别是在面对大量并发请求时。

系统的核心需求包括:

  • 支持用户注册、登录、权限管理
  • 博客内容的创建、编辑、发布和阅读
  • 基于本地Ollama模型的AI内容生成(使用智谱 GLM4-9B模型)
  • 在高并发(100+用户同时访问)情况下保持良好响应性
  • 实时监控系统健康状态和性能指标

这些需求促使我们思考如何在Flask这样的轻量级框架上,构建一个能够支撑高并发访问、处理计算密集型任务的高性能系统。

网站截图

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Flask博客网站核心文件结构说明

flask_blog/
│
├── app/                           # 应用主目录
│   ├── __init__.py                # 应用初始化,创建Flask实例和配置
│   ├── models.py                  # 数据库模型定义(用户、博客文章等)
│   ├── routes.py                  # 路由和视图函数定义
│   ├── forms.py                   # Web表单定义(登录、注册、发布博客等)
│   ├── ai_service.py              # AI内容生成服务接口
│   ├── cache.py                   # 缓存管理实现
│   ├── auth.py                    # 用户认证和授权
│   ├── static/                    # 静态文件目录
│   │   ├── css/                   # CSS样式文件
│   │   │   └── style.css          # 主样式表
│   │   ├── js/                    # JavaScript文件
│   │   │   └── main.js            # 主JS文件
│   │   └── images/                # 图片资源
│   └── templates/                 # HTML模板
│       ├── base.html              # 基础布局模板
│       ├── index.html             # 首页模板
│       ├── login.html             # 登录页面
│       ├── register.html          # 注册页面
│       ├── post.html              # 博客文章详情页
│       ├── create_post.html       # 创建博客页面
│       └── profile.html           # 用户资料页面
│
├── instance/                      # 实例配置目录(包含本地配置和数据库)
│   └── blog.db                    # SQLite数据库文件
│
├── config.py                      # 应用配置类定义
├── reset_db.py                    # 数据库重置和初始化脚本
├── requirements.txt               # 项目依赖包列表
└── README.md                      # 项目说明文档

文件/文件夹说明

核心应用文件

  • app/init.py: 应用工厂函数,创建和配置Flask应用实例,初始化扩展(如Flask-SQLAlchemy、Flask-Login)。主要功能包括数据库连接配置、登录管理器设置、蓝图注册等。

  • app/models.py: 定义数据库模型,包括User(用户)和Post(博客文章)等实体。User模型包含用户名、密码哈希、电子邮件等字段,Post模型包含标题、内容、创建时间和作者外键等字段。

  • app/routes.py: 定义所有路由和视图函数,处理Web请求。包括首页、登录、注册、博客详情、创建/编辑博客、用户个人资料等路由,以及AI内容生成接口。

  • app/forms.py: 使用Flask-WTF定义表单类,用于处理用户输入验证。包括登录表单、注册表单、博客发布表单以及AI内容生成表单等。

  • app/ai_service.py: 与Ollama模型交互,处理AI内容生成请求。封装了与本地AI模型通信的接口,处理请求参数和流式响应生成。

  • app/cache.py: 实现多层缓存策略,管理内存缓存和Redis缓存。定义缓存键生成、设置缓存内容和过期时间、获取缓存内容等功能,优化高频请求性能。

  • app/auth.py: 处理用户认证和授权,实现登录、注册和会话管理。包括密码哈希处理、用户验证、权限检查等功能。

静态文件和模板

  • app/static/css/style.css: 主要样式表,定义网站的视觉外观和布局。

  • app/static/js/main.js: 主要JavaScript文件,处理客户端交互和动态内容。

  • app/static/images/: 存放网站使用的图标、背景图和其他图像资源。

  • app/templates/base.html: 基础模板,定义网站的公共结构,包括导航栏、页脚等,其他模板继承自它。

  • app/templates/index.html: 首页模板,展示博客文章列表。

  • app/templates/login.html: 用户登录页面模板。

  • app/templates/register.html: 用户注册页面模板。

  • app/templates/post.html: 博客文章详情页模板,显示完整文章内容和评论。

  • app/templates/create_post.html: 创建和编辑博客文章的页面模板。

  • app/templates/profile.html: 用户个人资料页面模板,显示用户信息和发布的文章。

实例配置和数据

  • instance/blog.db: SQLite数据库文件,存储所有应用数据,包括用户账户、博客文章和相关内容。

根目录文件

  • config.py: 应用配置类,定义开发、测试和生产环境的不同配置参数,如数据库URI、密钥等。

  • reset_db.py: 重置数据库并创建测试数据的脚本,方便开发和测试过程重新初始化环境。

  • requirements.txt: 项目Python依赖列表,包含所有必需的包及其版本,如Flask、Flask-SQLAlchemy、Flask-Login等。

  • README.md: 项目说明文档,包含安装步骤、使用方法、功能描述等信息。

文件结构采用了Flask官方推荐的应用工厂模式,将功能模块化组织,便于理解和维护。项目使用SQLite作为开发数据库,可以在不需要额外服务的情况下快速启动和测试应用。

核心概念和知识点

1. 高性能Web应用架构设计原则

在设计高性能Web应用时,我们遵循以下原则:

  • 关注点分离:将不同功能模块解耦,使系统更易于扩展和维护
  • 分层缓存:在多个层级实施缓存策略,减少重复计算和数据库访问
  • 异步处理:将计算密集型任务异步化,避免阻塞主线程
  • 批处理技术:合并同类请求,减少资源争用和上下文切换
  • 实时监控:持续监测系统性能,及时发现并解决问题

2. Flask应用的性能优化技术

Flask作为一个轻量级框架,需要结合多种技术来提升其性能:

  • 应用工厂模式:便于配置管理和测试
  • 蓝图组织代码:模块化应用结构
  • WSGI服务器:使用Gunicorn/uWSGI替代Flask内置服务器
  • 数据库优化:合理设计索引、使用连接池
  • 代码优化:减少不必要的计算和SQL查询

3. AI模型集成与性能优化

集成AI大模型时的主要挑战是处理其高计算需求:

  • 流式响应:逐步返回AI生成内容,提升用户体验
  • 推理优化:调整模型参数和批处理大小,平衡速度和质量
  • 模型量化:降低模型精度以提高推理速度
  • 计算资源管理:合理分配CPU/GPU资源

4. 高并发处理策略

处理高并发请求的核心策略:

  • 连接池管理:有效复用数据库连接
  • 请求限流:防止系统过载
  • 队列机制:平滑处理请求峰值
  • 负载均衡:分散请求到多个工作进程

技术实战和代码

1. 多层次缓存策略实现

我们实现了三层缓存策略,显著提升了系统响应速度:

# 内存缓存层
memory_cache = {}

# Redis缓存层
def get_from_cache(key):
    # 先尝试从内存缓存获取
    if key in memory_cache:
        CACHE_HIT.inc()  # Prometheus指标
        return memory_cache[key]
    
    # 再尝试从Redis缓存获取
    cached_data = redis_client.get(key)
    if cached_data:
        # 同时更新内存缓存
        memory_cache[key] = cached_data
        CACHE_HIT.inc()
        return cached_data
    
    CACHE_MISS.inc()
    return None

# 数据库查询缓存装饰器
def cache_query(ttl=3600):
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            # 生成缓存键
            key = f"query_{f.__name__}_{str(args)}_{str(kwargs)}"
            result = get_from_cache(key)
            
            if result is None:
                # 缓存未命中,执行查询
                start = time.time()
                result = f(*args, **kwargs)
                query_time = time.time() - start
                DB_QUERY_TIME.observe(query_time)  # 记录查询时间
                
                # 存入缓存
                set_in_cache(key, result, ttl)
            
            return result
        return decorated_function
    return decorator

2. AI生成内容的流式响应实现

为提高用户体验,我们实现了AI内容的流式响应:

@app.route('/generate-blog', methods=['POST'])
def generate_blog():
    title = request.form.get('title')
    
    # 检查缓存
    cache_key = f"blog_gen_{title}"
    cached_result = get_from_cache(cache_key)
    if cached_result:
        return cached_result
    
    # 未命中缓存,调用AI模型
    def generate():
        start_time = time.time()
        INFERENCE_COUNT.inc()  # 增加推理计数
        
        prompt = f"写一篇关于'{title}'的博客文章,包含引言、主体和总结。"
        
        # 流式生成内容
        for chunk in ollama_client.generate(prompt=prompt, model="llama2"):
            yield chunk
            
        # 记录生成时间
        generation_time = time.time() - start_time
        AI_GENERATION_TIME.observe(generation_time)
        
        # 异步保存到缓存(完整内容需在流式传输后组装)
        # 此处使用线程避免阻塞响应
        threading.Thread(
            target=lambda: save_complete_content_to_cache(title, complete_content)
        ).start()
    
    return Response(generate(), mimetype='text/plain')

3. 异步任务处理与请求批处理

对于计算密集型任务,我们使用异步队列和批处理技术:

# 使用Redis作为任务队列
task_queue = redis_client.StrictRedis(host='localhost', port=6379, db=1)

# 提交生成任务
def submit_generation_task(title, callback_url):
    task_id = str(uuid.uuid4())
    task_data = {
        'task_id': task_id,
        'title': title,
        'callback_url': callback_url,
        'status': 'pending',
        'timestamp': time.time()
    }
    task_queue.lpush('generation_tasks', json.dumps(task_data))
    return task_id

# 批处理worker
def batch_processing_worker():
    while True:
        # 收集短时间内积累的任务
        tasks = []
        start_time = time.time()
        
        # 批量收集任务,最多等待100ms
        while time.time() - start_time < 0.1 and len(tasks) < 10:
            task_data = task_queue.rpop('generation_tasks')
            if task_data:
                tasks.append(json.loads(task_data))
            else:
                time.sleep(0.01)
        
        if not tasks:
            time.sleep(0.1)
            continue
            
        # 批量处理任务
        batch_process_tasks(tasks)

4. 性能监控系统集成

我们使用Prometheus和Grafana构建了全面的监控系统:

from prometheus_client import Counter, Histogram, Gauge, Summary, start_http_server

# 指标定义
REQUEST_COUNT = Counter("request_count", "Total number of requests", ["status"])
REQUEST_LATENCY = Histogram("request_latency_seconds", "Request latency in seconds")
INFERENCE_COUNT = Counter("inference_count", "Total number of AI inferences")
CACHE_HIT = Counter("cache_hit_count", "Cache hits")
CACHE_MISS = Counter("cache_miss_count", "Cache misses")
ACTIVE_USERS = Gauge("active_users", "Number of active users")
DB_QUERY_TIME = Summary("db_query_seconds", "Database query time")
BLOG_CREATE_COUNT = Counter("blog_create_count", "Blog creation count")
AI_GENERATION_TIME = Histogram("ai_generation_seconds", 
                              "AI content generation time",
                              buckets=[0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0])

def init_metrics(app):
    @app.before_request
    def before_request():
        request.start_time = time.time()

    @app.after_request
    def after_request(response):
        process_time = time.time() - request.start_time
        status = "success" if response.status_code < 400 else "failure"
        REQUEST_COUNT.labels(status=status).inc()
        REQUEST_LATENCY.observe(process_time)
        return response
    
    # 启动指标服务器
    start_http_server(8001)

5. 并发性能测试工具

我们开发了专门的并发测试工具,评估系统在不同并发级别下的表现:

class ConcurrencyTester:
    """并发性能测试工具"""
    
    def __init__(self, base_url="http://127.0.0.1:5000"):
        self.base_url = base_url
        self.concurrency_levels = [1, 5, 10, 20, 50, 100]
        self.results = {}
        self.endpoints = [
            {"name": "首页", "url": "/", "method": "get", "data": None},
            {"name": "博客详情", "url": "/post/1", "method": "get", "data": None},
            {"name": "AI生成", "url": "/generate-blog", "method": "post", 
             "data": lambda i: {"title": f"并发测试博客 {i}"}}
        ]
    
    async def run_test(self, endpoint, concurrency):
        """运行特定端点和并发级别的测试"""
        async with aiohttp.ClientSession() as session:
            tasks = []
            for i in range(concurrency):
                tasks.append(self.make_request(session, endpoint, i))
            
            durations = await asyncio.gather(*tasks)
            # 过滤出非None值
            durations = [d for d in durations if d is not None]
            return durations
            
    async def test_all_levels(self):
        """测试所有端点在所有并发级别下的性能"""
        for endpoint in self.endpoints:
            endpoint_name = endpoint["name"]
            self.results[endpoint_name] = {}
            
            for level in self.concurrency_levels:
                durations = await self.run_test(endpoint, level)
                
                if durations:
                    self.results[endpoint_name][level] = {
                        "avg": np.mean(durations),
                        "median": np.median(durations),
                        "max": np.max(durations),
                        "min": np.min(durations),
                        "p95": np.percentile(durations, 95),
                        "throughput": level / np.sum(durations),
                        "error_rate": (level - len(durations)) / level
                    }
                else:
                    print("    所有请求均失败")

疑难点与解决方案

1. AI模型推理延迟问题

问题:AI内容生成的平均响应时间达到3秒以上,严重影响用户体验。

解决方案

  1. 实现流式响应,使用户能立即看到部分输出
  2. 调整模型参数,减少tokens生成总量
  3. 对常见主题预先生成内容并缓存
  4. 实现模型量化,用精度换取速度

优化后的代码:

def generate_blog_content(title):
    # 检查是否是热门主题,优先使用模板
    template = get_template_for_topic(extract_topic(title))
    if template:
        # 使用模板+少量自定义替换热门主题请求
        return customize_template(template, title)
    
    # 调整生成参数,限制tokens
    params = {
        "model": "llama2-7b-chat-q4",  # 量化版模型
        "prompt": f"写一篇关于'{title}'的简短博客...",
        "max_tokens": 800,  # 限制生成长度
        "temperature": 0.7  # 调整创造性
    }
    
    # 流式响应
    return stream_generate(params)

2. 缓存一致性问题

问题:多层缓存导致数据不一致,用户看到过期内容。

解决方案

  1. 实现缓存失效传播机制
  2. 使用版本号标记缓存内容
  3. 为不同类型内容设置合理的TTL策略

缓存管理核心代码:

def invalidate_cache(key_pattern):
    """使某一类缓存失效"""
    # 找到所有匹配的键
    matched_keys = redis_client.keys(key_pattern)
    
    # 清除Redis缓存
    if matched_keys:
        redis_client.delete(*matched_keys)
    
    # 清除内存缓存
    for k in list(memory_cache.keys()):
        if re.match(key_pattern, k):
            del memory_cache[k]
            
    # 发布缓存失效消息,通知其他服务器节点
    redis_client.publish('cache_invalidation', key_pattern)

3. 数据库连接池耗尽

问题:高并发下数据库连接池被耗尽,导致服务不可用。

解决方案

  1. 优化连接池配置,增加最大连接数
  2. 减少长连接占用时间
  3. 实现连接租用超时和健康检查
  4. 增加慢查询监控

连接池优化代码:

# 数据库连接池配置
app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
    'pool_size': 30,               # 连接池大小
    'max_overflow': 15,            # 最大允许溢出连接数
    'pool_timeout': 30,            # 等待获取连接的超时时间
    'pool_recycle': 1800,          # 连接回收时间
    'pool_pre_ping': True          # 使用前ping测试连接健康
}

# 监控数据库连接使用情况
@app.after_request
def track_db_connections(response):
    conn_info = db.engine.pool.status()
    POOL_USED_CONNECTIONS.set(conn_info['used'])
    POOL_AVAILABLE_CONNECTIONS.set(conn_info['available'])
    return response

4. 内存泄漏问题

问题:长时间运行后,内存占用持续增加,最终导致OOM。

解决方案

  1. 使用内存分析工具(如memory-profiler)找出泄漏点
  2. 优化内存缓存管理,实现LRU淘汰策略
  3. 定期清理不使用的资源
  4. 增加内存使用监控

内存管理代码:

class LRUCache:
    """有大小限制的LRU缓存实现"""
    def __init__(self, capacity=1000):
        self.cache = OrderedDict()
        self.capacity = capacity
    
    def get(self, key):
        if key not in self.cache:
            return None
        # 将访问的元素移至末尾,表示最近使用
        self.cache.move_to_end(key)
        return self.cache[key]
    
    def put(self, key, value):
        if key in self.cache:
            # 更新现有键值
            self.cache.move_to_end(key)
        elif len(self.cache) >= self.capacity:
            # 移除最不常用的元素
            self.cache.popitem(last=False)
        self.cache[key] = value

# 替换全局内存缓存
memory_cache = LRUCache(capacity=10000)

# 定期清理任务
def cleanup_resources():
    while True:
        try:
            gc.collect()  # 触发垃圾回收
            # 记录当前内存使用情况
            MEMORY_USAGE.set(get_process_memory_info())
            time.sleep(300)  # 每5分钟执行一次
        except Exception as e:
            print(f"清理任务出错: {e}")

性能优化成果

通过综合应用上述技术和策略,我们在系统性能上取得了显著成果:

  1. 响应时间

    • 普通页面请求从平均250ms降至50ms
    • AI生成内容从3.5秒降至平均1.2秒(感知延迟降至0.3秒)
  2. 吞吐量

    • 系统每秒峰值请求处理能力从50提升至280
    • AI生成接口并发处理能力从10提升至50
  3. 缓存效率

    • 缓存命中率从最初的40%提升至85%
    • 数据库查询减少了65%
  4. 系统稳定性

    • 能够稳定处理100+用户的持续访问
    • 错误率从峰值5%降至0.2%以下
    • 内存使用趋于稳定,不再出现泄漏问题

总结和扩展思考

通过这个项目,我们成功构建了一个既具备传统内容管理功能,又能提供AI生成服务的高性能博客系统。这种结合传统Web应用和AI技术的系统代表了当前应用开发的一个重要趋势。

关键经验总结

  1. 分层设计的重要性:清晰的层次结构让优化工作更有针对性
  2. 监控先行:完善的监控系统是发现问题和评估优化效果的基础
  3. 多层缓存的效果显著:不同层次的缓存共同作用,极大提升了系统性能
  4. 用户体验优先:流式响应虽然没有减少总处理时间,但大幅提升了用户体验
  5. 性能测试的系统化:建立全面的测试体系,能持续指导优化方向

未来扩展方向

  1. 微服务化:将AI处理拆分为独立服务,实现更好的扩展性

    +--------------+      +------------------+      +-------------+
    |  Flask Web   | <--> |  API Gateway    | <--> | AI Service   |
    |  Application |      |  Load Balancer  |      | (Scalable)   |
    +--------------+      +------------------+      +-------------+
    
  2. 混合部署模式:根据需求灵活选择本地或云端AI模型

    def select_ai_model(request_params):
        """根据请求复杂度选择本地或云端模型"""
        if is_complex_request(request_params):
            return cloud_ai_client
        return local_ai_client
    
  3. 个性化缓存策略:基于用户行为分析的智能缓存预热

    def preload_cache_for_trending_topics():
        """预先生成热门话题的内容并缓存"""
        trending_topics = analyze_trending_topics()
        for topic in trending_topics:
            submit_generation_task(topic, cache_only=True)
    
  4. 边缘计算:将部分计算和缓存下沉到更接近用户的节点

    +-------------+     +---------------+     +--------------+
    | User Device | --> | Edge Node     | --> | Central      |
    | (Browser)   |     | (Cache+Basic  |     | Application  |
    +-------------+     |  Processing)  |     +--------------+
                        +---------------+
    

适用场景与价值

这种高性能博客系统架构特别适用于以下场景:

  1. 内容创作平台:需要AI辅助内容生成的创作系统
  2. 教育平台:需要生成教学内容和示例的教育网站
  3. 企业知识库:需要智能搜索和内容推荐的知识管理系统
  4. 媒体网站:需要快速内容生成和发布的新闻媒体平台

最后,高性能Web应用的开发是一个持续迭代的过程。通过科学的测量、分析和优化循环,我们能够不断提升系统性能,为用户提供更好的体验。本项目中使用的技术和方法,可以作为其他融合AI功能的Web应用的参考模型。

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

STM32_HAL开发环境搭建【Keil(MDK-ARM)、STM32F1xx_DFP、 ST-Link、STM32CubeMX】

安装Keil(MDK-ARM)【集成开发环境IDE】 我们会在Keil(MDK-ARM)上去编写代码、编译代码、烧写代码、调试代码。 Keil(MDK-ARM)的安装方法&#xff1a; 教学视频的第02分03秒开始看。 安装过程中请修改一下下面两个路径&#xff0c;避免占用C盘空间。 Core就是Keil(MDK-ARM)的…

多线程—JUC(java.util.concurrent)

上篇文章&#xff1a; 多线程—synchronized原理https://blog.csdn.net/sniper_fandc/article/details/146713129?fromshareblogdetail&sharetypeblogdetail&sharerId146713129&sharereferPC&sharesourcesniper_fandc&sharefromfrom_link 目录 1 Calla…

从零开始跑通3DGS教程:(三)坐标系与尺度编辑(CloudCompare)

写在前面 本文内容 本文所属《从零开始跑通3DGS教程》系列文章&#xff1b; sfm重建的点云已经丢掉了尺度信息&#xff0c;并且坐标系跟图像数据有关(SFM初始化选择的图像)&#xff0c;所以如果想恢复物理真实尺度&#xff0c;以及在想要的视角下渲染&#xff0c;那么需要对尺度…

多线程 - 线程安全引入

写一个代码&#xff0c;让主线程创建一个新的线程&#xff0c;由新的线程负责完成一系列的运算&#xff08;比如&#xff1a;1 2 3 ... 1000&#xff09;&#xff0c;再由主线程负责获取到最终结果。 但打印结果为 result 0&#xff0c;略微思考&#xff0c;明白了要让 t 线…

【面试八股】:CAS指令

一、CAS 面试题 1. 说说CAS、CAS有什么问题&#xff08;ABA)?(美团一面&#xff09; Compare And Swap 对比交换&#xff08;原子指令&#xff09; CAS是 CPU指令 操作系统原生 API&#xff0c;JVM对它进行了封装&#xff08;C)&#xff0c;供我们使用。 通过判断 内存 和 …

el-radio-group 中 el-radio-button value未能绑定上数值数据

这样绑定到admin后不会随着admin的值显示 在value加上 : 后成功显示

JSP(实验):带验证码的用户登录

[实验目的] 1&#xff0e;掌握应用request对象获取表单提交的数据。 2&#xff0e;掌握解决获取表单提交数据产生中文乱码的问题。 3&#xff0e;掌握使用response对象进行定时跳转功能。 4&#xff0e;掌握使用session对象完成登录和注销功能。 [实验要求] 设计带验证码…

集多功能为一体的软件,支持批量操作。

今天我给大家分享一个超实用的小工具&#xff0c;真的是太好用了&#xff01;这个软件是吾爱大神无知灰灰制作的&#xff0c;它能直接一键把webp格式的图片转换成png格式。 webp转为png 一键操作&#xff0c;支持压缩 其实&#xff0c;作者最近在工作中经常遇到webp格式的图片…

linux压缩指令

今天我们来了解一下linux压缩指令,压缩是我们文件传输的一种重要手段,对此,我们是必须学习压缩指令的,那么话不多说,来看. 1.grep过滤查找&#xff0c;管道符&#xff0c;“&#xff5c;”&#xff0c;表示将前一个命令的处理结果输出传递给后面的命令处理。 基本语法&#x…

污水处理厂人员定位方案-UWB免布线高精度定位

1. 方案概述 本方案采用免布线UWB基站与北斗卫星定位融合技术&#xff0c;结合UWBGNSS双模定位工卡&#xff0c;实现污水处理厂室内外人员高精度定位&#xff08;亚米级&#xff09;。系统通过低功耗4G传输数据&#xff0c;支持实时位置监控、电子围栏、聚集预警、轨迹回放等功…

Elasticsearch 高级

Elasticsearch 高级 建议阅读顺序&#xff1a; Elasticsearch 入门Elasticsearch 搜索Elasticsearch 搜索高级Elasticsearch高级&#xff08;本文&#xff09; 1. nested 类型 1.1 介绍 Elasticsearch 中的 nested 类型允许你在文档内存储复杂的数据结构&#xff0c;比如一个…

C语言笔记数据结构(链表)

希望文章能对你有所帮助&#xff0c;有不足的地方请在评论区留言指正,一起交流学习! 目录 1.链表 1.1 链表概念和组成 1.2 链表的分类 1.3 顺序表和链表 2.单链表&#xff08;无头单向不循环链表&#xff09; 2.1 结点的创建 2.2 创建新的结点 2.3 单链表的打印 2.4 尾…

Leetcode 两数相除

✅ LeetCode 29. 两数相除 — 思路总览 &#x1f9e9; 题目要求 给定两个整数 dividend 和 divisor&#xff0c;实现 整数除法&#xff0c;不能使用乘法 *、除法 / 和取余 % 运算符。 要求返回的结果应为 向零截断的整数商&#xff0c;即&#xff1a; 正数向下取整&#xf…

人工智能图像识别Scala介绍

Scala 一.Scala 简介 Scala即Scalable Language&#xff08;可伸缩的语言&#xff09;&#xff0c;Scala 语言是由 Martin Odersky 等人在 2003 年开发的&#xff0c;并于 2004 年首次发布。意味着这种语言设计上支持大规模软件开发&#xff0c;是一门多范式的编程语言。 Sc…

C++中使用CopyFromRecordset将记录集拷贝到excel中时,如果记录集为0个,函数崩溃,是什么原因

文章目录 原因分析解决方案1. 检查记录集是否为空2. 安全调用COM方法3.进行异常捕获4. 替代方案&#xff1a;手动处理空数据 总结 在C中使用CopyFromRecordset将空记录集&#xff08;0条记录&#xff09;复制到Excel时崩溃的原因及解决方法如下&#xff1a; 原因分析 空记录集…

c#的.Net Framework 的console 项目找不到System.Window.Forms 引用

首先确保是建立的.Net Framework 的console 项目,然后天健reference 应用找不到System.Windows.Forms 引用 打开对应的csproj 文件 在第一个PropertyGroup下添加 <UseWindowsForms>true</UseWindowsForms> 然后在第一个ItemGroup 下添加 <Reference Incl…

蓝桥杯嵌入式学习笔记

用博客来记录一下参加蓝桥杯嵌入式第十六届省赛的学习经历 工具环境准备cubemx配置外部高速时钟使能设置串口时钟配置项目配置 keil配置烧录方式注意代码规范头文件配置 模块ledcubemx配置keil代码实现点亮一只灯实现具体操作的灯&#xff0c;以及点亮还是熄灭 按键cubemx配置k…

Blender多摄像机怎么指定相机渲染图像

如题目所说&#xff0c;当blender的场景里面有摄像机的时候&#xff0c;按F12可以预览渲染结果&#xff0c;但是当有多个摄像机的时候就不知道使用哪个进行渲染了。 之前在网上没有找到方法&#xff0c;就用笨方法&#xff0c;把所有的摄像机删除&#xff0c;然后设置自己需要…

从 MySQL 到时序数据库 TDengine:Zendure 如何实现高效储能数据管理?

小T导读&#xff1a;TDengine 助力广州疆海科技有限公司高效完成储能业务的数据分析任务&#xff0c;轻松应对海量功率、电能及输入输出数据的实时统计与分析&#xff0c;并以接近 1 : 20 的数据文件压缩率大幅降低存储成本。此外&#xff0c;taosX 强大的 transform 功能帮助用…

观察者模式:解耦对象间的依赖关系

观察者模式&#xff1a;解耦对象间的依赖关系 JDK 中曾直接提供对观察者模式的支持&#xff0c;但因其设计局限性&#xff0c;现已被标记为“过时”&#xff08;Deprecated&#xff09;。不过&#xff0c;观察者模式的思想在 JDK 的事件处理、spring框架等仍有广泛应用。下面我…