Spring AI与Spring Modulith核心技术解析

news2025/12/14 17:38:21

Spring AI核心架构解析

Spring AI（https://spring.io/projects/spring-ai）作为Spring生态中的AI集成框架，其核心设计理念是通过模块化架构降低AI应用的开发复杂度。与Python生态中的LangChain/LlamaIndex等工具类似，但特别为多语言开发者设计，不局限于Python技术栈。

模块化抽象层设计

框架的核心价值体现在三个关键抽象层：

  1. 可插拔模型适配层
    通过标准化接口封装不同AI服务提供商的差异，开发者只需通过配置即可切换底层引擎。例如从OpenAI迁移到Azure OpenAI服务时，仅需修改配置而无需重写业务代码：
spring:
  ai:
    openai:
      api-key: ${OPENAI_KEY}
    azure:
      endpoint: https://{resource-name}.openai.azure.com

  1. 预置功能组件
    内置企业级场景解决方案：

    • 智能文档问答系统
    • 基于知识库的对话机器人
    • 自动化内容生成管道

  2. Spring生态深度集成
    与Spring Integration、Spring Data等组件无缝协作，支持复杂业务流程编排。例如通过Spring Integration的DSL实现AI处理管道：

@Bean
public IntegrationFlow aiProcessingFlow() {
    return IntegrationFlows.from("inputChannel")
        .transform(aiClient::call)
        .handle("resultProcessor")
        .get();
}

语言模型支持矩阵

当前版本（0.9.0-SNAPSHOT）主要聚焦语言类模型，支持以下能力：

模型类型典型应用场景版本支持
GPT系列文本生成/对话系统GPT-3.5/4全系列
Embedding模型语义搜索/文本分类text-embedding-ada
多模态模型图文生成（实验性）DALL·E 2

核心编程模型

提示词工程实现

框架通过PromptTemplate实现结构化提示词管理，支持动态变量插值：

PromptTemplate template = new PromptTemplate("""
    作为{role}，请用{style}风格回答关于{topic}的问题。
    回答时需包含以下要点：{points}
    """);

Prompt prompt = template.create(Map.of(
    "role", "技术专家",
    "style", "简明扼要",
    "topic", "微服务架构",
    "points", List.of("优势","挑战","最佳实践")
));
向量化处理

Embedding功能通过统一接口抽象，简化文本向量化操作：

EmbeddingClient client = new OpenAiEmbeddingClient();
List vector = client.embed("Spring框架核心特性");
上下文窗口管理

智能处理长文本的分块策略，避免超出模型token限制：

TextSplitter splitter = new TokenTextSplitter()
    .setChunkSize(2000)
    .setOverlap(200);

List chunks = splitter.split(largeDocument);

生产环境准备

虽然当前处于预览阶段，但已具备关键生产特性：

  • 完善的异常处理机制（AiClientException体系）
  • 可观测性支持（Micrometer指标暴露）
  • 重试与降级策略配置
# 应用配置示例
spring.ai.retry.max-attempts=3
spring.ai.retry.backoff.initial=1000ms
management.metrics.export.ai.requests.enabled=true

该架构特别适合需要快速迭代AI能力的Java企业应用，其模块化设计保证了技术栈的可持续演进能力。开发者可以基于当前稳定功能开始原型开发，同时保持对未来版本新增特性的兼容预期。

AI核心概念解析

模型机制：预训练模型原理与GPT系列特性分析

现代AI模型本质是通过海量数据训练获得的智能处理工具，其核心能力体现在模式识别与生成逻辑。以GPT系列为代表的语言模型采用Transformer架构，通过自注意力机制实现上下文理解。Spring AI当前主要集成以下模型类型：

// 模型选择配置示例
@Configuration
public class AiModelConfig {
    @Bean
    public ChatClient chatClient() {
        return new OpenAiChatClient("gpt-4"); // 可替换为gpt-3.5-turbo
    }
}

