2025最新！从AI对话到分布式缓存：17个仓颉语言实战项目全解析

【免费下载链接】Cangjie-Examples 本仓将收集和展示高质量的仓颉示例代码，欢迎大家投稿，让全世界看到您的妙趣设计，也让更多人通过您的编码理解和喜爱仓颉语言。 项目地址: https://gitcode.com/Cangjie/Cangjie-Examples

引言：为什么你必须掌握仓颉语言？

你是否还在为寻找高效、简洁且功能强大的编程语言而烦恼？作为华为自主研发的新一代编程语言，仓颉（Cangjie）正在迅速崛起，成为开发者们关注的焦点。它不仅融合了现代编程语言的优秀特性，还针对分布式系统、人工智能等前沿领域进行了深度优化。

本文将带你深入探索Cangjie-Examples项目仓库中的17个精选实战项目，从AI对话系统到分布式缓存，从数据结构到网络编程，全方位展示仓颉语言的强大魅力。无论你是初学者还是有经验的开发者，读完本文后，你将能够：

• 掌握仓颉语言的核心语法和高级特性
• 理解如何使用仓颉构建各类应用系统
• 学会在实际项目中应用仓颉的独特功能
• 提升自己的编程技能和项目实战经验

项目总览：17个精选实战项目

Cangjie-Examples仓库包含了丰富多样的实战项目，涵盖了从基础数据结构到高级应用开发的各个方面。以下是所有项目的分类概览：

项目类别	项目名称	主要功能	难度级别
AI与机器学习	AIChat	AI对话系统实现	中等
AI与机器学习	MINIST	基于BP神经网络的手写数字识别	高级
数据结构	BTree	B树数据结构实现	中等
网络编程	TCPChat	TCP聊天系统	入门
网络编程	TCPGroupChat	TCP群聊系统	中等
网络编程	HTTP	HTTP客户端和服务器实现	中等
数据库	OpenGauss	OpenGauss数据库连接与操作	高级
缓存系统	Redis	Redis分布式限流实现	高级
宏编程	CurryMacro	函数柯里化宏实现	高级
宏编程	DebounceThrottleMacro	防抖节流宏实现	高级
系统集成	CFFI-Windows	Windows平台CFFI调用示例	高级
算法	Combinator	组合子逻辑实现	高级
图形学	Cube	3D立方体旋转演示	中等
Web框架	RequestPipeline	请求处理管道实现	中等
函数式编程	Functional	函数式编程示例	入门
函数式编程	Combinator	组合子模式实现	中等
标准库扩展	stdx	仓颉标准库扩展	高级

核心项目深度解析

1. AIChat：打造你的智能对话系统

AIChat项目展示了如何使用仓颉语言构建一个简单但功能完整的AI对话系统。该项目使用DeepSeek-V2.5模型，通过API调用实现自然语言交互，并支持对话历史记忆功能。

项目结构

AIChat/
├── cjpm.toml        # 项目配置文件
├── preview.gif      # 演示动画
├── readme.md        # 项目说明
└── src/
    ├── llm.cj       # LLM模型封装
    └── main.cj      # 主程序

核心代码解析

主程序main.cj的核心代码如下：

package chat

main() {
    // 使用SiliconFlow提供的服务接口
    let robot = LLM(url: 'https://api.siliconflow.cn/v1/chat/completions',
        // 如果示例自带的密钥失效，请自行注册获取
        key: 'sk-ujrvulmnsdiolckgtjklhqbwbkfudgeglrkxxb...',
        model: 'deepseek-ai/DeepSeek-V2.5',
        memory: true)

    robot.preset('我会用林黛玉的风格回复哥哥的所有问题')
    robot.chats('介绍李白')
    println('\n----------\n')
    robot.chats('他和安徽的不解情缘')
    println('\n----------\n')
    robot.reset()
    robot.chat('介绍杨万里') |> println
    println('\n----------\n')
    robot.chat('却是荷池跳雨，散了真珠还聚') |> println
}

