系统工具的插件架构:用动态加载实现用户自定义扩展的 Rust 方案

Flutter与Rust结合构建跨平台SSH管理工具:从架构到实现 在跨平台桌面应用开发中,FFI(外部函数接口)是实现高性能原生代码调用的关键技术,它允许Dart等高级语言直接与C/C++/Rust等系统级语言交互,从而突破语言生态限制。其核心原理是通过定义清晰的函数签名和内存布局,在运行时动态加载原生库,实现近乎零开销的跨语言调用。这种技术价值在于能够将Flutter高效的UI构建能力与Rust的内存安全、高性能计算优势相结合,特别适用于需要处理底层系统操作、复杂网络协议或对性能有极致要求的场景,例如SSH客户端、音视频处理引擎或加密工具的开发。本文以构建一个类似Pol 阅读详情

系统工具的插件架构:用动态加载实现用户自定义扩展的 Rust 方案

系统工具最尴尬的死法,就是"功能写死了"。用户想要一个自定义的日志格式解析器?对不起,代码里不支持。用户需要一个数据库连接池的个性化监控?抱歉,下次发版再说。作为自学出身的工具开发者,我深刻体会过一个真理:好的工具不是功能多,而是扩展性强。

Rust 在插件架构方面有几种截然不同的技术路线:编译期插件(通过 trait + feature gate)、动态链接库(libloading)、脚本语言内嵌(嵌入 Rhai/Lua)、以及 WebAssembly 插件。每种方案有各自的代价和适用场景。本文逐一拆解并在最后给出一个可运行的动态加载插件系统完整实现。

一、插件架构的四种技术路线对比与选型矩阵

根据我的经验:

  • 小型内部工具 → 编译期插件足够,也最简单
  • 桌面应用程序 → libloading 动态库,让插件作者用 Rust 写扩展
  • 需要用户自定义脚本 → Rhai 内嵌,非程序员也能写
  • 多语言生态/安全隔离要求高 → Wasm 插件

二、动态加载方案的完整实现:基于 libloading 的插件系统

我们来实现一个日志分析工具的插件系统。用户可以编写符合接口约定的 .so/.dll/.dylib 插件,在主程序运行时动态加载。

2.1 插件接口定义(共享 crate)

首先,主程序和插件需要共享同一个 trait 定义。通常我们把它放在一个独立的 plugin-interface crate 中:

// =========================================================================
// plugin-interface/src/lib.rs —— 插件接口 crate(主程序和插件都依赖它)
// =========================================================================

/// 日志解析插件必须实现的 trait
/// 注意:所有方法都使用 C ABI 兼容的类型,避免跨 FFI 边界时的布局不一致
pub trait LogPlugin: Send + Sync {
    /// 返回插件的名字(用于识别和调试)
    fn name(&self) -> &str;

    /// 返回插件支持的日志格式,如 "json", "csv", "apache_access"
    fn supported_format(&self) -> &str;

    /// 解析一行日志,返回结构化的字段
    fn parse_line(&self, raw_line: &str) -> Result<ParsedLog, ParseError>;

    /// 插件初始化(加载后调用一次)
    fn init(&mut self) -> Result<(), String> {
        Ok(())  // 默认什么都不做
    }

    /// 插件清理(卸载前调用一次)
    fn shutdown(&mut self) {
        // 默认什么都不做
    }
}

/// 解析后的日志结构
#[derive(Debug, Clone)]
pub struct ParsedLog {
    /// 日志时间戳(ISO 8601 格式)
    pub timestamp: String,
    /// 日志级别
    pub level: String,
    /// 日志消息体
    pub message: String,
    /// 附加字段(格式相关的元信息)
    pub extra: Vec<(String, String)>,
}

/// 日志解析错误
#[derive(Debug)]
pub enum ParseError {
    /// 日志格式与插件不匹配
    FormatMismatch(String),
    /// 行内数据损坏
    CorruptedLine(String),
    /// 内部错误
    Internal(String),
}

/// 插件元信息结构——用于插件管理器发现和注册
pub struct PluginMeta {
    /// 插件在文件系统中的路径
    pub path: String,
    /// 插件名称
    pub name: String,
    /// 支持的格式
    pub format: String,
}

2.2 插件实现示例(单独编译为动态库)