关键特性包括：

  • 零样本学习：无需额外训练即可处理新任务
  • 512 tokens上下文窗口：处理长文本时自动分块
  • 多轮对话保持：通过session维护对话状态

提示工程：多角色提示模板设计与最佳实践

提示词是引导模型输出的关键指令，Spring AI通过PromptTemplate实现结构化设计：

PromptTemplate template = new PromptTemplate("""
    [系统角色]你是一位{domain}专家
    [用户输入]{question}
    [输出要求]用{language}回答，包含代码示例
    """);

Prompt prompt = template.create(
    Map.of("domain", "Spring框架", 
           "question", "如何实现AOP?", 
           "language", "中文")
);

最佳实践原则：

  1. 角色明确：定义AI的应答身份（如"资深Java架构师"）
  2. 格式控制：使用Markdown等结构化输出
  3. 示例引导：提供few-shot示例提高准确性

嵌入技术：文本向量化原理及相似度计算应用

文本嵌入将语义信息转化为768维向量，Spring AI提供标准化操作接口：

EmbeddingClient client = new AzureEmbeddingClient();
List vector1 = client.embed("微服务架构");
List vector2 = client.embed("分布式系统");

// 计算余弦相似度
double similarity = CosineSimilarity.calculate(vector1, vector2);

典型应用场景：

  • 语义搜索：超越关键词匹配的深层语义检索
  • 异常检测：通过向量偏离度识别异常文本
  • 知识图谱：实体关系可视化分析

令牌系统：计费机制与上下文窗口限制解决方案

令牌是AI模型的基础计费单位，Spring AI提供智能分块策略：

TextSplitter splitter = new RecursiveTextSplitter()
    .setChunkSize(1000)
    .setChunkOverlap(200);

List chunks = splitter.split(document);

关键限制与应对方案：

模型类型最大tokens分块策略成本估算
GPT-3.54096滑动窗口$0.002/1K tokens
GPT-48192层次分割$0.06/1K tokens

通过TokenCountEstimator可实时监控用量：

int tokens = estimator.estimate("Spring AI核心功能");

Spring Modulith架构设计

模块化哲学：城市分区式的应用组织

Spring Modulith采用"城市分区"隐喻构建模块化应用，其核心设计原则体现为：

  1. 功能自治性
    每个模块如同城市功能区（商业区/住宅区），包含完整的业务能力闭环。例如用户管理模块需独立实现：

    • 领域模型（User实体）
    • 持久层（UserRepository）
    • 业务服务（UserService）
    • REST端点（UserController）

  2. 明确边界约束
    通过Java包作用域实现强封装，内部实现类默认不可跨模块访问。典型包结构规范如下：

src/main/java
└── com.example
    ├── Application.java       # 主启动类
    ├── user                   # 用户模块
    │   ├── User.java          # 领域模型（包私有）
    │   └── UserService.java   # 公开服务
    └── order                  # 订单模块
        ├── Order.java
        └── OrderService.java

核心组件设计

模块内部采用三位一体架构：

// 用户模块公开接口示例
public interface UserService {
    User createUser(UserDTO dto);
}

// 内部实现（包私有可见性）
class DefaultUserService implements UserService {
    private final UserRepository repository;
    
    @Override
    public User createUser(UserDTO dto) {
        // 实现细节对外不可见
    }
}

关键设计要素：

  • 公开接口：通过Spring Bean暴露服务能力
  • 内部实现：使用默认包可见性修饰符
  • 依赖声明：通过@ApplicationModule注解显式声明

包结构自动识别规则

Spring Modulith通过以下规则自动识别模块边界：

  1. 主包识别
    标注@SpringBootApplication的类所在包为根包

  2. 模块推导
    直接子包自动识别为应用模块，例如：

    • com.example.user → user模块
    • com.example.order → order模块

  3. API可见性
    仅公共类型可跨模块引用，通过package-info.java强化约束：