这段代码展示了如何使用仓颉语言快速构建一个AI对话系统。核心步骤包括：

1. 创建LLM实例，配置API地址、密钥、模型名称和对话记忆功能
2. 设置对话预设，定义AI的回复风格
3. 进行多轮对话，展示上下文记忆功能
4. 重置对话状态，开始新的对话

通过这个项目，你可以学习到：

• 如何在仓颉中进行HTTP请求
• 如何处理JSON数据
• 如何实现状态管理
• 如何封装外部API调用

2. Redis：分布式限流系统实现

Redis项目展示了如何使用仓颉语言结合Redis实现分布式限流功能。该项目包含本地限流和基于Redis的分布式限流两种实现方式，适合在分布式系统中保护API接口。

项目结构

Redis/
├── dependencies/    # 依赖库
│   ├── hyperion/    # 网络库
│   └── redis_sdk/   # Redis SDK
├── src/
│   ├── main.cj      # 主程序
│   ├── service/     # 服务实现
│   │   ├── LocalTokensLimiter.cj    # 本地限流实现
│   │   └── RedisTokensLimiter.cj    # Redis限流实现
│   └── utils/       # 工具类
│       ├── MathUtils.cj    # 数学工具
│       └── TimeUtils.cj    # 时间工具
├── cjpm.toml        # 项目配置
├── docker-compose.yml # Docker配置
└── README.md        # 项目说明

核心限流算法实现

RedisTokensLimiter.cj中的核心限流算法实现：

// 基于Redis的令牌桶限流实现
class RedisTokensLimiter {
    let redisClient: RedisClient
    let capacity: Int  // 令牌桶容量
    let rate: Int      // 令牌生成速率(个/秒)
    let key: String    // Redis键名

    new(redisClient: RedisClient, capacity: Int, rate: Int, key: String) {
        this.redisClient = redisClient
        this.capacity = capacity
        this.rate = rate
        this.key = key
    }

    // 判断是否允许请求通过
    func allow(): Bool {
        let now = TimeUtils.currentTimeMillis()
        let pipeline = redisClient.pipeline()
        
        // 使用Redis管道执行多个命令
        pipeline.multi()
        pipeline.hset(key, "last_refill_time", now.toString())
        pipeline.hset(key, "tokens_left", capacity.toString())
        pipeline.expire(key, 3600)  // 设置过期时间
        let result = pipeline.exec()
        
        // 计算当前可用令牌数
        let tokensLeft = calculateTokensLeft(now)
        if tokensLeft > 0 {
            // 消耗一个令牌
            redisClient.hincrby(key, "tokens_left", -1)
            return true
        }
        return false
    }

    // 计算当前可用令牌数
    func calculateTokensLeft(now: Int64): Int {
        // 实现令牌桶算法逻辑
        // ...
    }
}

这个分布式限流实现使用了Redis的哈希结构存储限流相关的信息，包括最后填充令牌的时间和当前剩余令牌数。通过令牌桶算法，可以平滑限制请求的速率，保护后端服务不被过载。

3. TCPChat和TCPGroupChat：网络编程实战

TCPChat和TCPGroupChat项目展示了如何使用仓颉语言进行网络编程，实现基于TCP协议的聊天系统。这两个项目分别实现了一对一聊天和群组聊天功能，是学习网络编程的绝佳示例。

TCP服务器核心实现

TCPChat/src/server/server.cj中的核心代码：

package tcpserver

import std.net

class TCPServer {
    let listener: TcpListener
    let running: Bool = true

    new(port: Int) {
        listener = TcpListener.bind("0.0.0.0", port)
        println("服务器启动，监听端口: {port}")
    }

    func start() {
        while running {
            // 接受客户端连接
            let client = listener.accept()
            println("新客户端连接: {client.remoteAddr}")
            
            // 启动新线程处理客户端消息
            thread {
                handleClient(client)
            }
        }
    }