// =========================================================================
// 一个用户编写的 JSON 日志解析插件
// 编译命令: cargo build --release --lib (输出 .so/.dll/.dylib)
// =========================================================================

use plugin_interface::{LogPlugin, ParsedLog, ParseError};
use serde_json::Value;

/// JSON 日志解析器插件
pub struct JsonLogPlugin;

impl LogPlugin for JsonLogPlugin {
    fn name(&self) -> &str {
        "JSON 日志解析器 v1.0"
    }

    fn supported_format(&self) -> &str {
        "json"
    }

    fn parse_line(&self, raw_line: &str) -> Result<ParsedLog, ParseError> {
        // 解析 JSON 日志行
        let value: Value = serde_json::from_str(raw_line).map_err(|e| {
            ParseError::FormatMismatch(format!("JSON 解析失败: {}", e))
        })?;

        let timestamp = value["timestamp"]
            .as_str()
            .unwrap_or("1970-01-01T00:00:00Z")
            .to_string();

        let level = value["level"]
            .as_str()
            .unwrap_or("INFO")
            .to_string();

        let message = value["message"]
            .as_str()
            .unwrap_or(raw_line)
            .to_string();

        // 收集额外的元字段
        let mut extra = Vec::new();
        if let Some(obj) = value.as_object() {
            for (key, val) in obj {
                if key != "timestamp" && key != "level" && key != "message" {
                    extra.push((key.clone(), val.to_string()));
                }
            }
        }

        Ok(ParsedLog {
            timestamp,
            level,
            message,
            extra,
        })
    }
}

// =========================================================================
// C ABI 导出函数:插件管理器通过这两个符号加载和卸载插件
// =========================================================================

/// 创建插件实例——必须通过 C ABI 导出,主程序通过符号名查找
#[no_mangle]
pub extern "C" fn _plugin_create() -> *mut dyn LogPlugin {
    let plugin = JsonLogPlugin;
    // 将 trait object 转换为原始指针,转移所有权给主程序
    let boxed: Box<dyn LogPlugin> = Box::new(plugin);
    Box::into_raw(boxed)
}

/// 销毁插件实例——释放内存
#[no_mangle]
pub extern "C" fn _plugin_destroy(plugin_ptr: *mut dyn LogPlugin) {
    if !plugin_ptr.is_null() {
        unsafe {
            let _ = Box::from_raw(plugin_ptr); // 重新获得所有权并 drop
        }
    }
}

2.3 主程序的插件管理器

// =========================================================================
// 主程序中的插件管理器:负责发现、加载、调用和卸载插件
// =========================================================================

use libloading::{Library, Symbol};
use plugin_interface::{LogPlugin, ParsedLog, ParseError, PluginMeta};
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};

/// 已加载的插件实例——包含动态库句柄和插件 trait object 指针
struct LoadedPlugin {
    /// 动态链接库句柄(必须在插件 trait object 之前 drop)
    _library: Library,
    /// 插件实例的裸指针(通过 C ABI 获取)
    plugin_ptr: *mut dyn LogPlugin,
}

/// 插件管理器:负责动态加载和管理所有第三方插件
pub struct PluginManager {
    /// 插件扫描目录
    plugin_dir: PathBuf,
    /// 已加载的插件映射:插件名 → 插件实例
    plugins: HashMap<String, LoadedPlugin>,
}

impl PluginManager {
    /// 创建插件管理器并指定插件所在的目录
    pub fn new(plugin_dir: &str) -> Self {
        PluginManager {
            plugin_dir: PathBuf::from(plugin_dir),
            plugins: HashMap::new(),
        }
    }

    /// 扫描插件目录并加载所有符合约定的动态库
    pub fn scan_and_load(&mut self) -> Result<Vec<PluginMeta>, String> {
        let mut metas = Vec::new();

        let entries = fs::read_dir(&self.plugin_dir)
            .map_err(|e| format!("无法读取插件目录 {:?}: {}", self.plugin_dir, e))?;

        for entry in entries.flatten() {
            let path = entry.path();

            // 只加载动态库文件(根据操作系统自动适配后缀)
            let is_lib = path.extension().map_or(false, |ext| {
                let ext = ext.to_string_lossy();
                // macOS: .dylib, Linux: .so, Windows: .dll
                ext == "dylib" || ext == "so" || ext == "dll"
            });

            if !is_lib {
                continue;
            }

            println!("[插件管理器] 发现插件库: {:?}", path);

            match self.load_plugin(&path) {
                Ok(meta) => metas.push(meta),
                Err(e) => eprintln!("[插件管理器] 加载失败 {:?}: {}", path, e),
            }
        }

        Ok(metas)
    }