@org.springframework.modulith.ApplicationModule(
    allowedDependencies = {"order"}
)
package com.example.user;

验证机制与架构测试

框架提供自动化验证工具，确保模块化约束：

// 模块结构验证测试
@Test
void verifyModuleStructure() {
    ApplicationModules.of(Application.class)
        .verify(); // 违反约束时抛出Violations异常
}

// 生成模块文档
@Test
void generateDocumentation() {
    new Documenter(ApplicationModules.of(Application.class))
        .writeDocumentation(); // 生成AsciiDoc文档
}

典型约束检查包括：

  • 非法跨模块引用检测
  • 循环依赖分析
  • 公开API合规性验证

事件驱动通信模式

模块间推荐采用事件进行解耦通信：

// 用户模块发布事件
@Service
public class UserService {
    private final ApplicationEventPublisher events;

    public User register(User user) {
        // 持久化操作...
        events.publishEvent(new UserRegisteredEvent(user.getId()));
    }
}

// 订单模块监听事件
@Service
public class OrderService {
    @TransactionalEventListener
    void handleUserRegistered(UserRegisteredEvent event) {
        // 处理新用户注册逻辑
    }
}

通过EVENT_PUBLICATION表实现可靠事件传递，确保模块间最终一致性。

模块化实战案例

项目合并策略

将MyRetro与Users两个独立应用重构为模块化单体时，需遵循以下关键步骤：

  1. 项目结构重组
    合并后的基础包结构应保持扁平化设计，主应用类置于根包层级：

    src/main/java
└── com.apress
    ├── MyretroApplication.java  // 主启动类
    ├── myretro                 // 看板模块
    │   ├── package-info.java    // 模块声明文件
    │   └── service/RetroBoardAndCardService.java
    └── users                   // 用户模块
        ├── package-info.java
        └── service/UserService.java

  2. 依赖管理配置
    在build.gradle中声明Modulith核心依赖：

    dependencyManagement {
    imports {
        mavenBom 'org.springframework.modulith:spring-modulith-bom:1.1.2'
    }
}
dependencies {
    implementation 'org.springframework.modulith:spring-modulith-starter-core'
    implementation 'org.springframework.modulith:spring-modulith-starter-jpa'
}

事件驱动通信

跨模块交互推荐采用事务事件模式，避免直接依赖：

  1. 事件定义
    在users模块中创建领域事件DTO：

    @Data
public class UserEvent {
    private String email;
    private String action; // "create"/"update"/"delete"
}

  2. 事件发布
    修改UserService使用类型安全的事件发布：

    @Service
public class UserService {
    private final ApplicationEventPublisher events;
    
    @Transactional
    public User saveUser(User user) {
        User saved = repository.save(user);
        events.publishEvent(new UserEvent(saved.getEmail(), "save"));
        return saved;
    }
}

  3. 事件监听
    在看板模块中使用事务监听器：

    @Service
public class RetroBoardAndCardService {
    @Async
    @TransactionalEventListener
    public void handleUserEvent(UserEvent event) {
        log.info("Process user {} event at {}", event.getEmail(), event.getAction());
    }
}

依赖白名单控制

通过package-info.java显式声明模块间依赖关系：

// myretro模块声明文件
@org.springframework.modulith.ApplicationModule(
    allowedDependencies = {"users"} // 仅允许依赖users模块
)
package com.apress.myretro;

架构验证与文档

Spring Modulith提供自动化测试工具：

class ModularityTests {
    ApplicationModules modules = ApplicationModules.of(MyretroApplication.class);

    @Test
    void verifyStructure() {
        modules.verify(); // 验证模块边界
    }

    @Test
    void generateDocs() {
        new Documenter(modules)
           .writeDocumentation(); // 生成AsciiDoc文档
    }
}

执行测试后会在build目录生成：

  • modules.adoc：模块结构说明文档
  • module-interactions.puml：PlantUML格式的模块交互图

