首页
/ Sarama：Go语言Apache Kafka客户端库全面解析

Sarama：Go语言Apache Kafka客户端库全面解析

2026-01-14 17:39:21作者：魏侃纯Zoe
sarama
Sarama is a Go library for Apache Kafka.
项目地址：https://gitcode.com/gh_mirrors/sar/sarama

Sarama是一个MIT许可的纯Go语言编写的Apache Kafka客户端库，由IBM开发和维护。作为Go生态系统中最为成熟和广泛使用的Kafka客户端之一，Sarama为开发者提供了完整的高级别和低级别API，能够无缝集成到任何Go应用程序中，实现高效的消息生产和消费。本文将从项目概述、核心特性、生态系统定位、对比优势以及版本兼容性等多个维度全面解析Sarama客户端库。

Sarama项目概述与核心特性介绍

Sarama是一个MIT许可的纯Go语言编写的Apache Kafka客户端库，由IBM开发和维护。作为Go生态系统中最为成熟和广泛使用的Kafka客户端之一，Sarama为开发者提供了完整的高级别和低级别API，能够无缝集成到任何Go应用程序中，实现高效的消息生产和消费。

项目定位与设计哲学

Sarama的设计遵循"简单而强大"的原则，它提供了两个层次的API接口：

高级别API - 面向大多数常见使用场景，提供简单易用的接口：

  • 异步生产者(AsyncProducer)：通过通道接收消息并在后台异步高效处理
  • 同步生产者(SyncProducer)：阻塞式发送，等待Kafka确认消息投递
  • 消费者(Consumer)：支持单分区和多分区消息消费
  • 消费者组(ConsumerGroup)：实现Kafka消费者组协议，支持自动负载均衡

低级别API - 为需要精细控制的场景提供底层访问：

  • Broker连接管理：直接控制与Kafka broker的连接
  • 请求/响应对象：精确控制网络层面的消息传输
  • 协议级操作：支持所有Kafka协议操作

核心架构特性

Sarama的架构设计体现了现代分布式系统客户端的最佳实践：

classDiagram
    class Client {
        +Metadata management
        +Broker coordination
        +Connection pooling
    }
    
    class Producer {
        <<interface>>
        +SendMessage()
        +Close()
    }
    
    class Consumer {
        <<interface>>
        +ConsumePartition()
        +Close()
    }
    
    class Broker {
        +Request/Response handling
        +Connection management
    }
    
    Client --> Broker : manages
    Producer --> Client : uses
    Consumer --> Client : uses

主要功能特性

1. 完整的Kafka协议支持

Sarama实现了Apache Kafka的完整协议栈，包括：

协议类别 支持功能 说明
生产者API 消息发送、批量处理、压缩 支持GZIP、Snappy、LZ4、Zstandard压缩
消费者API 消息消费、偏移量管理 支持手动和自动提交偏移量
管理API Topic管理、ACL控制、配置管理 完整的集群管理功能
事务API 跨分区原子操作 支持Kafka事务语义

2. 高性能设计

Sarama经过深度优化，具备出色的性能表现：

  • 连接池管理：复用TCP连接，减少连接建立开销
  • 批量处理：自动合并小消息为批量请求
  • 零拷贝优化：减少内存分配和复制操作
  • 异步IO：非阻塞网络操作，最大化吞吐量

3. 企业级特性

flowchart TD
    A[安全认证] --> B[SASL/SCRAM]
    A --> C[SASL/GSSAPI Kerberos]
    A --> D[SASL/PLAIN]
    
    E[监控指标] --> F[Prometheus集成]
    E --> G[性能指标收集]
    E --> H[健康检查]
    
    I[容错机制] --> J[自动重试]
    I --> K[故障转移]
    I --> L[背压控制]

4. 丰富的压缩支持

Sarama支持多种消息压缩算法，可根据业务需求选择最优方案：

压缩算法 压缩比 CPU开销 适用场景
GZIP 高 高 高带宽节省场景
Snappy 中 低 平衡性能与压缩
LZ4 中高 很低 高性能需求场景
Zstandard 很高 中 最佳压缩效率

代码示例：基础使用

以下示例展示了Sarama的基本使用方法：

// 生产者示例
config := sarama.NewConfig()
config.Producer.Return.Successes = true