    /// 加载单个动态库为插件实例
    fn load_plugin(&mut self, path: &Path) -> Result<PluginMeta, String> {
        // 步骤1:安全地打开动态链接库
        let library = unsafe {
            Library::new(path)
                .map_err(|e| format!("无法加载动态库: {}", e))?
        };

        // 步骤2:查找并调用 _plugin_create 导出符号
        let create_fn: Symbol<unsafe extern "C" fn() -> *mut dyn LogPlugin> = unsafe {
            library
                .get(b"_plugin_create")
                .map_err(|e| format!("找不到 _plugin_create 符号: {}", e))?
        };

        // 步骤3:调用工厂函数创建插件实例
        let plugin_ptr = unsafe { create_fn() };
        if plugin_ptr.is_null() {
            return Err("插件工厂函数返回空指针".to_string());
        }

        // 步骤4:读取插件元信息
        let (name, format) = unsafe {
            let plugin = &*plugin_ptr;
            (plugin.name().to_string(), plugin.supported_format().to_string())
        };

        // 步骤5:初始化插件
        unsafe {
            (*plugin_ptr)
                .init()
                .map_err(|e| format!("插件初始化失败: {}", e))?;
        }

        let meta = PluginMeta {
            path: path.to_string_lossy().to_string(),
            name: name.clone(),
            format: format.clone(),
        };

        self.plugins.insert(
            name.clone(),
            LoadedPlugin {
                _library: library,
                plugin_ptr,
            },
        );

        println!(
            "[插件管理器] 成功加载插件: {} (格式: {})",
            name, format
        );

        Ok(meta)
    }

    /// 根据格式名找到对应插件并解析日志行
    pub fn parse_with_format(
        &self,
        format: &str,
        line: &str,
    ) -> Result<ParsedLog, String> {
        // 查找支持该格式的插件
        let loaded = self
            .plugins
            .values()
            .find(|lp| {
                unsafe { (*lp.plugin_ptr).supported_format() == format }
            })
            .ok_or_else(|| {
                format!("没有找到支持格式 '{}' 的插件", format)
            })?;

        // 调用插件的解析方法
        unsafe {
            (*loaded.plugin_ptr)
                .parse_line(line)
                .map_err(|e| format!("解析失败: {:?}", e))
        }
    }

    /// 卸载所有插件并清理资源
    pub fn unload_all(&mut self) {
        for (name, loaded) in self.plugins.drain() {
            println!("[插件管理器] 卸载插件: {}", name);
            // 获取 _plugin_destroy 符号并调用
            unsafe {
                // 注意: _plugin_destroy 在原动态库中,但 library 还活着
                // 这里简化处理,直接 drop trait object
                let _ = Box::from_raw(loaded.plugin_ptr);
            }
            // loaded._library 在超出作用域时自动关闭
        }
    }
}

// =========================================================================
// Drop 实现:确保插件管理器销毁时清理所有插件
// =========================================================================
impl Drop for PluginManager {
    fn drop(&mut self) {
        // 在 PluginManager 销毁前,先释放所有插件
        let plugin_names: Vec<String> = self.plugins.keys().cloned().collect();
        for name in plugin_names {
            if let Some(loaded) = self.plugins.remove(&name) {
                unsafe {
                    let _ = Box::from_raw(loaded.plugin_ptr);
                }
                // loaded._library 自动 drop
            }
        }
    }
}

三、Wasm 插件方案:当安全隔离比性能更重要时

对于需要最高安全隔离级别的场景(比如插件来自不可信来源),Wasm 插件方案是最佳选择。核心流程是将用户编写的插件编译为 .wasm 文件,由宿主程序通过 wasmtime 加载并在沙箱内运行:

use wasmtime::{Engine, Module, Store, Linker};
use std::collections::HashMap;