运行时验证

启动应用后可通过以下方式验证：

  1. 检查H2控制台的EVENT_PUBLICATION表，确认事件持久化记录
  2. 观察日志输出中的事务事件处理时间戳
  3. 访问Actuator端点查看模块健康状态

该方案实现了：

  • 编译时强制的模块边界检查
  • 运行时可视化的事件流监控
  • 可追溯的跨模块交互日志

与微服务的对比分析

架构差异：单体模块化 vs 分布式服务

Spring Modulith采用逻辑模块化的单体架构，各模块通过进程内调用通信，而微服务架构强调物理隔离的独立部署单元。关键差异体现在：

// Modulith模块间调用示例（进程内）
@Service
public class OrderService {
    private final UserService userService; // 直接注入
    
    public Order createOrder(Long userId) {
        User user = userService.getUser(userId); // 本地方法调用
        // ...
    }
}

// 微服务调用示例（跨进程）
@FeignClient("user-service")
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);
}

通信延迟对比：

架构类型平均延迟典型协议
Modulith0.1-1ms方法调用
微服务10-100msHTTP/gRPC

适用场景分析

适合Modulith的场景
  • 快速迭代需求：初创项目需要快速验证业务模型时
  • 强事务一致性：如金融交易系统需要ACID事务保证
  • 中小团队协作：10人以下团队维护单一代码库
适合微服务的场景
  • 异构技术栈：不同模块需要不同语言/框架实现
  • 独立扩展需求：如电商促销期间只需扩容订单服务
  • 故障隔离要求：关键服务需要物理隔离避免级联故障

性能关键指标对比

通过JMeter压测模拟不同架构表现：

Modulith架构 (TPS)
--------------------
用户管理模块: 1250 
订单模块: 980

微服务架构 (TPS)
--------------------
用户服务: 820 
订单服务: 650 
网关延迟: 200ms平均

团队适配建议

组织架构匹配
  • 垂直功能团队：适合Modulith（如全栈功能小组）
  • 领域专家团队：适合微服务（如支付/物流领域组）
技术能力要求
技术能力
Modulith要求
微服务要求
Spring深度掌握
模块设计能力
分布式系统知识
容器化部署技能

迁移路径建议

对于从Modulith演进到微服务的系统，推荐分阶段过渡：

  1. 模块解耦阶段
    使用@ApplicationModule明确边界，为每个模块添加REST API

    @ApplicationModule(allowedDependencies = "inventory")
package com.example.ordering;

  2. 独立部署准备
    引入Spring Cloud Stream实现事件总线：

    spring:
  cloud:
    stream:
      bindings:
        order-out.destination: orders
        payment-in.destination: payments

  3. 最终拆分阶段
    通过Spring Cloud Kubernetes实现服务发现：

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

该对比分析表明，架构选择需要综合考量业务发展阶段、团队规模和性能需求等因素，两种架构也可在系统演进过程中配合使用。

技术总结

Spring AI的技术突破

Spring AI通过三层抽象架构显著降低AI集成复杂度：

  1. 标准化接口层：封装OpenAI/Azure等不同供应商的API差异，仅需配置变更即可切换服务提供商
  2. 预置功能组件：内置文档问答、对话机器人等企业级场景解决方案
  3. Spring生态集成：与Spring Data JPA协同实现AI处理结果持久化，典型代码如下：
@Repository
public interface AnalysisRepository extends JpaRepository {
    @Modifying
    @Query("update AiAnalysis a set a.result = :result where a.id = :id")
    void updateResult(@Param("id") Long id, @Param("result") String result);
}

Spring Modulith的架构价值

模块化设计通过三项核心机制保障可维护性：

  1. 编译时验证：ApplicationModules验证器强制检查模块边界
  2. 运行时监控：EVENT_PUBLICATION表记录所有跨模块事件
  3. 文档自动化：PlantUML生成的模块交互图实时反映架构状态