producer, err := sarama.NewSyncProducer([]string{"localhost:9092"}, config)
if err != nil {
    log.Fatalf("Error creating producer: %v", err)
}
defer producer.Close()

msg := &sarama.ProducerMessage{
    Topic: "test-topic",
    Value: sarama.StringEncoder("Hello Kafka!"),
}

partition, offset, err := producer.SendMessage(msg)
if err != nil {
    log.Printf("Failed to send message: %v", err)
} else {
    log.Printf("Message sent to partition %d at offset %d", partition, offset)
}

// 消费者示例
consumer, err := sarama.NewConsumer([]string{"localhost:9092"}, config)
if err != nil {
    log.Fatalf("Error creating consumer: %v", err)
}
defer consumer.Close()

partitionConsumer, err := consumer.ConsumePartition("test-topic", 0, sarama.OffsetNewest)
if err != nil {
    log.Fatalf("Error creating partition consumer: %v", err)
}
defer partitionConsumer.Close()

for msg := range partitionConsumer.Messages() {
    log.Printf("Consumed message: %s", string(msg.Value))
}

生态系统集成

Sarama与Go生态系统深度集成，支持：

  • 标准日志接口：兼容所有符合StdLogger接口的日志库
  • Metrics收集：通过go-metrics库暴露丰富的性能指标
  • 测试框架：提供完整的Mock对象，便于单元测试
  • 配置管理：与各种配置管理方案无缝集成

版本兼容性保证

Sarama遵循严格的语义化版本控制，并提供"2个发布版本 + 2个月"的兼容性保证：

  • 支持最新的两个稳定Kafka版本
  • 支持最新的两个稳定Go版本
  • 为旧版本提供2个月的过渡期

这种兼容性策略确保了项目的长期稳定性，同时允许用户有计划地进行升级。

Sarama作为Go语言中Kafka客户端的事实标准，其成熟度、功能完整性和性能表现都经过了大规模生产环境的验证，是构建基于Kafka的分布式系统的理想选择。

Sarama在Kafka生态系统中的定位

Sarama作为Apache Kafka的纯Go语言客户端库，在Kafka生态系统中扮演着至关重要的角色。它不仅是Go开发者接入Kafka的首选方案，更是连接Go语言生态与Kafka分布式消息系统的重要桥梁。

多语言生态中的Go语言代表

在Kafka的多语言客户端生态中，Sarama代表了Go语言的官方级实现。与其他主流语言客户端形成完整的生态矩阵：

语言 主要客户端 特点
Java Kafka Client 官方原生支持，功能最全面
Go Sarama 高性能，纯Go实现，无外部依赖
Python kafka-python 易用性强，Python生态集成
.NET Confluent.Kafka 基于librdkafka，性能优异
Node.js kafkajs 现代API设计，TypeScript支持

Sarama填补了Go语言在Kafka生态中的空白，为Go开发者提供了与企业级Kafka集群无缝集成的能力。

功能完备性定位

Sarama提供了从底层协议到高层API的完整功能栈：

graph TB
    A[Sarama功能架构] --> B[生产者API]
    A --> C[消费者API]
    A --> D[管理API]
    A --> E[底层协议]
    
    B --> B1[异步生产者]
    B --> B2[同步生产者]
    B --> B3[事务生产者]
    
    C --> C1[消费者组]
    C --> C2[独立消费者]
    C --> C3[偏移量管理]
    
    D --> D1[主题管理]
    D --> D2[ACL管理]
    D --> D3[配置管理]
    D --> D4[集群监控]
    
    E --> E1[请求/响应编码]
    E --> E2[协议版本协商]
    E --> E3[错误处理]

这种分层架构使得Sarama既能满足简单的消息收发需求，也能处理复杂的分布式事务和集群管理任务。

性能与稳定性定位

Sarama在性能方面定位为高性能Go客户端，具有以下核心特性：

  • 零拷贝设计：最大限度减少内存分配和复制操作
  • 连接池管理：智能的Broker连接重用机制
  • 批量处理优化：支持消息批量生产和压缩
  • 背压控制：内置流量控制防止系统过载
// 高性能生产者配置示例
config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal       // 高性能确认模式
config.Producer.Compression = sarama.CompressionSnappy   // Snappy压缩
config.Producer.Flush.Frequency = 500 * time.Millisecond // 批量刷新频率
config.Producer.Flush.Bytes = 1024 * 1024               // 1MB批量大小
config.Producer.Return.Successes = true                 // 成功回调