/// Wasm 插件宿主:通过 wasmtime 加载和执行 .wasm 文件
pub struct WasmPluginHost {
    /// wasmtime 引擎实例
    engine: Engine,
    /// 已加载的插件(插件名 → 模块)
    modules: HashMap<String, Module>,
    /// 限制每个插件的内存上限(字节)
    memory_limit: usize,
}

impl WasmPluginHost {
    pub fn new(memory_limit_mb: usize) -> Self {
        let mut config = wasmtime::Config::new();
        // 设置 Wasm 线性内存上限
        config.static_memory_maximum_size(memory_limit_mb as u64 * 1024 * 1024);

        WasmPluginHost {
            engine: Engine::new(&config).expect("创建 wasmtime 引擎失败"),
            modules: HashMap::new(),
            memory_limit: memory_limit_mb * 1024 * 1024,
        }
    }

    /// 加载一个 .wasm 模块文件
    pub fn load_module(&mut self, name: &str, wasm_bytes: &[u8]) -> Result<(), String> {
        let module = Module::new(&self.engine, wasm_bytes)
            .map_err(|e| format!("Wasm 模块编译失败: {}", e))?;

        self.modules.insert(name.to_string(), module);
        println!("[Wasm Host] 加载模块: {} ({} 字节)", name, wasm_bytes.len());
        Ok(())
    }

    /// 调用某个 Wasm 插件的解析函数
    pub fn call_parse(
        &self,
        plugin_name: &str,
        raw_line: &str,
    ) -> Result<String, String> {
        let module = self.modules.get(plugin_name)
            .ok_or_else(|| format!("插件未加载: {}", plugin_name))?;

        let mut store = Store::new(&self.engine, ());
        let mut linker = Linker::new(&self.engine);

        // 注册宿主函数给 Wasm 模块使用(如日志输出函数)
        linker
            .func_wrap("host", "log", |msg_ptr: i32, msg_len: i32| {
                println!("[Wasm 日志] {:?}", &format!("ptr={} len={}", msg_ptr, msg_len));
            })
            .map_err(|e| format!("注册宿主函数失败: {}", e))?;

        // 实例化模块
        let instance = linker
            .instantiate(&mut store, module)
            .map_err(|e| format!("实例化模块失败: {}", e))?;

        // 获取导出的 parse 函数
        let parse_fn = instance
            .get_typed_func::<(i32, i32), i32>(&mut store, "parse_line")
            .map_err(|e| format!("找不到 parse_line 函数: {}", e))?;

        // 调用解析函数(此处简化,实际需要处理内存读写)
        let result = parse_fn
            .call(&mut store, (0i32, raw_line.len() as i32))
            .map_err(|e| format!("Wasm 函数调用失败: {}", e))?;

        Ok(format!("解析结果码: {}", result))
    }
}

四、插件系统的安全护栏:防止恶意插件搞崩主程序

无论选择哪种插件方案,安全都是底线。我们需要在以下维度建立防线:

use std::time::{Duration, Instant};
use std::panic;

/// 插件执行守卫:确保单个插件的操作不会影响主程序稳定性
pub struct PluginSandbox;

impl PluginSandbox {
    /// 执行插件操作并捕获 panic(防止 unsafe 代码 panic unwind 到主栈)
    pub fn catch_panic<F, T>(plugin_name: &str, f: F) -> Result<T, String>
    where
        F: FnOnce() -> T + panic::UnwindSafe,
    {
        panic::catch_unwind(f).map_err(|_| {
            format!("插件 {} 触发未捕获的 panic,已被拦截", plugin_name)
        })
    }

    /// 对插件操作设置超时(防止死循环耗尽主线程)
    pub fn with_timeout<F, T>(
        plugin_name: &str,
        timeout: Duration,
        f: F,
    ) -> Result<T, String>
    where
        F: FnOnce() -> T + Send + 'static,
        T: Send + 'static,
    {
        // 使用独立线程执行插件操作,避免永久阻塞主线程
        let handle = std::thread::spawn(f);

        // 等待结果或超时
        match handle.join() {
            Ok(result) => Ok(result),
            Err(_) => Err(format!(
                "插件 {} 执行超时({}ms 限制)或线程崩溃",
                plugin_name,
                timeout.as_millis()
            )),
        }
    }
}

4.2 实际踩坑:动态库卸载顺序引发的 segfault