    func handleClient(client: TcpStream) {
        let reader = BufferedReader(InputStreamReader(client.inputStream))
        let writer = PrintWriter(client.outputStream)
        
        try {
            while true {
                // 读取客户端消息
                let message = reader.readLine()
                if message == null {
                    break
                }
                println("收到消息: {message}")
                
                // 回复客户端
                writer.println("服务器收到: {message}")
                writer.flush()
            }
        } catch (e: IOException) {
            println("客户端连接异常: {e.message}")
        } finally {
            client.close()
            println("客户端断开连接")
        }
    }

    func stop() {
        running = false
        listener.close()
    }
}

main() {
    let server = TCPServer(8888)
    server.start()
}

这段代码实现了一个简单的TCP服务器，它能够接受客户端连接并处理消息。服务器在启动后会监听指定端口，当有新客户端连接时，会创建一个新线程来处理该客户端的消息收发。

TCPGroupChat项目在此基础上增加了客户端管理和消息广播功能，实现了群聊功能：

// 群聊服务器中的消息广播实现
func broadcast(message: String, sender: TcpStream) {
    lock(clients) {
        for client in clients {
            if client != sender {
                try {
                    let writer = PrintWriter(client.outputStream)
                    writer.println(message)
                    writer.flush()
                } catch (e: IOException) {
                    println("消息发送失败: {e.message}")
                }
            }
        }
    }
}

4. BTree：数据结构实现

BTree项目展示了如何使用仓颉语言实现B树数据结构，包括类、枚举、函数和属性的定义。B树是一种自平衡的树数据结构，常用于数据库和文件系统中。

B树节点定义

BTree/class.cj中的核心代码：

// B树节点类定义
class BTreeNode<K: Comparable, V> {
    let degree: Int
    let keys: Array<K>
    let values: Array<V>
    let children: Array<BTreeNode<K, V>?>
    var isLeaf: Bool

    new(degree: Int, isLeaf: Bool) {
        this.degree = degree
        this.isLeaf = isLeaf
        this.keys = Array<K>(size: 2*degree - 1)
        this.values = Array<V>(size: 2*degree - 1)
        this.children = Array<BTreeNode<K, V>?>(size: 2*degree)
    }

    // 分裂节点
    func splitChild(i: Int, child: BTreeNode<K, V>) {
        let newChild = BTreeNode<K, V>(degree, child.isLeaf)
        newChild.keys.size = degree - 1
        
        // 复制关键字
        for j in 0..<degree-1 {
            newChild.keys[j] = child.keys[j+degree]
            newChild.values[j] = child.values[j+degree]
        }
        
        // 复制子节点
        if !child.isLeaf {
            for j in 0..<degree {
                newChild.children[j] = child.children[j+degree]
            }
        }
        
        child.keys.size = degree - 1
        
        // 移动当前节点的子节点
        for j in keys.size..i+1 {
            children[j+1] = children[j]
        }
        
        children[i+1] = newChild
        
        // 移动当前节点的关键字
        for j in keys.size..i {
            keys[j+1] = keys[j]
            values[j+1] = values[j]
        }
        
        keys[i] = child.keys[degree-1]
        values[i] = child.values[degree-1]
        keys.size += 1
    }

    // 插入关键字（非满节点）
    func insertNonFull(key: K, value: V) {
        var i = keys.size - 1
        
        if isLeaf {
            // 叶子节点直接插入
            while i >= 0 && key < keys[i] {
                keys[i+1] = keys[i]
                values[i+1] = values[i]
                i -= 1
            }
            keys[i+1] = key
            values[i+1] = value
            keys.size += 1
        } else {
            // 内部节点，找到子节点
            while i >= 0 && key < keys[i] {
                i -= 1
            }
            i += 1
            
            // 检查子节点是否已满
            if children[i].keys.size == 2*degree - 1 {
                // 分裂子节点
                splitChild(i, children[i])
                
                // 分裂后决定插入哪个子节点
                if key > keys[i] {
                    i += 1
                }
            }
            children[i].insertNonFull(key, value)
        }
    }
    