关键约束配置示例：

@ApplicationModule(
    allowedDependencies = {"inventory"},
    displayName = "订单核心模块"
)
package com.example.order;

架构选型决策矩阵

基于团队规模和技术复杂度的选型建议：

评估维度Spring Modulith适用场景微服务适用场景
团队规模≤10人全功能团队≥3个领域专家团队
发布频率每日多次迭代独立模块周级发布
事务需求强ACID事务最终一致性
技术债务遗留系统改造全新绿色工程

演进式架构实践

建议采用渐进式架构演进路径：

  1. 单体模块化阶段：使用Modulith建立清晰边界
  2. 混合架构阶段：关键模块通过Spring Cloud逐步剥离
  3. 全微服务阶段：采用Service Mesh治理服务网格

性能对比数据：

  • 模块间调用延迟：Modulith(0.8ms) vs 微服务(35ms)
  • 事务成功率：Modulith(99.99%) vs 微服务(98.7%)

Spring生态设计哲学

两大项目均体现Spring的核心原则：

  1. 约定优于配置：模块默认扫描规则、AI客户端自动装配
  2. 渐进式复杂度：从简单CRUD到复杂事件流的分层抽象
  3. 生产就绪思维：内置健康检查、指标暴露等运维能力

AI与Modulith的协同示例：

@ApplicationModule
public class AiIntegrationModule {
    @Bean
    public ChatClient chatClient() {
        return new OpenAiChatClient(apiKey);
    }
    
    @TransactionalEventListener
    public void handleAnalysisEvent(AiRequestEvent event) {
        // 模块化处理AI请求
    }
}

该技术体系为Java企业应用提供了从AI集成到架构治理的完整解决方案，建议团队根据实际成熟度选择适配路径。

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

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

相关文章

Spring数据访问模块设计

Spring数据访问模块设计

前面我们已经完成了IoC和web模块的设计，聪明的码友立马就知道了，该到数据访问模块了，要不就这俩玩个6啊，查库势在必行，至此，它来了。 一、核心设计理念 1、痛点在哪 应用离不开数据（数据库、No…
阅读更多...
如何在最短时间内提升打ctf（web)的水平？

如何在最短时间内提升打ctf（web)的水平？

刚刚刷完2遍 bugku 的 web 题，前来答题。 每个人对刷题理解是不同，有的人是看了writeup就等于刷了，有的人是收藏了writeup就等于刷了，有的人是跟着writeup做了一遍就等于刷了，还有的人是独立思考做了一遍就等于刷了。…
阅读更多...
如何理解 IP 数据报中的 TTL？

如何理解 IP 数据报中的 TTL？

目录 前言理解 前言 面试灵魂一问：说说对 IP 数据报中 TTL 的理解？我们都知道，IP 数据报由首部和数据两部分组成，首部又分为两部分：固定部分和可变部分，共占 20 字节，而即将讨论的 TTL 就位于首…
阅读更多...
Android 之 kotlin 语言学习笔记三（Kotlin-Java 互操作）

Android 之 kotlin 语言学习笔记三（Kotlin-Java 互操作）

参考官方文档：https://developer.android.google.cn/kotlin/interop?hlzh-cn 一、Java（供 Kotlin 使用） 1、不得使用硬关键字 不要使用 Kotlin 的任何硬关键字作为方法的名称 或字段。允许使用 Kotlin 的软关键字、修饰符关键字和特殊标识…
阅读更多...
C++ Visual Studio 2017厂商给的源码没有.sln文件 易兆微芯片下载工具加开机动画下载。

C++ Visual Studio 2017厂商给的源码没有.sln文件 易兆微芯片下载工具加开机动画下载。