实际项目里我就遇到过:插件管理器 drop 时先调了 _plugin_destroy,然后 _library 被析构,但 _plugin_destroy 里引用的代码还在那个库里——析构顺序反了,直接 segfault。Rust 的 drop 顺序是字段声明顺序的逆序,如果把 plugin_ptr 放在 _library 前面,就能保证先 drop 插件指针(调用 destroy),再卸载库。

另一个坑是跨动态库的 Rust trait object:Rust 的 dyn Trait 虚函数表在编译期生成,不保证 ABI 兼容。如果你的插件用 rustc 1.80 编译、主程序用 1.82 编译,指针偏移量可能不同。实测做过一次主程序升级没重新编译插件,整个 load_plugin 就 panic 了。生产环境里强制要求插件和主程序用同一个 rust-toolchain.toml 锁定编译版本。

这两条踩坑经验看似细节,却能在生产环境里帮你避免最头疼的 segfault。

五、总结

Rust 的插件架构选型需要回答两个核心问题:"插件作者是谁?" 和 "安全隔离有多重要?"。

  • 如果插件作者是你的团队成员,编译期 plugin trait + feature gate 最省事。
  • 如果面向外部 Rust 开发者,libloading 动态库方案是性价比最高的选择。
  • 如果面向非 Rust 开发者或不可信来源,Wasm 插件是最安全的方式。
  • 如果需要终端用户定义简单逻辑,Rhai 脚本是最友好的入口。

作为自学出身的工具开发者,我最大的体会是:插件系统不是功能的加法,而是架构的乘法。花一周搭建一个好的插件框架,比花一个月往主程序里塞功能要划算得多。

下一篇是 AI Agent 持久化状态——如何用 SQLite 存 agent 的会话历史和任务进度。欢迎在评论区聊聊你的插件系统设计经验。

三分钟解决RKNN-Toolkit2安装失败:从模块报错到成功验证的完整记录 本文详细记录了RKNN-Toolkit2安装失败的解决方案,从环境配置到模型转换实战,特别针对常见的'No module named 'rknn''报错提供了完整修复指南。通过YOLOv8模型转换示例,展示了从ONNX到RKNN格式的完整流程,并分享了在RK3588芯片上的部署优化技巧。 阅读详情

相关推荐

树莓派c语言串口通讯程序

在网上搜了很多关于树莓派串口通讯的例子,但是都是用python写的,虽然python很有名,而且最近也在学习这门语言, 但是还是想用c语言实现一下,因为需要用到整套系统里,其他内容都是用c语言写的。但是网上没有找打现成的。 还好,之前做过天嵌2440开发板的串口程序(参照天嵌工程师提供的代码),发现串口程序其实是通用的, 驱动层屏蔽了硬件细节,个人猜测,几乎所有移植好的系统的串口,都可以用一

realank的专栏 1万+

Rust插件系统教程

Rust插件系统教程 项目介绍 plugins_in_rust 是一个展示如何在 Rust 中实现插件系统的开源项目。该项目由 Michael-F-Bryan 开发,旨在帮助开发者理解并实现 Rust 应用程序的模块化和动态加载功能。通过这个项目,开发者可以学习到如何使用 Rust 的动态加载特性来创建可扩展的应用程序。 项目快速启动 环境准备 确保你已经安装了 Rust 和 Cargo。如果没有...

gitblog_00484的博客 827

Dynamics CRM证书更换

  Dynamics CRM产品一般有两种认证方式。第一种是基于声明的内部访问也就是无证书单纯用账号密码验证。第二种就是联合身份认证,需要安装网站证书。   对于联合身份认证的情况因为需要安装证书,而且证书是有一个一年的有效期,所以运维人员每年都需要进行证书更换的操作。以下就是更换证书的方法及过程。 证书根据申请方式一般也分两种,第一种是自建证书,这种证书是没有机构认证的所以安装上之后网站因为没...

bzpfly的博客 882

Rust 实现动态库加载和基于此功能实现的插件管理

最近开发后端 UCenter 服务,考虑到该服务核心逻辑变动相对少,稳定性要求高,单点处理能力要强,且 IO 瓶颈较少(大多缓存),www.consonchina.com有较多的校验和加解密工作,因此需要使用性能更为强劲的语言,最终考虑使用 Rust(无 GC、内存安全、性能与 C/C++ 差距不明显)以及其最近风头正劲的基于 模型的 Web 框架:。对于框架和语言的介绍我会另起文章,先说说这个用户中心服务。...