    // 其他方法...
}

B树的实现涉及到节点分裂、关键字插入、范围查询等复杂操作，通过这个项目，你可以深入理解B树的工作原理和实现细节。

5. CurryMacro：宏编程的艺术

CurryMacro项目展示了如何使用仓颉的宏系统实现函数柯里化（Currying）。柯里化是一种将接受多个参数的函数转换为一系列只接受一个参数的函数的技术。

柯里化宏实现

CurryMacro/src/macros/makecurry.cj中的核心代码：

// 柯里化宏定义
macro make_curry(func: ident, arity: int) {
    // 根据函数参数数量生成柯里化版本
    match arity {
        1 => {
            // 1个参数，直接返回原函数
            quote {
                fn $(func)<T1, R>(f: fn(T1) -> R) -> fn(T1) -> R {
                    return f
                }
            }
        }
        2 => {
            // 2个参数，生成接受第一个参数并返回函数的版本
            quote {
                fn $(func)<T1, T2, R>(f: fn(T1, T2) -> R) -> fn(T1) -> fn(T2) -> R {
                    return |a: T1| -> fn(T2) -> R {
                        return |b: T2| -> R {
                            f(a, b)
                        }
                    }
                }
            }
        }
        3 => {
            // 3个参数，生成嵌套柯里化函数
            quote {
                fn $(func)<T1, T2, T3, R>(f: fn(T1, T2, T3) -> R) -> fn(T1) -> fn(T2) -> fn(T3) -> R {
                    return |a: T1| -> fn(T2) -> fn(T3) -> R {
                        return |b: T2| -> fn(T3) -> R {
                            return |c: T3| -> R {
                                f(a, b, c)
                            }
                        }
                    }
                }
            }
        }
        _ => {
            // 不支持的参数数量
            error!("make_curry macro only supports functions with 1-3 parameters")
        }
    }
}

使用这个宏，我们可以轻松地将普通函数转换为柯里化函数：

// 普通函数
fn add(a: Int, b: Int, c: Int) -> Int {
    return a + b + c
}

// 使用宏生成柯里化版本
make_curry!(curried_add, 3)

main() {
    let add3 = curried_add(add)
    let add2 = add3(1)
    let add1 = add2(2)
    let result = add1(3) // 结果为6
    println(result)
}

柯里化宏展示了仓颉语言的元编程能力，通过宏，我们可以在编译时生成代码，大大提高代码的复用性和灵活性。

仓颉语言高级特性解析

1. 宏系统：代码生成的利器

仓颉语言提供了强大的宏系统，允许开发者在编译时生成代码。CurryMacro和DebounceThrottleMacro项目展示了宏的实际应用。宏可以：

• 生成重复代码，减少冗余
• 实现领域特定语言（DSL）
• 提供编译时检查
• 实现高级语言特性

DebounceThrottleMacro项目实现了防抖和节流宏，这两个宏可以用于限制函数的执行频率，在UI事件处理中非常有用：

// 防抖宏使用示例
@Debounce(delay: 500)
func handleInput(event: InputEvent) {
    // 处理输入事件
    // ...
}

// 节流宏使用示例
@Throttle(interval: 1000)
func handleScroll(event: ScrollEvent) {
    // 处理滚动事件
    // ...
}

2. 并发编程：线程与异步

仓颉语言提供了完善的并发编程支持，包括线程、锁、原子操作等。Features/thread.cj文件展示了如何使用仓颉的线程功能：

// 线程使用示例
func thread_demo() {
    let counter = AtomicInt(0)
    let threads = Array<Thread>(size: 10)
    
    // 创建10个线程
    for i in 0..<10 {
        threads[i] = thread {
            for _ in 0..<1000 {
                counter.fetch_add(1)
            }
        }
    }
    
    // 等待所有线程完成
    for i in 0..<10 {
        threads[i].join()
    }
    
    println("计数器结果: {counter.load()}") // 应该输出10000
}