1.先用Visual Studio 2017打开Yichip YC31xx loader.vcxproj，再用Visual Studio 2022打开。再保侟就有.sln文件了。 易兆微芯片下载工具加开机动画下载 ExtraDownloadFile1Info.\logo.bin|0|0|10D2000|0 MFC应用兼容CMD 在BOOL CYichipYC31xxloaderDlg::OnIni…
阅读更多...
【Oracle】分区表

【Oracle】分区表

个人主页：Guiat 归属专栏：Oracle 文章目录 1. 分区表基础概述1.1 分区表的概念与优势1.2 分区类型概览1.3 分区表的工作原理 2. 范围分区 (RANGE Partitioning)2.1 基础范围分区2.1.1 按日期范围分区2.1.2 按数值范围分区 2.2 间隔分区 (INTERVAL Partit…
阅读更多...
【开发技术】.Net使用FFmpeg视频特定帧上绘制内容

【开发技术】.Net使用FFmpeg视频特定帧上绘制内容

目录 一、目的 二、解决方案 2.1 什么是FFmpeg 2.2 FFmpeg主要功能 2.3 使用Xabe.FFmpeg调用FFmpeg功能 2.4 使用 FFmpeg 的 drawbox 滤镜来绘制 ROI 三、总结 一、目的 当前市场上有很多目标检测智能识别的相关算法，当前调用一个医疗行业的AI识别算法后返回…
阅读更多...
RNN避坑指南：从数学推导到LSTM/GRU工业级部署实战流程

RNN避坑指南：从数学推导到LSTM/GRU工业级部署实战流程

本文较长，建议点赞收藏，以免遗失。更多AI大模型应用开发学习视频及资料，尽在聚客AI学院。 本文全面剖析RNN核心原理，深入讲解梯度消失/爆炸问题，并通过LSTM/GRU结构实现解决方案，提供时间序列预测和文本生成…
阅读更多...
学习STC51单片机32（芯片为STC89C52RCRC）OLED显示屏2

学习STC51单片机32（芯片为STC89C52RCRC）OLED显示屏2

每日一言 今天的每一份坚持，都是在为未来积攒底气。 案例：OLED显示一个A 这边观察到一个点，怎么雪花了就是都是乱七八糟的占满了屏幕。。 解释 ： 如果代码里信号切换太快（比如 SDA 刚变，SCL 立刻变&#…
阅读更多...
3-11单元格区域边界定位(End属性)学习笔记

3-11单元格区域边界定位(End属性)学习笔记

返回一个Range 对象，只读。该对象代表包含源区域的区域上端下端左端右端的最后一个单元格。等同于按键 End 向上键(End(xlUp))、End向下键(End(xlDown))、End向左键(End(xlToLeft)End向右键(End(xlToRight)) 注意：它移动的位置必须是相连的有内容的单元格…
阅读更多...
蓝桥杯3498 01串的熵

蓝桥杯3498 01串的熵

问题描述 对于一个长度为 23333333的 01 串, 如果其信息熵为 11625907.5798&#xff0c; 且 0 出现次数比 1 少, 那么这个 01 串中 0 出现了多少次? #include<iostream> #include<cmath> using namespace std;int n 23333333;int main() {//枚举 0 出现的次数//因…
阅读更多...
什么是Ansible Jinja2

什么是Ansible Jinja2

理解 Ansible Jinja2 模板 Ansible 是一款功能强大的开源自动化工具&#xff0c;可让您无缝地管理和配置系统。Ansible 的一大亮点是它使用 Jinja2 模板&#xff0c;允许您根据变量数据动态生成文件、配置设置和脚本。本文将向您介绍 Ansible 中的 Jinja2 模板&#xff0c;并通…
阅读更多...
优选算法第十二讲：队列 + 宽搜 优先级队列

优选算法第十二讲：队列 + 宽搜 优先级队列

优选算法第十二讲&#xff1a;队列 宽搜 && 优先级队列 1.N叉树的层序遍历2.二叉树的锯齿型层序遍历3.二叉树最大宽度4.在每个树行中找最大值5.优先级队列 -- 最后一块石头的重量6.数据流中的第K大元素7.前K个高频单词8.数据流的中位数 1.N叉树的层序遍历 2.二叉树的锯…
阅读更多...
项目部署到Linux上时遇到的错误（Redis，MySQL，无法正确连接，地址占用问题）

项目部署到Linux上时遇到的错误（Redis，MySQL，无法正确连接，地址占用问题）

Redis无法正确连接 在运行jar包时出现了这样的错误 查询得知问题核心在于Redis连接失败&#xff0c;具体原因是客户端发送了密码认证请求&#xff0c;但Redis服务器未设置密码 1.为Redis设置密码&#xff08;匹配客户端配置&#xff09; 步骤&#xff1a; 1&#xff09;.修…
阅读更多...
智能分布式爬虫的数据处理流水线优化：基于深度强化学习的数据质量控制

智能分布式爬虫的数据处理流水线优化：基于深度强化学习的数据质量控制

在数字化浪潮席卷全球的今天&#xff0c;数据已成为企业和研究机构的核心资产。智能分布式爬虫作为高效的数据采集工具&#xff0c;在大规模数据获取中发挥着关键作用。然而&#xff0c;传统的数据处理流水线在面对复杂多变的网络环境和海量异构数据时&#xff0c;常出现数据质…
阅读更多...
OPenCV CUDA模块图像处理-----对图像执行 均值漂移滤波（Mean Shift Filtering）函数meanShiftFiltering()

OPenCV CUDA模块图像处理-----对图像执行 均值漂移滤波（Mean Shift Filtering）函数meanShiftFiltering()

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 在 GPU 上对图像执行 均值漂移滤波&#xff08;Mean Shift Filtering&#xff09;&#xff0c;用于图像分割或平滑处理。 该函数将输入图像中的…
阅读更多...
AI书签管理工具开发全记录（十九）：嵌入资源处理

AI书签管理工具开发全记录（十九）：嵌入资源处理

1.前言 &#x1f4dd; 在上一篇文章中&#xff0c;我们完成了书签的导入导出功能。本篇文章我们研究如何处理嵌入资源&#xff0c;方便后续将资源打包到一个可执行文件中。 2.embed介绍 &#x1f3af; Go 1.16 引入了革命性的 embed 包&#xff0c;彻底改变了静态资源管理的…
阅读更多...
分布式增量爬虫实现方案

分布式增量爬虫实现方案

之前我们在讨论的是分布式爬虫如何实现增量爬取。增量爬虫的目标是只爬取新产生或发生变化的页面&#xff0c;避免重复抓取&#xff0c;以节省资源和时间。 在分布式环境下&#xff0c;增量爬虫的实现需要考虑多个爬虫节点之间的协调和去重。 另一种思路&#xff1a;将增量判…
阅读更多...
Maven 概述、安装、配置、仓库、私服详解

Maven 概述、安装、配置、仓库、私服详解

目录 1、Maven 概述 1.1 Maven 的定义 1.2 Maven 解决的问题 1.3 Maven 的核心特性与优势 2、Maven 安装 2.1 下载 Maven 2.2 安装配置 Maven 2.3 测试安装 2.4 修改 Maven 本地仓库的默认路径 3、Maven 配置 3.1 配置本地仓库 3.2 配置 JDK 3.3 IDEA 配置本地 Ma…
阅读更多...
Mac下Android Studio扫描根目录卡死问题记录

Mac下Android Studio扫描根目录卡死问题记录

环境信息 操作系统: macOS 15.5 (Apple M2芯片)Android Studio版本: Meerkat Feature Drop | 2024.3.2 Patch 1 (Build #AI-243.26053.27.2432.13536105, 2025年5月22日构建) 问题现象 在项目开发过程中&#xff0c;提示一个依赖外部头文件的cpp源文件需要同步&#xff0c;点…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023