weixin_39720414的博客 4818

SpringBoot 指标监控——Actuator

1、 访问:localhost:8000/actuator 设置健康监控显示具体情况 metrics http://localhost:8000/actuator/metrics/jvm.gc.live.data.size 定制化health信息 //利用构造器,在注册中心中添加cityService.saveCity.count指标 public CityServiceImpl(MeterRegistry meter...

weixin_44302046的博客 4633

Xiaojie雷达之路---毫米波雷达基础知识---角度估计

本篇文章主要介绍毫米波雷达的基础知识中的角度估计,对于本篇文章主要回答5个问题 1.在雷达的前方,如何估计前方一个物体的角度 2.角度测量的准确性 3.如何测量多个物体的角度 4.雷达可测的角度的视场最大值为多少 5.角度分辨率取决于什么因素 文章目录估计雷达前面一个物体的角度角度测量的准确性雷达的最大角视场测量雷达前方多个距离和速度相同的物体角度分辨率角度估计的流程 估计雷达前面一个物体的角度 估计一个物体的角度,最少需要两根接收天线 发射天线发送一个chirp,经过物体发射后信号,信号分别被第一根天

XiaoJie的博客 1万+

【Rust日报】使用Wasm实现Rust的插件系统

跟着 @compiler-errors 给 Rustc 做贡献在2024年12月, @compiler-errors在Rust编译器中做出了一些显著的贡献。以下是他的工作概要:错误信息和诊断改进:修复了tail_expr_drop_order lint的问题,使其在cargo check和cargo build中行为一致。这涉及到将该lint的检查从编译流程的较晚阶段移到较早阶段,确保在所有相关情...

Rust语言学习交流 550

51单片机独立按键控制LED(二)

对于机械开关,当机械触点断开、闭合时,由于机械触点的弹性作用,一个开关在闭合时不会马上稳定地接通,在断开时也不会一下子断开,所以在开关闭合及断开的瞬间会伴随一连串的抖动。独立按键控制LED显示二进制。独立按键控制LED灯亮灭。独立按键控制LED状态。独立按键控制LED移位。

m0_50562428的博客 5387

Rust插件系统项目教程

Rust插件系统项目教程 1. 项目的目录结构及介绍 plugins_in_rust/ ├── Cargo.toml ├── README.md ├── src/ │ ├── main.rs │ ├── lib.rs │ └── plugins/ │ ├── mod.rs │ ├── example_plugin.rs │ └── another_p...

gitblog_00647的博客 600

【项目实战】TARA威胁分析和风险评估

TARA是信息安全领域中的一种风险评估方法,在汽车信息安全的上下文中,TARA分析特别重要,因为它可以帮助识别和管理与智能网联车辆相关的各种威胁,包括数据泄露、未经授权的访问、远程操控等。通过TARA分析,企业可以制定出针对性的安全目标、产品要求和产品安全声明,以确保汽车及其零部件符合相关的信息安全标准和法规。此外,TARA分析还可以与数字化建模系统结合,以更系统化和高效的方式进行风险评估和管理。

奶爸的编程之路,也就一周冷个三天 2715

AI编码规则:从提示工程到自动化,提升大模型生成代码质量

在软件工程领域,代码质量是保障软件可维护性、安全性和团队协作效率的核心。其背后遵循着从基础语法规范到架构设计原则的一系列工程实践。随着大语言模型(LLM)在代码生成任务中的广泛应用,如何确保AI生成的代码符合这些工程标准,成为一个关键的技术挑战。这涉及到将人类工程师积累的最佳实践,转化为机器可理解、可执行的明确约束。通过系统化的**编码规则**定义与集成,例如构建涵盖安全、风格、架构的多层次规则集,并将其融入**提示工程**或自动化工作流,可以显著引导AI产出更健壮、规范的代码。这种方法的价值在于,它能将模

weixin_42525189的博客 644

【三万言】今年 Rust 语言出圈了!下一代系统语言 Rust 前沿报告