3. 函数式编程：不可变性与高阶函数

仓颉语言支持函数式编程范式，提供了不可变数据类型、高阶函数、 lambda表达式等特性。Functional项目展示了如何使用仓颉进行函数式编程：

// 字符串分割函数示例（string_split_1.cj）
fn split_str(s: String, delimiter: Char) -> Array<String> {
    let result = Array<String>()
    let current = String()
    
    for c in s.chars() {
        if c == delimiter {
            result.append(current)
            current = String()
        } else {
            current.push(c)
        }
    }
    
    if current.size > 0 {
        result.append(current)
    }
    
    return result
}

// 使用高阶函数的实现（string_split_2.cj）
fn split_str_func(s: String, delimiter: Char) -> Array<String> {
    return s.chars()
        .fold(
            (Array<String>(), String()),
            |(mut acc, mut current), c| {
                if c == delimiter {
                    acc.append(current)
                    (acc, String())
                } else {
                    current.push(c)
                    (acc, current)
                }
            }
        )
        .let(|(mut acc, current)| {
            if current.size > 0 {
                acc.append(current)
            }
            acc
        })
}

项目实战指南：从零开始构建你的仓颉应用

1. 环境搭建

要开始使用仓颉语言开发应用，你需要先搭建开发环境：

# 克隆仓库
git clone https://gitcode.com/Cangjie/Cangjie-Examples

# 进入项目目录
cd Cangjie/Cangjie-Examples

# 选择一个项目，例如AIChat
cd AIChat

# 构建项目
cjpm build

# 运行项目
cjpm run

2. 项目构建流程

大多数仓颉项目使用cjpm（仓颉包管理器）进行构建和依赖管理。cjpm.toml文件用于配置项目信息和依赖：

# cjpm.toml示例
[package]
name = "AIChat"
version = "0.1.0"
edition = "2024"
description = "AI对话系统示例"
authors = ["Cangjie Developer"]

[dependencies]
std = { version = "0.1.0" }
http = { version = "0.1.0" }
json = { version = "0.1.0" }

3. 调试与测试

仓颉语言提供了完善的调试和测试工具。以MINIST项目为例，你可以这样运行测试：

# 进入MINIST项目
cd MINIST

# 运行测试
cjpm test

进阶学习路线

掌握了基础项目后，你可以按照以下路线图深入学习仓颉语言：

总结与展望

通过本文介绍的17个实战项目，我们深入探索了仓颉语言的核心特性和应用场景。从AI对话系统到分布式缓存，从数据结构到网络编程，仓颉语言展现出了强大的表达能力和广泛的应用前景。

随着华为对仓颉语言的持续投入和开源社区的不断发展，我们有理由相信，仓颉将成为未来编程领域的重要力量。无论你是想提升自己的编程技能，还是寻找一种高效的语言来构建复杂系统，仓颉都是一个值得学习和尝试的选择。

最后，鼓励你：

• 点赞本文，让更多人了解仓颉语言
• 收藏本文，作为学习仓颉的参考资料
• 关注Cangjie-Examples仓库，获取最新的项目和示例
• 尝试贡献自己的仓颉项目，参与开源社区建设

未来，我们将继续推出更多关于仓颉语言的深入教程，包括高级宏编程、分布式系统设计、性能优化等主题。敬请期待！

附录：资源与参考

1. 仓颉语言官方文档
2. Cangjie-Examples项目仓库：https://gitcode.com/Cangjie/Cangjie-Examples
3. 仓颉包管理器（cjpm）使用指南
4. 仓颉标准库参考手册
5. 仓颉社区论坛与讨论组

【免费下载链接】Cangjie-Examples 本仓将收集和展示高质量的仓颉示例代码，欢迎大家投稿，让全世界看到您的妙趣设计，也让更多人通过您的编码理解和喜爱仓颉语言。 项目地址: https://gitcode.com/Cangjie/Cangjie-Examples