企业级特性支持

在企业级应用场景中，Sarama提供了完整的安全和管理功能：

企业特性 支持情况 应用场景
SASL认证 全面支持 Kerberos, PLAIN, SCRAM
SSL/TLS加密 完整支持 传输层安全加密
ACL访问控制 管理API支持 细粒度权限管理
事务支持 完整实现 精确一次语义(EOS)
监控指标 内置支持 Prometheus集成

云原生生态集成

在现代云原生架构中，Sarama与主流云平台和编排系统深度集成：

flowchart LR
    A[Kubernetes] --> B[Sarama客户端]
    C[服务网格] --> B
    D[监控系统] --> B
    E[配置中心] --> B
    B --> F[Apache Kafka集群]
    
    B --> G[指标导出]
    B --> H[健康检查]
    B --> I[动态配置]

这种集成能力使得Sarama成为云原生微服务架构中消息处理的核心组件。

开发者生态定位

Sarama在开发者生态中定位为：

  1. API友好性：提供符合Go语言习惯的API设计
  2. 文档完整性：详细的Godoc文档和示例代码
  3. 测试覆盖度：高测试覆盖率确保代码质量
  4. 社区活跃度：活跃的GitHub社区和及时的问题响应
  5. 版本兼容性：严格的语义版本控制和向后兼容承诺

未来演进方向

随着Kafka协议的不断演进，Sarama的定位也在持续扩展：

  • Kafka 3.x新特性：逐步支持最新协议版本特性
  • Quarkus集成：与Java生态的深度互操作
  • Serverless适配：更好地适应无服务器架构
  • 多语言互操作：增强与其他语言客户端的兼容性

Sarama在Kafka生态系统中的定位不仅是一个功能完备的客户端库，更是Go语言在分布式系统领域的重要基础设施。它通过持续的技术演进和生态建设，为Go开发者提供了与企业级Kafka集群深度集成的完整解决方案。

Sarama与其他Kafka客户端的对比优势

在Go语言的Kafka客户端生态系统中，Sarama凭借其独特的优势脱颖而出，成为众多开发者的首选。与其他Kafka客户端相比，Sarama在性能、易用性、功能完整性和社区支持等方面都表现出显著优势。

原生Go语言实现的高性能优势

Sarama作为纯Go语言实现的Kafka客户端，充分利用了Go语言的并发特性，提供了卓越的性能表现：

graph TD
    A[Go语言特性] --> B[Goroutine轻量级线程]
    A --> C[Channel通信机制]
    A --> D[高效内存管理]
    
    B --> E[高并发处理能力]
    C --> F[线程安全的消息传递]
    D --> G[低内存占用]
    
    E --> H[高性能消息处理]
    F --> I[可靠的并发控制]
    G --> J[优秀的资源利用率]
    
    H --> K[Sarama性能优势]
    I --> K
    J --> K

与其他基于JVM的Kafka客户端相比，Sarama在以下几个方面具有明显优势：

特性对比 Sarama (Go) Java客户端 优势说明
启动时间 毫秒级 秒级 Go编译为静态二进制，无JVM启动开销
内存占用 较低 较高 Go运行时内存管理更高效
并发性能 优秀 良好 Goroutine比线程更轻量
部署复杂度 简单 复杂 单二进制文件，无需JRE环境

完整的协议支持和功能特性

Sarama实现了完整的Kafka协议规范，支持从0.8到最新版本的所有特性：

// Sarama支持丰富的配置选项示例
config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForAll
config.Producer.Return.Successes = true
config.Producer.Partitioner = sarama.NewRandomPartitioner
config.Producer.Idempotent = true  // 支持精确一次语义
config.Net.SASL.Enable = true      // 支持SASL认证
config.Net.TLS.Enable = true       // 支持TLS加密

功能完整性对比表：

功能特性 Sarama支持 其他Go客户端支持 说明
事务支持 ✅ 完整 ⚠️ 部分 支持生产者事务和消费者事务
SASL认证 ✅ 多种机制 ⚠️ 有限 支持PLAIN、SCRAM、GSSAPI等
压缩算法 ✅ 全面 ⚠️ 部分 支持GZIP、Snappy、LZ4、Zstandard
监控指标 ✅ 丰富 ❌ 有限 内置完善的metrics收集