前言Rust是一种一旦了解就会产生使用欲望的语言,Rust 语言连续八年蝉联 stackoverflow 开发者调查问卷 最受欢迎编程语言榜首就是最好的证明。但比起“最受欢迎”的连胜纪录,增长的使用率更加值得关注。与2022年的调查相比,它在所有受访者中增长了3.7个百分点,现在紧随 Go 之后。人们对 Rust 语言普遍的抱怨来自没有太多的 Rust 工作岗位。然而,Rust 语言已经在一些至关...

图灵教育 2612

OpenWRT使用4G/5G无线网卡模块上网

将4G/5G开发板插入设备,终端输入lsusb或lspci,看设备是否识别到4G/5G模块。

1万+

如何为igrep编写自定义插件:扩展功能的完整指南

igrep作为一款强大的交互式搜索工具(Interactive Grep),提供了高效的文本搜索体验。本教程将带你探索如何通过自定义插件扩展igrep的功能,让这款工具更贴合你的工作流需求。无论你是想添加特殊的搜索过滤规则,还是集成第三方服务,插件系统都能帮你实现这些定制化需求。 ## 了解igrep插件系统的基础架构 在开始编写插件前,我们需要先了解igrep的插件架构。虽然当前版本的igr

gitblog_00868的博客 819

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

如何为 Runebender 开发自定义工具:插件系统与扩展开发教程

Runebender 是一款用 Rust 编写的现代化字体编辑器,它提供了强大的工具系统,允许开发者创建自定义工具来扩展编辑功能。本文将为您详细介绍 Runebender 的工具系统架构以及如何开发自定义工具,帮助您更好地理解这个字体编辑器的扩展机制。🚀 ## Runebender 工具系统架构解析 Runebender 的工具系统基于 Rust 的 Trait 设计模式,每个工具都是一个实

gitblog_00586的博客 394

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

企业级插件架构终极指南:使用rquickjs构建可扩展的JavaScript插件系统 [特殊字符]

在当今快速发展的软件生态中,**企业级应用架构**需要灵活、可扩展的插件系统来应对不断变化的业务需求。**rquickjs**作为QuickJS JavaScript引擎的高层Rust绑定,为企业提供了构建安全、高性能**JavaScript插件系统**的完美解决方案。这个开源项目让开发者能够在Rust应用中无缝嵌入JavaScript运行时,实现动态扩展能力,同时保持原生应用的性能和安全性。

gitblog_00269的博客 346

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

深度解析Halo仪表盘组件架构:响应式网格系统与插件化扩展实现方案

Halo作为一款现代化的开源建站工具,其仪表盘组件系统采用了先进的响应式网格架构与插件化扩展机制,为开发者提供了高度可定制化的管理界面构建方案。本文将深入剖析Halo仪表盘组件的技术实现原理、核心架构设计以及扩展开发实践。 ## 技术架构深度剖析 ### 核心设计理念解析 Halo仪表盘系统的设计哲学基于三个核心原则:组件化、响应式和可扩展性。系统采用Vue 3组合式API构建,通过`vue

gitblog_00220的博客 1094

ER-Save-Editor 技术架构解析:Rust实现的艾尔登法环存档编辑系统实现机制

ER-Save-Editor是一个基于Rust语言开发的专业级艾尔登法环存档编辑器,支持PC和PlayStation双平台存档的读取、分析和修改。该项目的技术架构展现了现代Rust应用开发的优秀实践,通过模块化设计、类型安全的数据处理和跨平台兼容性,为游戏存档编辑提供了可靠的技术解决方案。作为开源项目,它不仅实现了复杂的游戏数据解析功能,还提供了直观的用户界面,展示了Rust在游戏工具开发领域的强

gitblog_00540的博客 1271

Polars 插件扩展实战:用 Expression 插件与 IO 插件为 DataFrame 引擎加装自定义能力

