不灭的焱

Rust crate 相当于 Java 的啥概念 ？ 其他的概念也比较一下

Rust 里的 crate，可以粗略理解为 Java 里的：

一个 Maven/Gradle 依赖包，或者一个 jar 包。

但不完全等价。更准确地说：

Rust 概念	Java 大概对应	说明
crate	Maven artifact / jar 包 / Java 模块	Rust 的最小编译单元，也是依赖发布单位
package	Maven 项目 / Gradle project	一个 Rust package 里可以包含一个或多个 crate
Cargo.toml	pom.xml / build.gradle	管理依赖、版本、构建配置
cargo	Maven / Gradle	Rust 官方构建、依赖、测试、发布工具
crates.io	Maven Central	Rust 官方/主流 crate 仓库
module / mod	Java package 的一部分概念	Rust 代码组织方式，不等于 Java package
use	import	引入模块、类型、函数
pub	public	控制可见性
trait	interface	定义能力/行为，类似 Java 接口
impl	class implements interface / 方法实现	给类型实现方法或 trait
struct	class / record / DTO	Rust 的结构体，只有数据字段，没有继承
enum	enum + sealed class	Rust enum 比 Java enum 强很多，可携带数据
workspace	Maven multi-module project	多个 package 放在一个工程里统一管理

1. crate 是什么？

Rust 的 crate 是一个编译单元，也是依赖使用的基本单位。

例如你在 Cargo.toml 里写：

[dependencies]
serde = "1"
regex = "1"

这里的 serde、regex 就是 crate。

Java 里类似：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.x.x</version>
</dependency>

所以可以理解为：

Rust crate ≈ Java Maven 依赖包 ≈ jar 包

2. package 和 crate 的区别

这个地方容易混。

Rust 里：

package 是项目单位
crate 是编译产物单位

一个 Rust package 通常长这样：

my_app/
├── Cargo.toml
└── src/
    └── main.rs

这就是一个 package，里面默认有一个二进制 crate。

如果是库项目：

my_lib/
├── Cargo.toml
└── src/
    └── lib.rs

这就是一个 package，里面默认有一个 library crate。

类比 Java：

Rust package ≈ 一个 Maven 项目
Rust crate ≈ 这个项目构建出来的 jar / 可执行程序

3. crate 有两种常见类型

1）Binary crate

类似 Java 里的可运行应用程序。

Rust：

src/main.rs

Java：

public static void main(String[] args) {
}

作用是生成一个可执行程序。

2）Library crate

类似 Java 里的公共 jar 包、工具包、SDK。

Rust：

src/lib.rs

Java：

commons-lang3.jar
jackson-databind.jar
mysql-connector.jar

作用是被其他项目引用。

4. mod 和 Java package 的区别

Rust 里的 mod 用来组织代码。

例如：

mod user;
mod order;

Java 里类似：

package com.example.user;
import com.example.order.OrderService;

但两者不是完全一样。

Java 的 package 通常和目录、命名空间强绑定：

com/example/user/UserService.java

Rust 的模块系统更灵活，但也有推荐目录规则：

src/
├── main.rs
├── user.rs
└── order.rs

或者：

src/
├── main.rs
├── user/
│   └── mod.rs
└── order/
    └── mod.rs

可以粗略理解为：

Rust mod ≈ Java package + class 文件组织方式

5. Cargo 是什么？

Cargo 是 Rust 官方工具，非常重要。

它同时负责：

依赖管理
编译构建
运行项目
执行测试
发布 crate
生成文档

对应 Java 生态：

cargo ≈ Maven / Gradle

常用命令：

cargo new demo       # 创建项目
cargo build          # 编译
cargo run            # 运行
cargo test           # 测试
cargo add serde      # 添加依赖
cargo update         # 更新依赖
cargo doc            # 生成文档
cargo publish        # 发布 crate

6. Cargo.toml 是什么？

Cargo.toml 就是 Rust 项目的配置文件。

类似 Java 的：

pom.xml
build.gradle

例如：

[package]
name = "demo"
version = "0.1.0"
edition = "2024"

[dependencies]
serde = "1"
regex = "1"

类比 Maven：

<project>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>1.0.0</version>

    <dependencies>
        ...
    </dependencies>
</project>

7. crates.io 是什么？

crates.io 是 Rust 的官方 crate 仓库。

对应 Java 里的：

Maven Central

也就是说：

Java 去 Maven Central 下载 jar
Rust 去 crates.io 下载 crate

8. trait 相当于 Java 的什么？

Rust 的 trait 很像 Java 的 interface。

Rust：

trait Fly {
    fn fly(&self);
}

Java：

interface Fly {
    void fly();
}

Rust 实现 trait：

struct Bird;

impl Fly for Bird {
    fn fly(&self) {
        println!("bird fly");
    }
}

Java 实现 interface：

class Bird implements Fly {
    public void fly() {
        System.out.println("bird fly");
    }
}

可以理解为：

Rust trait ≈ Java interface

但 Rust 的 trait 更强，常用于泛型约束、默认实现、扩展方法等。

9. struct 相当于 Java 的什么？

Rust 的 struct 类似 Java 的 class / record / DTO。

Rust：

struct User {
    name: String,
    age: u32,
}

Java：

class User {
    String name;
    int age;
}

不过 Rust 的 struct 默认只有数据，没有继承，也没有构造函数概念。方法要单独用 impl 写：

impl User {
    fn new(name: String, age: u32) -> Self {
        Self { name, age }
    }
}

10. impl 是什么？

impl 用来给类型实现方法。

Rust：

impl User {
    fn say_hello(&self) {
        println!("hello");
    }
}

Java：

class User {
    void sayHello() {
        System.out.println("hello");
    }
}

所以：

Rust impl ≈ Java class 里面写方法

如果是：

impl Display for User {
    ...
}

那就类似：

class User implements Display {
    ...
}

11. enum 相当于 Java 的什么？

Rust 的 enum 比 Java 的 enum 强很多。

Java enum：

enum Status {
    SUCCESS,
    FAILED
}

Rust enum：

enum Status {
    Success,
    Failed,
}

这部分类似。

但 Rust enum 还可以携带数据：

enum Result {
    Success(String),
    Failed(String),
}

这个更像 Java 里的：

enum + sealed class + 子类

所以可以理解为：

Rust enum ≈ Java enum 的加强版

12. workspace 相当于 Java 的什么？

Rust workspace 类似 Maven 多模块项目。

Rust：

my_workspace/
├── Cargo.toml
├── app/
│   └── Cargo.toml
├── common/
│   └── Cargo.toml
└── service/
    └── Cargo.toml

Java Maven：

parent-project/
├── pom.xml
├── app/
│   └── pom.xml
├── common/
│   └── pom.xml
└── service/
    └── pom.xml

对应关系：

Rust workspace ≈ Maven parent + multi-module

总结一句话

可以这样记：

crate      ≈ jar 包 / Maven artifact
package    ≈ Maven 项目
Cargo.toml ≈ pom.xml / build.gradle
cargo      ≈ Maven / Gradle
crates.io  ≈ Maven Central
mod        ≈ Java package / 代码模块
trait      ≈ interface
struct     ≈ class / record / DTO
impl       ≈ 方法实现 / implements
enum       ≈ 更强的 enum / sealed class
workspace  ≈ Maven 多模块工程

最关键的是：

Java 是 package + class + jar 的体系；Rust 是 package + crate + module 的体系。