优秀的开发者体验和易用性

Sarama提供了清晰的API设计和详尽的文档支持，大大降低了开发者的学习成本：

flowchart TD
    A[开发者需求] --> B{选择客户端}
    B -->|高性能| C[Sarama]
    B -->|易用性| C
    B -->|功能完整| C
    
    C --> D[API设计]
    D --> E[同步/异步生产者]
    D --> F[消费者组API]
    D --> G[管理API]
    
    E --> H[简单直观]
    F --> I[自动重平衡]
    G --> J[集群管理]
    
    H --> K[快速上手]
    I --> L[可靠消费]
    J --> M[便捷运维]

易用性特性对比：

  1. 清晰的API分层：

    • 高级API：简单的生产消费接口
    • 低级API：精确的协议控制
    • 管理API：完整的集群管理功能

  2. 完善的错误处理：

    • 详细的错误码和错误信息
    • 自动重试机制
    • 死信队列支持

  3. 丰富的示例代码：

    • 生产者示例
    • 消费者示例
    • 事务处理示例
    • 认证配置示例

强大的社区支持和生态整合

Sarama作为CNCF生态下的重要组件，拥有活跃的社区支持和广泛的生态整合：

pie title Sarama生态系统整合
    "Kubernetes Operator" : 35
    "监控系统" : 25
    "CI/CD工具" : 20
    "测试框架" : 15
    "其他中间件" : 5

社区优势体现：

  • 活跃的维护：IBM主导开发，定期更新和bug修复
  • 广泛的采用：被众多知名项目使用，如Kubernetes、Prometheus等
  • 完善的文档：详细的API文档和最佳实践指南
  • 丰富的扩展：支持各种中间件和监控系统集成

卓越的性能调优能力

Sarama提供了细粒度的性能调优选项，可以根据具体场景进行优化：

// 性能调优配置示例
config := sarama.NewConfig()
config.Net.MaxOpenRequests = 5           // 连接并发控制
config.Producer.Flush.Frequency = 500 * time.Millisecond // 批量发送频率
config.Producer.Flush.Bytes = 1024 * 1024 // 批量发送大小
config.Producer.Retry.Max = 10           // 重试次数
config.Metadata.RefreshFrequency = 10 * time.Minute // 元数据刷新频率

性能调优对比优势：

调优维度 Sarama灵活性 其他客户端灵活性 优势说明
批量处理 高度可配置 有限配置 支持按大小、时间、数量多维度控制
并发控制 精细控制 粗粒度控制 支持连接级、请求级并发控制
内存管理 智能优化 基本控制 支持内存使用上限和缓冲控制
网络优化 全面支持 部分支持 支持连接池、超时、重试等

可靠的生产环境稳定性

经过大规模生产环境的验证，Sarama在稳定性方面表现出色：

  • 经过验证的可靠性：在众多大型互联网公司生产环境运行
  • 完善的错误恢复：自动处理网络异常、broker故障等场景
  • 详细的状态监控：提供丰富的metrics指标用于监控告警
  • 平滑的版本升级：遵循语义化版本，保证API兼容性

Sarama凭借其原生Go实现的高性能、完整的功能特性、优秀的开发者体验、强大的社区支持和卓越的性能调优能力，在与其他Kafka客户端的对比中展现出明显优势，是Go语言开发者处理Kafka消息的首选解决方案。

Sarama的版本兼容性与API稳定性

在分布式消息系统开发中，版本兼容性和API稳定性是决定项目长期可维护性的关键因素。Sarama作为Go语言中最成熟的Apache Kafka客户端库，在这方面提供了业界领先的保障机制。本节将深入解析Sarama的版本兼容性策略、API稳定性保证机制以及在实际开发中的最佳实践。

版本兼容性策略

Sarama采用"2 releases + 2 months"的兼容性保证策略，这意味着：

  • Kafka版本支持：支持最新的两个稳定Kafka版本
  • Go语言版本支持：支持最新的两个稳定Go版本
  • 宽限期：为旧版本提供两个月的过渡期

这种策略确保了Sarama能够及时跟进Kafka社区的最新特性，同时为现有用户提供足够的升级缓冲时间。

支持的Kafka版本范围