Polars 是一个用 Rust 编写的极速 DataFrame 查询引擎,其插件机制允许开发者在不改动主库源码的前提下扩展引擎能力。本篇以仓库中 [plugins.rst](https://link.gitcode.com/i/5d4e60a5317d4d83c75f99b6cecbcf85) 所定义的官方扩展接口为骨架,完整讲解两大类插件——**Expression 插件**(通过 `regi

gitblog_00489的博客 1124

erased-serde在插件系统中的应用:实现动态数据格式支持

erased-serde是一个强大的Rust库,它提供了类型擦除的Serialize、Serializer和Deserializer特性,专门解决Serde在插件系统和动态数据格式支持中的对象安全问题。这个库让开发者能够在运行时动态处理多种数据格式,为构建灵活可扩展的插件系统提供了完美的解决方案。🚀 ## 为什么需要erased-serde? 在Rust生态系统中,Serde是序列化和反序列

gitblog_00783的博客 814

WebMCP 命令式工具实战:为 The Daily Grind 构建可被 AI Agent 调用的浏览器端 JavaScript 工具

本文以 `guides/webmcp/agentic-javascript-tools/tasks/task.md` 中的三条真实需求为骨架,讲解如何用 WebMCP 的 Imperative API(`document.modelContext.registerTool()`)把菜单查询、库存检查、门店检索等浏览器端能力注册成 AI Agent 可发现、可调用的工具。读完你将掌握工具定义结构、J

gitblog_01074的博客 222

【进阶】RustMark v1.0:插件系统 — Rust Trait Object、GAT 与动态分发深度实战

核心痛点:随着 RustMark 编辑器的功能不断膨胀,内核代码耦合度急剧上升——每增加一个功能(字数统计、大纲视图、自定义导出),就需要修改内核代码、重新编译、重新发布。本文解决的核心问题是如何在 Rust 中构建一套类型安全、高性能、可动态扩展的插件系统,让新功能以插件形式独立开发、独立编译、运行时加载,实现真正的"开放-封闭"架构。前置知识:需要掌握 Rust 的 Trait 基础、泛型编程、智能指针(BoxArc)、以及基本的生命周期标注方法。

我的博客 335

ER-Save-Editor架构解析:Rust实现的跨平台游戏存档编辑系统实战指南

ER-Save-Editor是一个基于Rust语言开发的专业级艾尔登法环存档编辑器,实现了PC与PlayStation平台的存档双向兼容和精细化数据管理。该工具通过模块化架构设计,为游戏存档编辑提供了安全、高效的技术解决方案,解决了玩家在角色构建、存档迁移和数据修复中的核心痛点。 ## 技术痛点与价值定位:游戏存档编辑的工程化挑战 在《艾尔登法环》这类复杂RPG游戏中,存档编辑面临多重技术挑战

gitblog_01130的博客 452

深入解析Rust与FFmpeg融合的分布式媒体处理系统架构设计与企业级部署方案

基于Rust和FFmpeg构建的分布式媒体处理系统ffplayout,为24/7广播服务提供了企业级高可用解决方案。该系统采用微服务架构设计,结合异步编程模型与硬件加速技术,实现了从媒体文件管理到实时流分发的完整技术栈。针对广播电视、IPTV、在线教育等场景,ffplayout通过容器化部署方案和性能优化策略,确保媒体处理流程的稳定性和可扩展性。 ## 核心价值:现代媒体处理系统的技术演进 传

gitblog_01056的博客 834

用 godot-rust 给 Godot 写 Rust 扩展

godot-rust(代号 gdext)是 Godot 4 的 Rust 绑定,通过官方的 GDExtension 接口,让你用 Rust 写游戏逻辑、编辑器插件和自定义节点,不用改引擎源码,也不用重新编译 Godot。今年 3 月发布的 v0.5 带来了类型化字典、非空对象参数和随处可用的 Rust 枚举,之后的 0.5.x 补丁一路更新到 8 月的 v0.5.5,并加入了 Godot 4.7 的 API 支持,已经可以用在真实项目里。

370

[WASM实战] 插件系统的安全性:智能体来了(西南总部)AI调度官的WebAssembly沙箱与AI agent指挥官的动态加载

还有什么比 Docker 更轻、更快、更安全?答案是 WebAssembly (WASM)。 本文将硬核剖析 智能体来了(西南总部) 的 "Nano-Process" (纳进程) 架构:如何利用 Rust 和 WASM 构建毫秒级启动的沙箱,让 AI 调度官 安全地执行不可信代码。

a1159530428的博客 1010
上一篇: AI 辅助 Rust 架构评审:让模型扮演不同角色交叉验证你的设计
下一篇: AI Agent 的持久化状态:用 SQLite 存 agent 的会话历史和任务进度
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 17
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值