Sarama支持从Kafka 0.8.2.0到4.0.0.0的广泛版本范围，涵盖了近十年的Kafka发展历程：

timeline
    title Sarama支持的Kafka版本时间线
    section 早期版本
        2013 : 0.8.2.0
        2015 : 0.9.0.0
    section 主要版本
        2017 : 1.0.0.0
        2018 : 2.0.0.0
        2020 : 2.6.0.0
    section 现代版本
        2021 : 3.0.0.0
        2023 : 3.6.0.0
        2024 : 4.0.0.0

版本比较机制

Sarama提供了强大的版本比较功能，通过KafkaVersion结构体和相关方法实现：

// KafkaVersion实例代表上游Kafka broker的版本
type KafkaVersion struct {
    version [4]uint // 主版本.次版本.修订版本.补丁版本
}

// IsAtLeast方法判断当前版本是否大于等于指定版本
func (v KafkaVersion) IsAtLeast(other KafkaVersion) bool {
    for i := range v.version {
        if v.version[i] > other.version[i] {
            return true
        } else if v.version[i] < other.version[i] {
            return false
        }
    }
    return true
}

// 使用示例
if currentVersion.IsAtLeast(sarama.V2_1_0_0) {
    // 可以使用2.1.0.0及以上版本的特性
}

API稳定性保证

Sarama遵循语义化版本控制（Semantic Versioning）规范，并通过Go模块版本编号方案提供API稳定性：

版本号语义

版本号变化 含义 兼容性保证
MAJOR版本变更 不兼容的API修改 需要代码调整
MINOR版本变更 向后兼容的功能性新增 安全升级
PATCH版本变更 向后兼容的问题修复 推荐升级

撤回机制（Retract）

Sarama在go.mod文件中使用retract指令明确标识存在问题的版本，保护用户免受已知问题的影响：

retract (
    v1.32.0 // producer hangs on retry https://github.com/IBM/sarama/issues/2150
    [v1.31.0, v1.31.1] // producer deadlock https://github.com/IBM/sarama/issues/2129
    [v1.26.0, v1.26.1] // consumer fetch session allocation 
    [v1.24.1, v1.25.0] // consumer group metadata reqs
)

这种透明的撤回机制确保了用户不会意外使用存在严重问题的版本。

协议版本协商

Sarama实现了智能的协议版本协商机制，能够根据配置的Kafka版本自动选择最合适的协议版本：

// 配置示例：明确指定Kafka版本
config := sarama.NewConfig()
config.Version = sarama.V2_1_0_0

// Sarama会根据配置的版本自动选择协议版本
// 例如：对于V2_1_0_0版本，会使用对应的MetadataRequest V6-V10

协议版本选择流程

flowchart TD
    A[应用程序配置Kafka版本] --> B{Sarama检测配置版本}
    B --> C[版本有效?]
    C -->|是| D[选择对应的协议版本范围]
    C -->|否| E[使用默认协议版本]
    D --> F[与Broker协商确定具体版本]
    E --> F
    F --> G[建立连接并使用协商版本]

向后兼容性处理

Sarama在处理向后兼容性方面表现出色，特别是在以下场景：

1. 消息格式兼容性

// 在offset_response.go中处理向后兼容性
func (r *OffsetResponse) decode(pd packetDecoder) (err error) {
    // 为了向后兼容，将offset也放入offsets数组中
    if r.Version >= 1 {
        // 新版本的处理逻辑
    } else {
        // 旧版本的处理逻辑
    }
}

2. 分区策略兼容性

// 在partitioner.go中维护向后兼容性
// 虽然现在有更好的实现，但需要保持向后兼容
// 对于已经开始使用特定配置的用户

最佳实践建议

1. 版本配置明确化

始终在配置中明确指定Kafka版本，避免依赖默认值：

config := sarama.NewConfig()
config.Version = sarama.V2_1_0_0 // 明确指定版本

2. 版本检查策略

在生产代码中加入版本检查，确保功能可用性：

func checkFeatureAvailability(version sarama.KafkaVersion) {
    if !version.IsAtLeast(sarama.V2_0_0_0) {
        log.Warn("某些高级功能需要Kafka 2.0+版本")
    }
}

3. 升级测试矩阵

建立完整的升级测试矩阵，覆盖不同版本组合：

Sarama版本 Kafka版本 Go版本 测试状态
v1.42.x 3.6.0 1.23 ✅ 通过
v1.42.x 3.5.0 1.22 ✅ 通过
v1.41.x 3.4.0 1.21 ⚠️ 部分功能

4. 监控和告警

实施版本监控，及时发现兼容性问题：

// 监控当前使用的Kafka版本
func monitorKafkaVersion(client sarama.Client) {
    brokerVersions := client.Brokers()
    for _, broker := range brokerVersions {
        if !broker.Version().IsAtLeast(minRequiredVersion) {
            alert.IncompatibleVersion(broker.Addr(), broker.Version())
        }
    }
}

故障排除与常见问题

1. 版本不匹配错误

当出现协议版本不匹配时，Sarama会提供清晰的错误信息：

ERROR: kafka: protocol request was for an invalid or unsupported version

解决方案：检查并更新config.Version配置，确保与Kafka集群版本匹配。

2. 功能不可用警告

某些高级功能在旧版本Kafka上不可用，Sarama会返回适当的错误：

// 事务性生产者需要Kafka 0.11+
if !config.Version.IsAtLeast(sarama.V0_11_0_0) {
    return errors.New("事务功能需要Kafka 0.11.0或更高版本")
}

未来发展方向

Sarama团队持续关注Kafka社区的发展，未来的兼容性工作重点包括：

  1. Kafka 4.0+特性支持：完整支持Kafka 4.0的新特性和协议变更
  2. Go语言版本跟进：及时支持新的Go语言特性和性能优化
  3. 云原生适配：更好地支持Kubernetes和云环境下的版本管理
  4. 自动化测试增强：扩大测试矩阵覆盖范围，提高兼容性验证效率

通过完善的版本兼容性策略和API稳定性保证，Sarama为Go语言开发者提供了可靠、稳定的Kafka客户端解决方案，确保在各种生产环境中的长期稳定运行。

通过完善的版本兼容性策略和API稳定性保证，Sarama为Go语言开发者提供了可靠、稳定的Kafka客户端解决方案，确保在各种生产环境中的长期稳定运行。Sarama凭借其原生Go实现的高性能、完整的功能特性、优秀的开发者体验、强大的社区支持和卓越的性能调优能力，在与其他Kafka客户端的对比中展现出明显优势，是Go语言开发者处理Kafka消息的首选解决方案。

sarama
Sarama is a Go library for Apache Kafka.
项目地址：https://gitcode.com/gh_mirrors/sar/sarama
登录后查看全文
热门项目推荐
相关项目推荐

最新内容推荐

DesignPatternsPHP：如何用状态模式和命令模式实现看板工作流 探索H3：高效三维地理空间索引库Docker Cheat Sheet：数据库容器管理终极指南 🚀探索O'Reilly官方网络安全培训资源：从入门到专家的完整指南终极指南：10个纯CSS加载状态优化技巧，告别JavaScript依赖【亲测免费】 推荐一款创新的WebUI工具：OpenPose Editor 探索GitHub上的宝藏：Good First Issue Finder【亲测免费】 探索React日期范围选择器：react-daterange-picker 探索 `circular-json`: 解决JSON循环引用问题的神器AI Agents A-Z权限管理：用户角色、访问控制和权限分配完整指南

项目优选

收起
kernelkernel
deepin linux kernel
C
27
11
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
477
3.55 K
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
227
95
flutter_flutterflutter_flutter
暂无简介
Dart
727
175
ohos_react_nativeohos_react_native
React Native鸿蒙化仓库
JavaScript
287
340
pytorchpytorch
Ascend Extension for PyTorch
Python
285
319
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.27 K
702
nop-entropynop-entropy
Nop Platform 2.0是基于可逆计算理论实现的采用面向语言编程范式的新一代低代码开发平台，包含基于全新原理从零开始研发的GraphQL引擎、ORM引擎、工作流引擎、报表引擎、规则引擎、批处理引引擎等完整设计。nop-entropy是它的后端部分，采用java语言实现，可选择集成Spring框架或者Quarkus框架。中小企业可以免费商用
Java
10
1
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
849
442
leetcodeleetcode
🔥LeetCode solutions in any programming language | 多种编程语言实现 LeetCode、《剑指 Offer（第 2 版）》、《程序员面试金典（第 6 版）》题解
Java
65
19