TinyZ's Blog

Rust语言从入门到精通系列 - SeaORM框架实战(数据库DML篇)

Tue, 30 May 2023 00:00:00 GMT

SeaORM是一个Rust语言的ORM框架，提供了简单易用的API，可以帮助我们轻松地操作数据库。SeaORM支持多种数据库，包括MySQL、PostgreSQL、SQLite等等。

在本教程中，我们将以Animal实体为例，介绍SeaORM的基本用法，包括创建表、增删改查等操作。

准备工作#

在MySQL中创建一个名为animals的数据库，并在其中创建一个名为animal的表，用于存储动物的信息。表结构如下：

1
CREATE TABLE `animal` (
2
  `id` int(11) NOT NULL AUTO_INCREMENT,
3
  `name` varchar(255) NOT NULL,
4
  `age` int(11) NOT NULL,
5
  `species` varchar(255) NOT NULL,
6
  PRIMARY KEY (`id`)
7
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

定义 `Entity`#

在SeaORM中，我们可以通过定义实体来操作数据库。实体通常对应着数据库中的一张表。在本例中，我们需要创建一个Animal实体，对应着animal表。

首先，我们需要在Cargo.toml中添加SeaORM和MySQL驱动程序的依赖：

1
[dependencies]
2
sea-orm = "0.11.3"

然后，在src目录下创建一个名为animal.rs的文件，定义Animal实体：

1
use sea_orm::entity::prelude::*;
2

3
#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
4
#[sea_orm(table_name = "animal")]
5
pub struct Animal {
6
    #[sea_orm(primary_key)]
7
    pub id: i32,
8
    pub name: String,
9
    pub age: i32,
10
    pub species: String,
11
}

这里我们使用了derive宏来自动生成Animal实体的代码。其中，#[sea_orm(table_name = "animal")]表示Animal实体对应的表名为animal；#[sea_orm(primary_key)]表示id字段为主键。

有了Animal实体之后，我们就可以使用SeaORM提供的API来操作数据库了。下面分别介绍如何进行增删改查操作。

增加记录#

要增加一条记录，我们可以使用Animal::insert()方法。例如，要添加一只名为“Tom”的2岁猫，可以这样写：

1
use sea_orm::{Database, EntityTrait, FromQueryResult};
2

3
let database_url = "mysql://root:password@localhost:3306/animals";
4
let db = Database::connect(database_url).await.unwrap();
5

6
let animal = Animal {
7
    id: 0,
8
    name: "Tom".to_owned(),
9
    age: 2,
10
    species: "cat".to_owned(),
11
};
12

13
let inserted_animal = Animal::insert(&animal).exec(&db).await.unwrap();

这里我们首先连接到了名为animals的MySQL数据库，然后创建了一只名为“Tom”的2岁猫，使用Animal::insert()方法将其插入到数据库中，最后返回插入的记录。

删除记录#

要删除一条记录，我们可以使用Animal::delete()方法。例如，要删除id为1的记录，可以这样写：

1
use sea_orm::{Database, EntityTrait, FromQueryResult};
2

3
let database_url = "mysql://root:password@localhost:3306/animals";
4
let db = Database::connect(database_url).await.unwrap();
5

6
let deleted_animal = Animal::delete()
7
    .filter(animal::Column::Id.eq(1))
8
    .exec(&db)
9
    .await
10
    .unwrap();

这里我们使用Animal::delete()方法删除了id为1的记录，使用filter()方法指定了要删除的记录，最后返回删除的记录。

更新记录#

要更新一条记录，我们可以使用Animal::update()方法。例如，要将id为1的记录的年龄改为3岁，可以这样写：

1
use sea_orm::{Database, EntityTrait, FromQueryResult};
2

3
let database_url = "mysql://root:password@localhost:3306/animals";
4
let db = Database::connect(database_url).await.unwrap();
5

6
let updated_animal = Animal::update()
7
    .set(animal::Column::Age, 3)
8
    .filter(animal::Column::Id.eq(1))
9
    .exec(&db)
10
    .await
11
    .unwrap();

这里我们使用Animal::update()方法更新了id为1的记录，使用set()方法指定了要更新的字段，最后返回更新后的记录。

查询记录#

要查询记录，我们可以使用Animal::find()方法。例如，要查询所有名字为“Tom”的动物，可以这样写：

1
use sea_orm::{Database, EntityTrait, FromQueryResult};
2

3
let database_url = "mysql://root:password@localhost:3306/animals";
4
let db = Database::connect(database_url).await.unwrap();
5

6
let animals = Animal::find()
7
    .filter(animal::Column::Name.eq("Tom"))
8
    .all(&db)
9
    .await
10
    .unwrap();

这里我们使用Animal::find()方法查询了所有名字为“Tom”的动物，使用filter()方法指定了查询条件，最后返回查询结果。

联表查询#

除了基本的增删改查操作之外，SeaORM还支持联表查询。例如，我们可以查询每个物种的平均年龄：

1
use sea_orm::{Database, EntityTrait, FromQueryResult};
2

3
let database_url = "mysql://root:password@localhost:3306/animals";
4
let db = Database::connect(database_url).await.unwrap();
5

6
let avg_age_by_species = Animal::find()
7
    .group_by(animal::Column::Species)
8
    .select((animal::Column::Species, Avg(animal::Column::Age)))
9
    .all(&db)
10
    .await
11
    .unwrap();

这里我们使用Animal::find()方法查询了所有动物的信息，使用group_by()方法指定了分组条件，使用select()方法指定了要查询的字段和聚合函数，最后返回查询结果。

总结#

本教程介绍了SeaORM的基本用法，包括创建实体、增删改查等操作。SeaORM提供了简单易用的API，可以帮助我们轻松地操作数据库。同时，SeaORM还支持多种数据库，包括MySQL、PostgreSQL、SQLite等等。

在实际开发中，我们可以根据需要选择不同的数据库和ORM框架。SeaORM是一个不错的选择，它提供了很多有用的功能，可以帮助我们更加高效地开发应用程序。

Rust语言从入门到精通系列 - SeaORM框架实践(基础篇)

Tue, 30 May 2023 00:00:00 GMT

SeaORM是一个基于Rust语言的ORM（对象关系映射）框架，它提供了一种简单的方式来操作SQL数据库。SeaORM的设计理念是将SQL查询和Rust代码结合在一起，从而提供更好的类型安全和代码可读性。

在本教程中，我们将介绍SeaORM的基本用法和进阶用法。我们将使用SQLite数据库来演示这些用法。

基础用法#

在使用SeaORM之前，我们需要将其添加到我们的Rust项目中。cargo.toml添加依赖：

1
sea-orm = "0.11.3"

连接到数据库#

在使用SeaORM之前，我们需要连接到一个数据库。我们可以使用DatabaseConnection结构体来完成这个任务。

1
use sea_orm::Database;
2

3
#[async_std::main]
4
async fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let db_conn = Database::connect("mysql://username:password@hostname:port/database").await?;
6
    // ...
7
    Ok(())
8
}

在上面的代码中，我们使用DatabaseConnectionInfo::from_env()方法从环境变量中获取数据库连接信息，并使用DatabaseConnection::connect()方法连接到数据库。

定义表#

在SeaORM中，我们可以使用sea_query::Table结构体来定义表。我们可以定义表的名称、列名和列类型。

1
use sea_query::{ColumnDef, ColumnType, Table};
2

3
let users = Table::new("users")
4
    .add_column("id", ColumnType::Int(Some(11)).Unsigned(true).NotNull(true).AutoIncrement(true))
5
    .add_column("name", ColumnType::String(Some(256)).NotNull(true))
6
    .add_column("email", ColumnType::String(Some(256)).NotNull(true).Unique(true))
7
    .add_column("age", ColumnType::Int(Some(3)).Unsigned(true).NotNull(true))
8
    .set_primary_key(vec!["id"]);

在上面的代码中，我们定义了一个名为users的表，它有四个列：id、name、email和age。id列是自增的主键，name和email列是字符串类型，age列是整数类型。

插入数据#

在SeaORM中，我们可以使用InsertStatement结构体来插入数据。我们可以使用values()方法来设置要插入的值。

1
use sea_orm::{entity::*, query::*, DatabaseConnection};
2

3
let user = User {
4
    name: "John Doe".to_owned(),
5
    email: "john.doe@example.com".to_owned(),
6
    age: 30,
7
};
8

9
let insert = Insert::single_into(User::table())
10
    .values(user.clone())
11
    .build();
12

13
let result = User::insert(insert).exec(&db_conn).await?;

在上面的代码中，我们使用Insert::single_into()方法和values()方法来设置要插入的值。我们使用User::table()方法来获取User实体的表格。最后，我们使用User::insert()方法和exec()方法来执行插入操作。

查询数据#

在SeaORM中，我们可以使用SelectStatement结构体来查询数据。我们可以使用from()方法来设置要查询的表格，使用column()方法来设置要查询的列，使用where_expr()方法来设置查询条件。

1
use sea_orm::{entity::*, query::*, DatabaseConnection};
2

3
let query = Select::from_table(User::table())
4
    .column(User::all_columns)
5
    .where_expr(User::email.eq("john.doe@example.com"))
6
    .build();
7

8
let result = User::find_by_sql(query).one(&db_conn).await?;

在上面的代码中，我们使用Select::from_table()方法和column()方法来设置要查询的表格和列。我们使用where_expr()方法来设置查询条件。最后，我们使用User::find_by_sql()方法和one()方法来查询数据。

更新数据#

在SeaORM中，我们可以使用UpdateStatement结构体来更新数据。我们可以使用set()方法来设置要更新的值，使用where_expr()方法来设置更新条件。

1
use sea_orm::{entity::*, query::*, DatabaseConnection};
2

3
let update = Update::table(User::table())
4
    .set(User::name, "Jane Doe")
5
    .where_expr(User::email.eq("john.doe@example.com"))
6
    .build();
7

8
let result = User::update(update).exec(&db_conn).await?;

在上面的代码中，我们使用Update::table()方法和set()方法来设置要更新的值。我们使用where_expr()方法来设置更新条件。最后，我们使用User::update()方法和exec()方法来执行更新操作。

删除数据#

在SeaORM中，我们可以使用DeleteStatement结构体来删除数据。我们可以使用where_expr()方法来设置删除条件。

1
use sea_orm::{entity::*, query::*, DatabaseConnection};
2

3
let delete = Delete::from_table(User::table())
4
    .where_expr(User::email.eq("john.doe@example.com"))
5
    .build();
6

7
let result = User::delete(delete).exec(&db_conn).await?;

在上面的代码中，我们使用Delete::from_table()方法和where_expr()方法来设置删除条件。最后，我们使用User::delete()方法和exec()方法来执行删除操作。

进阶用法#

关联表查询#

在SeaORM中，我们可以使用JoinType枚举来设置关联类型。我们可以使用JoinOn结构体来设置关联条件。

1
use sea_orm::{entity::*, query::*, DatabaseConnection};
2

3
let query = Select::from_table(User::table())
4
    .inner_join(Post::table(), JoinOn::new(User::id, Post::user_id))
5
    .column((User::name, Post::title))
6
    .build();
7

8
let result = User::find_by_sql(query).all(&db_conn).await?;

在上面的代码中，我们使用Select::from_table()方法和inner_join()方法来设置关联表格。我们使用JoinOn::new()方法来设置关联条件。最后，我们使用User::find_by_sql()方法和all()方法来查询数据。

事务处理#

在SeaORM中，我们可以使用Transaction结构体来处理事务。我们可以使用begin()方法来开始事务，使用commit()方法来提交事务，使用rollback()方法来回滚事务。

1
use sea_orm::{entity::*, query::*, DatabaseConnection, Transaction};
2

3
let tx = Transaction::new(&db_conn).await?;
4

5
let user = User {
6
    name: "John Doe".to_owned(),
7
    email: "john.doe@example.com".to_owned(),
8
    age: 30,
9
};
10

11
let insert = Insert::single_into(User::table())
12
    .values(user.clone())
13
    .build();
14

15
let result = User::insert(insert).exec(&tx).await?;
16

17
let update = Update::table(User::table())
18
    .set(User::name, "Jane Doe")
19
    .where_expr(User::email.eq("john.doe@example.com"))
20
    .build();
21

22
let result = User::update(update).exec(&tx).await?;
23

24
tx.commit().await?;

展开收起

在上面的代码中，我们使用Transaction::new()方法来开始事务。我们使用User::insert()方法和exec()方法来插入数据，使用User::update()方法和exec()方法来更新数据。最后，我们使用tx.commit()方法来提交事务。

总结#

在本教程中，我们介绍了SeaORM的基本用法和进阶用法。SeaORM提供了一种简单的方式来操作SQL数据库，它将SQL查询和Rust代码结合在一起，提供了更好的类型安全和代码可读性。通过本教程的学习，我们可以更好地理解SeaORM的使用方法，从而更好地使用它来开发Rust应用程序。

Rust语言从入门到精通系列 - SQLx模块MySQL入门

Tue, 30 May 2023 00:00:00 GMT

SQLx是一个Rust语言的异步SQL执行库，它支持多种数据库，包括MySQL、PostgreSQL、SQLite等。本教程将以MySQL数据库为例，介绍SQLx在Rust语言中的基础用法和进阶用法。

基础用法#

要使用SQLx，需要在Cargo.toml文件中添加以下依赖：

1
[dependencies]
2
sqlx = { version = "0.6", features = ["mysql", "runtime-tokio-rustls"] }
3
tokio = { version = "1", features = ["full"] }

连接数据库#

在使用SQLx之前，需要先连接数据库。SQLx提供了两种方式连接MySQL数据库：使用URL连接和使用配置文件连接。

URL连接#

使用URL连接时，需要在代码中指定连接字符串，例如：

1
use sqlx::mysql::MySqlPoolOptions;
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = MySqlPoolOptions::new()
6
        .max_connections(5)
7
        .connect("mysql://username:password@hostname:port/database")
8
        .await?;
9
    // ...
10
    Ok(())
11
}

其中，username和password是数据库用户名和密码，hostname是数据库主机名，port是数据库端口号，database是要连接的数据库名。

配置文件连接#

使用配置文件连接时，需要在项目根目录下创建一个名为.env的文件，并在其中指定连接信息，例如：

1
DATABASE_URL=mysql://username:password@hostname:port/database

然后在代码中使用dotenv库加载.env文件，并使用sqlx::MySqlPool::connect_dotenv()方法连接数据库，例如：

1
use sqlx::mysql::MySqlPoolOptions;
2

3
#[tokio::main]
4
async fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    dotenv::dotenv().ok();
6
    let pool = MySqlPoolOptions::new()
7
        .max_connections(5)
8
        .connect(&dotenv::var("DATABASE_URL")?)
9
        .await?;
10
    // ...
11
    Ok(())
12
}

查询数据#

连接成功后，就可以使用SQLx执行SQL查询语句了。SQLx提供了两种方式执行SQL查询语句：使用query()方法和使用query_as()方法。

使用query()方法#

使用query()方法执行SQL查询语句时，需要手动指定返回结果的类型，例如：

1
use sqlx::{MySqlPool, Row};
2

3
#[derive(Debug)]
4
struct User {
5
    id: i32,
6
    name: String,
7
}
8

9
#[tokio::main]
10
async fn main() -> Result<(), sqlx::Error> {
11
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
12
    let mut conn = pool.acquire().await?;
13

14
    let mut rows = sqlx::query("SELECT id, name FROM users")
15
        .map(|row: sqlx::mysql::MySqlRow| {
16
            User {
17
                id: row.get(0),
18
                name: row.get(1),
19
            }
20
        })
21
        .fetch_all(&mut conn)
22
        .await?;
23

24
    for row in rows.iter() {
25
        println!("{:?}", row);
26
    }
27

28
    Ok(())
29
}

展开收起

使用query_as()方法#

使用query_as()方法执行SQL查询语句时，可以自动将返回结果转换为指定类型的结构体，例如：

1
use sqlx::{MySqlPool, FromRow};
2

3
#[derive(Debug, FromRow)]
4
struct User {
5
    id: i32,
6
    name: String,
7
}
8

9
#[tokio::main]
10
async fn main() -> Result<(), sqlx::Error> {
11
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
12
    let mut conn = pool.acquire().await?;
13

14
    let mut rows = sqlx::query_as::<_, User>("SELECT id, name FROM users")
15
        .fetch_all(&mut conn)
16
        .await?;
17

18
    for row in rows.iter() {
19
        println!("{:?}", row);
20
    }
21

22
    Ok(())
23
}

展开收起

插入数据#

使用SQLx插入数据时，可以使用execute()方法或execute_with()方法。

使用execute()方法#

使用execute()方法插入数据时，需要手动指定插入的数据，例如：

1
use sqlx::{MySqlPool, Row};
2

3
#[derive(Debug)]
4
struct User {
5
    name: String,
6
}
7

8
#[tokio::main]
9
async fn main() -> Result<(), sqlx::Error> {
10
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
11
    let mut conn = pool.acquire().await?;
12

13
    let user = User {
14
        name: "John".to_string(),
15
    };
16

17
    let result = sqlx::query("INSERT INTO users (name) VALUES (?)")
18
        .bind(user.name)
19
        .execute(&mut conn)
20
        .await?;
21

22
    println!("{:?}", result);
23

24
    Ok(())
25
}

展开收起

使用execute_with()方法#

使用execute_with()方法插入数据时，可以使用结构体自动映射的特性，例如：

1
use sqlx::{MySqlPool, FromRow};
2

3
#[derive(Debug, FromRow)]
4
struct User {
5
    name: String,
6
}
7

8
#[tokio::main]
9
async fn main() -> Result<(), sqlx::Error> {
10
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
11
    let mut conn = pool.acquire().await?;
12

13
    let user = User {
14
        name: "John".to_string(),
15
    };
16

17
    let result = sqlx::query_with::<_, User>("INSERT INTO users (name) VALUES (?)", user)
18
        .execute(&mut conn)
19
        .await?;
20

21
    println!("{:?}", result);
22

23
    Ok(())
24
}

展开收起

更新数据#

使用SQLx更新数据时，可以使用execute()方法或execute_with()方法。

使用execute()方法#

使用execute()方法更新数据时，需要手动指定更新的条件和更新的数据，例如：

1
use sqlx::{MySqlPool, Row};
2

3
#[derive(Debug)]
4
struct User {
5
    id: i32,
6
    name: String,
7
}
8

9
#[tokio::main]
10
async fn main() -> Result<(), sqlx::Error> {
11
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
12
    let mut conn = pool.acquire().await?;
13

14
    let user = User {
15
        id: 1,
16
        name: "John".to_string(),
17
    };
18

19
    let result = sqlx::query("UPDATE users SET name = ? WHERE id = ?")
20
        .bind(user.name)
21
        .bind(user.id)
22
        .execute(&mut conn)
23
        .await?;
24

25
    println!("{:?}", result);
26

27
    Ok(())
28
}

展开收起

使用execute_with()方法#

使用execute_with()方法更新数据时，可以使用结构体自动映射的特性，例如：

1
use sqlx::{MySqlPool, FromRow};
2

3
#[derive(Debug, FromRow)]
4
struct User {
5
    id: i32,
6
    name: String,
7
}
8

9
#[tokio::main]
10
async fn main() -> Result<(), sqlx::Error> {
11
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
12
    let mut conn = pool.acquire().await?;
13

14
    let user = User {
15
        id: 1,
16
        name: "John".to_string(),
17
    };
18

19
    let result = sqlx::query_with::<_, User>("UPDATE users SET name = :name WHERE id = :id", user)
20
        .execute(&mut conn)
21
        .await?;
22

23
    println!("{:?}", result);
24

25
    Ok(())
26
}

展开收起

删除数据#

使用SQLx删除数据时，可以使用execute()方法或execute_with()方法。

使用execute()方法#

使用execute()方法删除数据时，需要手动指定删除的条件，例如：

1
use sqlx::{MySqlPool, Row};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
6
    let mut conn = pool.acquire().await?;
7

8
    let result = sqlx::query("DELETE FROM users WHERE id = ?")
9
        .bind(1)
10
        .execute(&mut conn)
11
        .await?;
12

13
    println!("{:?}", result);
14

15
    Ok(())
16
}

展开收起

使用execute_with()方法#

使用execute_with()方法删除数据时，可以使用结构体自动映射的特性，例如：

1
use sqlx::{MySqlPool, FromRow};
2

3
#[derive(Debug, FromRow)]
4
struct User {
5
    id: i32,
6
}
7

8
#[tokio::main]
9
async fn main() -> Result<(), sqlx::Error> {
10
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
11
    let mut conn = pool.acquire().await?;
12

13
    let user = User {
14
        id: 1,
15
    };
16

17
    let result = sqlx::query_with::<_, User>("DELETE FROM users WHERE id = :id", user)
18
        .execute(&mut conn)
19
        .await?;
20

21
    println!("{:?}", result);
22

23
    Ok(())
24
}

展开收起

进阶用法#

事务#

使用SQLx执行事务时，可以使用begin()方法开始事务，使用commit()方法提交事务，使用rollback()方法回滚事务。

1
use sqlx::{MySqlPool, Transaction};
2

3
#[derive(Debug)]
4
struct User {
5
    name: String,
6
}
7

8
#[tokio::main]
9
async fn main() -> Result<(), sqlx::Error> {
10
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
11
    let mut conn = pool.acquire().await?;
12

13
    let mut tx = conn.begin().await?;
14

15
    let user = User {
16
        name: "John".to_string(),
17
    };
18

19
    let result = sqlx::query("INSERT INTO users (name) VALUES (?)")
20
        .bind(user.name)
21
        .execute(&mut tx)
22
        .await?;
23

24
    println!("{:?}", result);
25

26
    tx.commit().await?;
27

28
    Ok(())
29
}

展开收起

连接池#

使用SQLx连接池时，可以使用PoolOptions::new()方法创建连接池，并使用acquire()方法获取连接。

1
use sqlx::mysql::MySqlPoolOptions;
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = MySqlPoolOptions::new()
6
        .max_connections(5)
7
        .connect("mysql://username:password@hostname:port/database")
8
        .await?;
9
    let mut conn = pool.acquire().await?;
10

11
    let pool = MySqlPoolOptions::new()
12
        .max_connections(5)
13
        .connect("mysql://username:password@hostname:port/database")
14
        .await?;
15

16
    let mut conn = pool.acquire().await?;
17

18
    // ...
19

20
    Ok(())
21
}

展开收起

总结#

本教程介绍了SQLx在Rust语言中的基础用法和进阶用法，包括连接数据库、查询数据、插入数据、更新数据、删除数据、事务和连接池等。SQLx是一个简单易用的异步SQL执行库，可以帮助Rust开发者快速地与多种数据库进行交互。

Rust语言从入门到精通系列 - SQLx模块PostgreSQL入门

Tue, 30 May 2023 00:00:00 GMT

SQLx是一个Rust语言的异步SQL数据库连接库，支持PostgreSQL、MySQL和SQLite数据库。它提供了简单的API和异步执行查询的能力，使得Rust程序员可以轻松地与数据库交互。本教程将以PostgreSQL数据库为例，介绍SQLx的基础和进阶用法。

基础用法#

安装SQLx#

首先，我们需要在Rust项目中添加SQLx依赖。在Cargo.toml文件中添加以下内容：

1
[dependencies]
2
sqlx = "0.6"
3
sqlx-core = "0.6"
4
sqlx-postgres = "0.6"

其中，sqlx是SQLx的主要依赖，sqlx-core是SQLx的核心依赖，sqlx-postgres是SQLx连接PostgreSQL数据库的依赖。

连接数据库#

在使用SQLx进行数据库操作之前，我们需要先连接到数据库。在这里，我们使用PostgreSQL数据库作为示例。首先，我们需要在环境变量中设置数据库连接字符串：

Terminal window

1
export DATABASE_URL=postgres://username:password@localhost:5432/database_name

其中，username和password分别是数据库的用户名和密码，localhost是数据库所在的主机名或IP地址，5432是PostgreSQL默认的端口号，database_name是数据库的名称。

然后，在Rust代码中使用connect方法连接到数据库：

1
use sqlx::postgres::PgPool;
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = PgPool::connect(&std::env::var("DATABASE_URL")?).await?;
6

7
    // ...
8
}

我们使用PgPool连接到PostgreSQL数据库，其中DATABASE_URL是环境变量中设置的数据库连接字符串。

执行查询#

连接到数据库之后，我们可以使用SQLx执行SQL查询。SQLx提供了两种方式执行查询：一种是使用query方法返回一个结果集，另一种是使用execute方法执行一个SQL语句。

使用query方法#

使用query方法可以执行一个查询语句，并返回一个结果集。在这里，我们查询PostgreSQL中的users表：

1
use sqlx::postgres::PgQueryAs;
2

3
#[derive(Debug, sqlx::FromRow)]
4
struct User {
5
    id: i32,
6
    name: String,
7
}
8

9
async fn get_users(pool: &PgPool) -> Result<Vec<User>, sqlx::Error> {
10
    let users = sqlx::query_as::<_, User>("SELECT id, name FROM users")
11
        .fetch_all(pool)
12
        .await?;
13

14
    Ok(users)
15
}

展开收起

我们使用query_as方法执行查询语句，并将结果集映射为User结构体。fetch_all方法将结果集转换为Vec类型，并返回查询结果。

使用execute方法#

使用execute方法可以执行一个SQL语句，并返回受影响的行数。在这里，我们向PostgreSQL中的users表插入一条记录：

1
async fn add_user(pool: &PgPool, name: &str) -> Result<u64, sqlx::Error> {
2
    let result = sqlx::query("INSERT INTO users (name) VALUES ($1)")
3
        .bind(name)
4
        .execute(pool)
5
        .await?;
6

7
    Ok(result.rows_affected())
8
}

我们使用query方法执行SQL语句，并使用bind方法绑定参数。execute方法执行SQL语句，并返回受影响的行数。

事务处理#

在数据库操作中，事务处理是非常重要的。SQLx提供了transaction方法，可以在事务中执行多个SQL操作。

1
async fn transfer_money(pool: &PgPool, from: i32, to: i32, amount: i32) -> Result<(), sqlx::Error> {
2
    let mut tx = pool.begin().await?;
3

4
    let from_balance: i32 = sqlx::query_scalar("SELECT balance FROM accounts WHERE id = $1")
5
        .bind(from)
6
        .fetch_one(&mut tx)
7
        .await?;
8

9
    if from_balance < amount {
10
        return Err(sqlx::Error::RowNotFound);
11
    }
12

13
    sqlx::query("UPDATE accounts SET balance = balance - $1 WHERE id = $2")
14
        .bind(amount)
15
        .bind(from)
16
        .execute(&mut tx)
17
        .await?;
18

19
    sqlx::query("UPDATE accounts SET balance = balance + $1 WHERE id = $2")
20
        .bind(amount)
21
        .bind(to)
22
        .execute(&mut tx)
23
        .await?;
24

25
    tx.commit().await?;
26

27
    Ok(())
28
}

展开收起

我们使用begin方法开始一个事务，并在事务中执行多个SQL操作。如果所有操作都执行成功，我们使用commit方法提交事务。如果发生错误，我们使用rollback方法回滚事务。

使用连接池#

在实际应用中，我们需要处理多个数据库连接。SQLx提供了连接池来管理多个数据库连接。在这里，我们使用PgPool连接池：

1
use sqlx::postgres::PgPoolOptions;
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = PgPoolOptions::new()
6
        .max_connections(5)
7
        .connect(&std::env::var("DATABASE_URL")?)
8
        .await?;
9

10
    // ...
11
}

我们使用PgPoolOptions创建一个连接池，并在连接池中设置最大连接数。然后，我们使用connect方法连接到数据库。

使用SQLx宏#

SQLx提供了一组宏，可以在编译时检查SQL语句的正确性和类型安全性。在这里，我们使用sqlx::query!宏执行查询语句：

1
use sqlx::postgres::PgRow;
2
use sqlx::query;
3

4
async fn get_user(pool: &PgPool, id: i32) -> Result<Option<PgRow>, sqlx::Error> {
5
    let user = query!("SELECT * FROM users WHERE id = $1", id)
6
        .fetch_optional(pool)
7
        .await?;
8

9
    Ok(user)
10
}

我们使用query!宏执行查询语句，并使用$1占位符绑定参数。fetch_optional方法返回一个Option类型的结果集。

进阶用法#

自定义类型映射#

SQLx默认支持一些常见的Rust类型和PostgreSQL数据类型的映射。但是，在某些情况下，我们需要自定义类型映射。在这里，我们自定义一个Json类型映射：

1
use serde::{Deserialize, Serialize};
2
use sqlx::postgres::{PgTypeInfo, PgValue, types::PgTypeMetadata};
3
use sqlx::{Decode, Encode, Type};
4

5
#[derive(Debug, Clone, Serialize, Deserialize)]
6
struct Json<T>(pub T);
7

8
impl<'r, T> Type<'r> for Json<T>
9
where
10
    T: Serialize + Deserialize<'r>,
11
{
12
    fn type_info() -> PgTypeInfo<'r> {
13
        PgTypeInfo::with_name("jsonb")
14
    }
15

16
    fn compatible(ty: &PgTypeMetadata<'_>) -> bool {
17
        ty.name() == "json" || ty.name() == "jsonb"
18
    }
19
}
20

21
impl<'q, 'r, T> Encode<'q, 'r> for Json<T>
22
where
23
    T: Serialize,
24
{
25
    fn encode(&self, buf: &mut Vec<u8>) -> sqlx::encode::Result<()> {
26
        let json = serde_json::to_string(&self.0)?;
27
        PgValue::from(json).encode(buf)
28
    }
29
}
30

31
impl<'r, T> Decode<'r> for Json<T>
32
where
33
    T: Deserialize<'r>,
34
{
35
    fn decode(value: PgValue<'r>) -> Result<Self, sqlx::Error> {
36
        let json = value.try_get::<&str>()?;
37
        let value = serde_json::from_str(json)?;
38
        Ok(Json(value))
39
    }
40
}

展开收起

我们定义了一个Json结构体，它包装了一个T类型的值。然后，我们实现了Type、Encode和Decode trait，将Json类型映射为PostgreSQL的jsonb类型。

使用SQLx的连接池管理器#

在实际应用中，我们需要使用连接池管理器来管理多个数据库连接。SQLx提供了连接池管理器，可以方便地管理连接池和连接。在这里，我们使用r2d2连接池管理器：

1
use std::thread;
2
use sqlx::postgres::PgConnection;
3
use sqlx::pool::{Pool, PoolConnection};
4
use r2d2_postgres::{postgres::NoTls, PostgresConnectionManager};
5

6
#[tokio::main]
7
async fn main() -> Result<(), sqlx::Error> {
8
    let manager = PostgresConnectionManager::new(
9
        "host=localhost user=postgres".parse().unwrap(),
10
        NoTls,
11
    );
12
    let pool = r2d2::Pool::new(manager).unwrap();
13

14
    // ...
15
}

展开收起

我们使用PostgresConnectionManager创建一个连接管理器，并在连接管理器中设置最大连接数。然后，我们使用Pool构建一个连接池，并在连接池中设置最大连接数。

总结#

本教程介绍了SQLx的基础和进阶用法。我们学习了如何连接到PostgreSQL数据库，如何执行SQL查询和操作，如何处理事务，如何使用连接池和宏，以及如何自定义类型映射和使用连接池管理器。SQLx是一个强大的异步SQL数据库连接库，可以帮助Rust程序员轻松地与数据库交互。

Rust语言从入门到精通系列 - SQLx模块SQLite入门

Tue, 30 May 2023 00:00:00 GMT

SQLx是一个Rust语言的异步SQL数据库访问库，支持多种数据库，包括PostgreSQL、MySQL、SQLite等。本教程将以SQLite为例，介绍SQLx的基础用法和进阶用法。

基础用法#

连接数据库#

首先，需要在Rust项目中添加SQLx库的依赖：

1
[dependencies]
2
sqlx = "0.6"
3
sqlx-core = "0.6"
4
sqlx-derive = "0.6"
5
sqlx-macros = "0.6"

然后，可以使用以下代码连接SQLite数据库：

1
use sqlx::{SqlitePool, sqlite::SqliteConnectOptions};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let database_url = "sqlite:mydatabase.db";
6
    let options = SqliteConnectOptions::new()
7
        .filename(database_url);
8
    let pool = SqlitePool::connect_with(options).await?;
9
    Ok(())
10
}

这里使用了SqlitePool连接池，可以在多个线程中共享连接。SqliteConnectOptions用于配置连接选项，这里指定了SQLite数据库文件的路径。

创建表#

下面的代码演示了如何使用SQLx创建一个名为users的表：

1
use sqlx::{query, SqlitePool};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = SqlitePool::connect("sqlite:mydatabase.db").await?;
6
    query("CREATE TABLE users (
7
        id INTEGER PRIMARY KEY,
8
        name TEXT NOT NULL,
9
        email TEXT NOT NULL UNIQUE
10
    )").execute(&pool).await?;
11
    Ok(())
12
}

这里使用了query宏执行SQL语句，execute方法用于执行语句。可以看到，SQL语句与普通的SQL语句没有太大区别。

插入数据#

下面的代码演示了如何使用SQLx向users表中插入一条数据：

1
use sqlx::{query, SqlitePool};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = SqlitePool::connect("sqlite:mydatabase.db").await?;
6
    query("INSERT INTO users (name, email) VALUES (?, ?)")
7
        .bind("Alice")
8
        .bind("alice@example.com")
9
        .execute(&pool)
10
        .await?;
11
    Ok(())
12
}

这里使用了bind方法绑定参数，可以避免SQL注入攻击。

查询数据#

下面的代码演示了如何使用SQLx查询users表中所有数据：

1
use sqlx::{query_as, SqlitePool};
2

3
#[derive(Debug, sqlx::FromRow)]
4
struct User {
5
    id: i32,
6
    name: String,
7
    email: String,
8
}
9

10
#[tokio::main]
11
async fn main() -> Result<(), sqlx::Error> {
12
    let pool = SqlitePool::connect("sqlite:mydatabase.db").await?;
13
    let users = query_as::<_, User>("SELECT * FROM users")
14
        .fetch_all(&pool)
15
        .await?;
16
    println!("{:?}", users);
17
    Ok(())
18
}

展开收起

这里使用了query_as宏查询数据，并使用FromRow特性将查询结果转换为User结构体。fetch_all方法用于获取所有查询结果。

更新数据#

下面的代码演示了如何使用SQLx更新users表中的数据：

1
use sqlx::{query, SqlitePool};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = SqlitePool::connect("sqlite:mydatabase.db").await?;
6
    query("UPDATE users SET email = ? WHERE name = ?")
7
        .bind("alice@example.org")
8
        .bind("Alice")
9
        .execute(&pool)
10
        .await?;
11
    Ok(())
12
}

这里使用了UPDATE语句更新数据。

删除数据#

下面的代码演示了如何使用SQLx删除users表中的数据：

1
use sqlx::{query, SqlitePool};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = SqlitePool::connect("sqlite:mydatabase.db").await?;
6
    query("DELETE FROM users WHERE name = ?")
7
        .bind("Alice")
8
        .execute(&pool)
9
        .await?;
10
    Ok(())
11
}

这里使用了DELETE语句删除数据。

进阶用法#

事务#

下面的代码演示了如何使用SQLx进行事务操作：

1
use sqlx::{query, SqlitePool, SqliteTransaction};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = SqlitePool::connect("sqlite:mydatabase.db").await?;
6
    let mut tx = pool.begin().await?;
7
    query("INSERT INTO users (name, email) VALUES (?, ?)")
8
        .bind("Alice")
9
        .bind("alice@example.com")
10
        .execute(&mut tx)
11
        .await?;
12
    query("INSERT INTO users (name, email) VALUES (?, ?)")
13
        .bind("Bob")
14
        .bind("bob@example.com")
15
        .execute(&mut tx)
16
        .await?;
17
    tx.commit().await?;
18
    Ok(())
19
}

展开收起

这里使用了begin方法开启一个事务，可以在事务中执行多条SQL语句。如果所有语句执行成功，可以使用commit方法提交事务，否则可以使用rollback方法回滚事务。

批量插入#

下面的代码演示了如何使用SQLx进行批量插入操作：

1
use sqlx::{query, SqlitePool};
2

3
#[tokio::main]
4
async fn main() -> Result<(), sqlx::Error> {
5
    let pool = SqlitePool::connect("sqlite:mydatabase.db").await?;
6
    let users = vec![
7
        ("Alice", "alice@example.com"),
8
        ("Bob", "bob@example.com"),
9
        ("Charlie", "charlie@example.com"),
10
    ];
11
    for (name, email) in users {
12
        query("INSERT INTO users (name, email) VALUES (?, ?)")
13
            .bind(name)
14
            .bind(email)
15
            .execute(&pool)
16
            .await?;
17
    }
18
    Ok(())
19
}

展开收起

这里使用了bind_all方法绑定多个参数，可以将多个参数一次性绑定到SQL语句中，避免了多次执行SQL语句的开销。

总结#

本教程介绍了SQLx的基础用法和进阶用法，包括连接数据库、创建表、插入数据、查询数据、更新数据、删除数据、事务和批量插入。SQLx是一个非常方便的异步SQL数据库访问库，可以大大提高开发效率。

Rust语言从入门到精通系列 - paho-mqtt模块实战(入门)

Mon, 29 May 2023 00:00:00 GMT

MQTT（Message Queuing Telemetry Transport）是一种轻量级的消息传输协议，它被设计用于低带宽和不稳定网络环境下的物联网设备通信。Rust是一种安全、并发和高效的编程语言，它在系统编程和网络编程方面有着很好的表现。在本教程中，我们将介绍如何使用Rust语言和paho-mqtt模块实现MQTT协议的应用。

前面写过3篇介绍 rumqttc 的教程，本篇开始使用 paho-mqtt 模块是c库的封装, 支持v5协议，qos 2等更复杂的特性。

环境准备#

我们需要先安装好相关的开发环境。在Cargo.toml中添加依赖：

1
paho-mqtt = "0.12.1"

连接MQTT服务器#

在使用MQTT协议之前，我们需要先连接到MQTT服务器。以下是连接MQTT服务器的示例代码：

1
extern crate paho_mqtt as mqtt;
2

3
fn main() {
4
    let host = "tcp://localhost:1883";
5
    let cli = mqtt::Client::new(host).unwrap();
6
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
7
        .keep_alive_interval(std::time::Duration::from_secs(20))
8
        .clean_session(false)
9
        .finalize();
10
    let response = cli.connect(conn_opts).unwrap();
11
    println!("Connected to MQTT server: {:?}", response);
12
}

在上面的示例代码中，我们首先创建了一个MQTT客户端对象，并指定了MQTT服务器的地址。然后，我们创建了一个连接选项对象，并设置了心跳间隔和会话清除标志。最后，我们使用连接选项对象连接到MQTT服务器，并打印连接响应信息。

发布MQTT消息#

在连接到MQTT服务器之后，我们可以使用MQTT客户端对象来发布消息。以下是发布MQTT消息的示例代码：

1
extern crate paho_mqtt as mqtt;
2

3
fn main() {
4
    let host = "tcp://localhost:1883";
5
    let cli = mqtt::Client::new(host).unwrap();
6
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
7
        .keep_alive_interval(std::time::Duration::from_secs(20))
8
        .clean_session(false)
9
        .finalize();
10
    let response = cli.connect(conn_opts).unwrap();
11
    println!("Connected to MQTT server: {:?}", response);
12

13
    let topic = "test/topic";
14
    let payload = "Hello, MQTT!";
15
    let message = mqtt::MessageBuilder::new()
16
        .topic(topic)
17
        .payload(payload)
18
        .qos(mqtt::QOS_1)
19
        .finalize();
20
    let response = cli.publish(message).unwrap();
21
    println!("Published MQTT message: {:?}", response);
22
}

展开收起

在上面的示例代码中，我们首先连接到MQTT服务器，然后创建了一个MQTT消息对象，并设置了消息主题、消息负载和消息服务质量等级。最后，我们使用MQTT客户端对象来发布消息，并打印发布响应信息。

订阅MQTT主题#

在使用MQTT协议之前，我们需要先订阅MQTT主题。以下是订阅MQTT主题的示例代码：

1
extern crate paho_mqtt as mqtt;
2

3
fn main() {
4
    let host = "tcp://localhost:1883";
5
    let cli = mqtt::Client::new(host).unwrap();
6
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
7
        .keep_alive_interval(std::time::Duration::from_secs(20))
8
        .clean_session(false)
9
        .finalize();
10
    let response = cli.connect(conn_opts).unwrap();
11
    println!("Connected to MQTT server: {:?}", response);
12

13
    let topic = "test/topic";
14
    let qos = mqtt::QOS_1;
15
    let response = cli.subscribe(topic, qos).unwrap();
16
    println!("Subscribed to MQTT topic: {:?}", response);
17
}

展开收起

在上面的示例代码中，我们首先连接到MQTT服务器，然后创建了一个MQTT订阅对象，并设置了订阅主题和服务质量等级。最后，我们使用MQTT客户端对象来订阅主题，并打印订阅响应信息。

同时发布和订阅MQTT消息#

在使用MQTT协议时，我们通常需要同时发布和订阅MQTT消息。以下是同时发布和订阅MQTT消息的示例代码：

1
extern crate paho_mqtt as mqtt;
2

3
fn main() {
4
    let host = "tcp://localhost:1883";
5
    let cli = mqtt::Client::new(host).unwrap();
6
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
7
        .keep_alive_interval(std::time::Duration::from_secs(20))
8
        .clean_session(false)
9
        .finalize();
10
    let response = cli.connect(conn_opts).unwrap();
11
    println!("Connected to MQTT server: {:?}", response);
12

13
    let topic = "test/topic";
14
    let qos = mqtt::QOS_1;
15
    let response = cli.subscribe(topic, qos).unwrap();
16
    println!("Subscribed to MQTT topic: {:?}", response);
17

18
    let payload = "Hello, MQTT!";
19
    let message = mqtt::MessageBuilder::new()
20
        .topic(topic)
21
        .payload(payload)
22
        .qos(mqtt::QOS_1)
23
        .finalize();
24
    let response = cli.publish(message).unwrap();
25
    println!("Published MQTT message: {:?}", response);
26

27
    for message in cli.start_consuming() {
28
        println!("Received MQTT message: {:?}", message);
29
    }
30
}

展开收起

在上面的示例代码中，我们首先连接到MQTT服务器，然后创建了一个MQTT订阅对象，并设置了订阅主题和服务质量等级。接着，我们创建了一个MQTT消息对象，并使用MQTT客户端对象来发布消息。最后，我们使用MQTT客户端对象来接收消息，并打印接收到的消息。

断开MQTT服务器连接#

在使用MQTT协议之后，我们需要断开与MQTT服务器的连接。以下是断开MQTT服务器连接的示例代码：

1
extern crate paho_mqtt as mqtt;
2

3
fn main() {
4
    let host = "tcp://localhost:1883";
5
    let cli = mqtt::Client::new(host).unwrap();
6
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
7
        .keep_alive_interval(std::time::Duration::from_secs(20))
8
        .clean_session(false)
9
        .finalize();
10
    let response = cli.connect(conn_opts).unwrap();
11
    println!("Connected to MQTT server: {:?}", response);
12

13
    cli.disconnect(None).unwrap();
14
    println!("Disconnected from MQTT server.");
15
}

展开收起

在上面的示例代码中，我们首先连接到MQTT服务器，然后使用MQTT客户端对象来断开与MQTT服务器的连接，并打印断开连接信息。

进阶使用#

在本节中，我们将介绍如何使用Rust语言和paho-mqtt模块实现MQTT协议的进阶应用。我们将提供2个示例，分别是：

使用SSL/TLS连接MQTT服务器
使用认证机制连接MQTT服务器

使用SSL/TLS连接MQTT服务器#

在使用MQTT协议时，我们通常需要使用SSL/TLS协议来保证通信安全。以下是使用SSL/TLS连接MQTT服务器的示例代码：

1
extern crate paho_mqtt as mqtt;
2

3
use std::fs::File;
4
use std::io::BufReader;
5
use std::sync::Arc;
6
use rustls::ClientConfig;
7

8
fn main() {
9
    let host = "ssl://localhost:8883";
10
    let cli = mqtt::Client::new(host).unwrap();
11

12
    let mut root_store = rustls::RootCertStore::empty();
13
    let cert_file = &mut BufReader::new(File::open("cert.pem").unwrap());
14
    root_store.add_pem_file(cert_file).unwrap();
15
    let config = ClientConfig::builder()
16
        .with_root_certificates(root_store)
17
        .with_no_client_auth();
18
    let tls = Arc::new(config);
19

20
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
21
        .keep_alive_interval(std::time::Duration::from_secs(20))
22
        .ssl_options(mqtt::SslOptionsBuilder::new()
23
            .ssl_version(mqtt::SslVersion::TlsV1_2)
24
            .server_name_indication(host)
25
            .build(tls))
26
        .clean_session(false)
27
        .finalize();
28
    let response = cli.connect(conn_opts).unwrap();
29
    println!("Connected to MQTT server: {:?}", response);
30
}

展开收起

在上面的示例代码中，我们首先创建了一个MQTT客户端对象，并指定了使用SSL/TLS协议连接MQTT服务器的地址。然后，我们使用rustls 0.20+的ClientConfig::builder()模式构建TLS配置，通过with_root_certificates()加载CA证书，通过with_no_client_auth()设置无需客户端认证。最后，我们创建了一个连接选项对象，并设置了心跳间隔、SSL/TLS选项和会话清除标志。我们使用连接选项对象连接到MQTT服务器，并打印连接响应信息。

使用认证机制连接MQTT服务器#

在使用MQTT协议时，我们通常需要使用认证机制来保证通信安全。以下是使用认证机制连接MQTT服务器的示例代码：

1
extern crate paho_mqtt as mqtt;
2

3
fn main() {
4
    let host = "tcp://localhost:1883";
5
    let cli = mqtt::Client::new(host).unwrap();
6

7
    let username = "user";
8
    let password = "password";
9
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
10
        .keep_alive_interval(std::time::Duration::from_secs(20))
11
        .user_name(username)
12
        .password(password)
13
        .clean_session(false)
14
        .finalize();
15
    let response = cli.connect(conn_opts).unwrap();
16
    println!("Connected to MQTT server: {:?}", response);
17
}

展开收起

在上面的示例代码中，我们首先创建了一个MQTT客户端对象，并指定了MQTT服务器的地址。然后，我们创建了一个连接选项对象，并设置了心跳间隔、用户名、密码和会话清除标志。我们使用连接选项对象连接到MQTT服务器，并打印连接响应信息。

总结#

在本教程中，我们介绍了如何使用Rust语言和paho-mqtt模块实现MQTT协议的应用。我们提供了几个基础应用的示例代码，包括连接MQTT服务器、发布MQTT消息、订阅MQTT主题、同时发布和订阅MQTT消息和断开MQTT服务器连接。

Rust语言从入门到精通系列 - 一文读懂MQTT的LWT特性

Mon, 29 May 2023 00:00:00 GMT

MQTT是一种轻量级的消息传输协议，它被广泛应用于物联网和机器对机器通信领域。Rust是一种安全、高效、并发的编程语言，它的生态系统也在不断壮大。本教程将介绍如何使用Rust语言和paho-mqtt模块实现MQTT协议，并重点介绍LWT特征。

Rust是一种系统级编程语言，它的主要特点是安全、高效、并发。Rust编译器会在编译时进行内存安全检查，避免了很多常见的内存安全问题，如空指针、缓冲区溢出、数据竞争等。同时，Rust也提供了很多高级语言的特性，如闭包、泛型、模式匹配等，使得编写Rust程序更加方便和高效。

什么是MQTT？#

MQTT是一种基于发布/订阅模式的消息传输协议。它是一种轻量级的协议，适用于低带宽、不稳定的网络环境。MQTT的核心思想是将消息发布到主题（Topic）上，订阅者可以通过订阅主题来接收消息。MQTT支持三种消息质量等级：

QoS 0：最多一次传输，消息不可靠，可能会丢失或重复。
QoS 1：最少一次传输，消息可靠，至少传输一次，可能会重复。
QoS 2：只有一次传输，消息可靠，只传输一次，不会重复。

MQTT协议的具体规范可以参考官方文档：MQTT Version 5.0 Specification。

paho-mqtt模块#

paho-mqtt是一个MQTT客户端库，它提供了多种语言的实现，包括C、C++、Java、Python、Rust等。paho-mqtt-rs是paho-mqtt的Rust语言实现，它提供了一套简单易用的API，可以方便地实现MQTT协议。

LWT特征#

LWT（Last Will and Testament）是MQTT协议中的一种特殊消息，它可以在客户端离线时自动发送。LWT消息包括一个主题和一个消息内容，当客户端离线时，服务器会自动将LWT消息发布到指定主题上。LWT特征可以用于检测客户端是否在线，也可以用于实现一些特殊的功能，如自动重连、状态监控等。

示例代码#

下面是一个使用paho-mqtt-rs实现MQTT协议的示例代码。该代码实现了一个简单的MQTT客户端，可以连接到指定的MQTT服务器，订阅指定的主题，发送和接收消息，并支持LWT特征。

1
use paho_mqtt as mqtt;
2
use std::time::Duration;
3

4
fn main() {
5
    // 创建MQTT客户端
6
    let cli = mqtt::Client::new("tcp://localhost:1883").unwrap();
7

8
    // 设置LWT特征
9
    let lwt = mqtt::Message::new("lwt", "offline", 0);
10
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
11
        .will_message(lwt)
12
        .clean_session(false)
13
        .connect_timeout(Duration::from_secs(5))
14
        .finalize();
15

16
    // 连接MQTT服务器
17
    let tok = cli.connect(conn_opts);
18
    tok.wait().unwrap();
19

20
    // 订阅主题
21
    let topic = "hello/world";
22
    let qos = 1;
23
    let tok = cli.subscribe(topic, qos);
24
    tok.wait().unwrap();
25

26
    // 发送消息
27
    let payload = "hello, world!";
28
    let msg = mqtt::Message::new(topic, payload, qos);
29
    let tok = cli.publish(msg);
30
    tok.wait().unwrap();
31

32
    // 接收消息
33
    for _ in 0..10 {
34
        let msg = cli.start_consuming().recv_timeout(Duration::from_secs(1)).unwrap();
35
        println!("Received message: {:?}", msg);
36
    }
37

38
    // 断开连接
39
    let tok = cli.disconnect(None);
40
    tok.wait().unwrap();
41
}

展开收起

该代码首先创建一个MQTT客户端，然后设置LWT特征，连接到指定的MQTT服务器，订阅指定的主题，发送和接收消息，并最终断开连接。其中，LWT特征通过ConnectOptionsBuilder的will_message方法设置，订阅主题通过subscribe方法实现，发送消息通过publish方法实现，接收消息通过await_message方法实现。

总结#

本教程介绍了如何使用Rust语言和paho-mqtt模块实现MQTT协议，并重点介绍了LWT特征。Rust语言的安全、高效、并发特性使得编写MQTT客户端更加方便和高效，paho-mqtt-rs提供了一套简单易用的API，可以方便地实现MQTT协议。LWT特征可以用于检测客户端是否在线，也可以用于实现一些特殊的功能，如自动重连、状态监控等。

Rust语言从入门到精通系列 - 一文读懂MQTT的LWT特性

Mon, 29 May 2023 00:00:00 GMT

Rust_Lang_Async_Program

Fri, 19 May 2023 00:00:00 GMT

Rust_Lang_Async_Wait

Fri, 19 May 2023 00:00:00 GMT

Rust_Prost_Protobuf_Serialize

Fri, 19 May 2023 00:00:00 GMT

Rust_Transmute

Fri, 19 May 2023 00:00:00 GMT

Rust反射

Fri, 19 May 2023 00:00:00 GMT

Rust语言从入门到精通系列 - 物联网消息传输协议MQTT(入门)

Tue, 16 May 2023 00:00:00 GMT

MQTT（Message Queuing Telemetry Transport）是一种轻量级的消息传输协议，用于在低带宽和不稳定的网络环境中传输消息。MQTT协议基于发布/订阅模式，包含了许多特性，如QoS，保留消息，遗嘱消息等，使得它非常适合物联网设备之间的通信。

Rust是一种系统级编程语言，具有内存安全和高性能的特性。Rust语言的主要目标是提供一种安全、并发、实用的编程语言，使得开发者可以轻松地编写高性能的系统级应用程序。本教程将介绍如何使用Rust语言和rumqttc模块来实现MQTT协议的基础应用和进阶应用。

rumqttc模块简介#

rumqttc是一个基于Rust语言实现的MQTT客户端库，它提供了连接MQTT服务器、订阅主题、发布消息等基本功能，并支持TLS加密连接。rumqttc的API简单易用，适合初学者和中级开发者使用。

在Cargo.toml文件中添加rumqtt模块依赖, 示例配置如下：

1
[dependencies]
2
rumqttc = "0.21.0"

应用实践#

连接MQTT服务器#

使用rumqttc连接MQTT服务器非常简单，只需要指定服务器地址和端口号即可。以下是一个连接到本地MQTT服务器的示例代码：

1
use rumqttc::{Client, MqttOptions};
2

3
fn main() {
4
    let mqtt_options = MqttOptions::new("test-1", "localhost", 1883);
5
    let (mut client, _) = Client::new(mqtt_options, 10);
6
    client
7
        .connect()
8
        .expect("Failed to connect to MQTT server");
9
    // ...
10
}

其中，test-1是客户端ID，可以自行定义。10是消息队列的大小，表示可以同时处理的未确认消息数量。

订阅主题#

订阅MQTT主题可以接收来自其他客户端的消息。使用rumqttc订阅主题也非常简单，只需要指定主题名称和消息处理函数即可。以下是一个订阅主题的示例代码：

1
use rumqttc::{Client, MqttOptions, QoS};
2

3
fn main() {
4
    let mqtt_options = MqttOptions::new("test-2", "localhost", 1883);
5
    let (mut client, mut connection) = Client::new(mqtt_options, 10);
6
    client
7
        .subscribe("test/topic", QoS::AtLeastOnce)
8
        .expect("Failed to subscribe to topic");
9
    for message in connection.iter() {
10
        if let Ok(message) = message {
11
            println!("{}", message.payload_str());
12
        }
13
    }
14
}

其中，test/topic是要订阅的主题名称，QoS::AtLeastOnce表示消息至少被处理一次，即使出现网络故障或客户端宕机也不会丢失。connection.iter()返回一个迭代器，可以用来不断接收来自服务器的消息。

发布消息#

发布MQTT消息可以向其他客户端发送数据。使用rumqttc发布消息也非常简单，只需要指定主题名称和消息内容即可。以下是一个发布消息的示例代码：

1
use rumqttc::{Client, MqttOptions, QoS, ReconnectOptions, Transport};
2

3
fn main() {
4
    let mqtt_options = MqttOptions::new("test-3", "localhost", 1883);
5
    let (mut client, mut connection) = Client::new(mqtt_options, 10);
6
    let reconnection_options = ReconnectOptions::Always(10);
7
    client
8
        .publish("test/topic", QoS::AtLeastOnce, false, "Hello, world!")
9
        .expect("Failed to publish message");
10
}

其中，"Hello, world!"是要发送的消息内容，可以是字符串、字节流或其他数据类型。

保留消息#

这个示例演示如何使用rumqttc模块发送和接收保留消息。

1
use rumqttc::{Client, MqttOptions, QoS};
2

3
fn main() {
4
    let mqtt_options = MqttOptions::new("test-retain", "localhost", 1883);
5

6
    let (mut client, _) = Client::new(mqtt_options, 10);
7

8
    client
9
        .publish("test/topic", QoS::AtLeastOnce, true, "hello world".to_owned())
10
        .unwrap();
11

12
    // 注意：rumqttc 没有提供 get_retained() 方法。
13
    // 订阅者订阅主题时会自动收到该主题的保留消息，
14
    // 无需主动获取。
15
}

展开收起

这个示例中，我们创建了一个MQTT客户端，连接到本地的MQTT服务器，然后发送了一条保留消息到test/topic主题。在调用publish方法时，我们指定了消息的QoS为AtLeastOnce，表示消息至少要被传输一次，但不保证只传输一次。第三个参数true表示该消息为保留消息。

订阅者订阅该主题时，MQTT服务器会自动推送最新的保留消息给订阅者，无需主动调用方法获取。

断开连接#

使用完rumqttc后，需要手动断开与MQTT服务器的连接。以下是一个断开连接的示例代码：

1
use rumqttc::{Client, MqttOptions};
2

3
fn main() {
4
    let mqtt_options = MqttOptions::new("test-4", "localhost", 1883);
5
    let (mut client, _) = Client::new(mqtt_options, 10);
6
    client
7
        .connect()
8
        .expect("Failed to connect to MQTT server");
9
    // ...
10
    client.disconnect().expect("Failed to disconnect from MQTT server");
11
}

使用Last Will和Testament#

这个示例演示如何使用rumqttc模块设置Last Will和Testament。

1
use rumqttc::{Client, LastWill, MqttOptions, QoS};
2

3
fn main() {
4
    let mut mqtt_options = MqttOptions::new("test-lwt", "localhost", 1883);
5

6
    let last_will = LastWill::new("test/topic", QoS::AtLeastOnce, "offline".to_owned());
7
    mqtt_options.set_last_will(last_will);
8

9
    let (mut client, _) = Client::new(mqtt_options, 10);
10

11
    // Do something here
12
}

这个示例中，我们创建了一个MQTT客户端，连接到本地的MQTT服务器。然后我们使用LastWill::new方法创建了一个Last Will和Testament，指定了主题、QoS和消息内容。注意：Last Will必须在创建Client之前通过mqtt_options.set_last_will()方法设置，而不是在Client创建之后调用。

TLS加密连接#

为了保护MQTT通信的安全性，可以使用TLS加密连接。使用rumqttc实现TLS加密连接也非常简单，只需要指定证书和私钥即可。以下是一个使用TLS加密连接的示例代码：

1
use std::fs::File;
2
use std::io::BufReader;
3
use std::path::Path;
4
use rumqttc::{Client, MqttOptions};
5
use rumqttc::tokio_rustls::rustls::{ClientConfig, RootCertStore};
6

7
fn main() {
8
    let mut mqtt_options = MqttOptions::new("test-5", "localhost", 8883);
9

10
    let mut root_store = RootCertStore::empty();
11
    let cert_file = &mut BufReader::new(File::open(Path::new("ca.crt")).unwrap());
12
    root_store.add_pem_file(cert_file).unwrap();
13
    let config = ClientConfig::builder()
14
        .with_root_certificates(root_store)
15
        .with_no_client_auth();
16
    mqtt_options.set_tls(config);
17

18
    let (mut client, _) = Client::new(mqtt_options, 10);
19
    client
20
        .connect()
21
        .expect("Failed to connect to MQTT server");
22
    // ...
23
}

展开收起

其中，ca.crt是CA证书。TLS配置必须在创建Client之前通过mqtt_options.set_tls()方法设置，使用rustls的ClientConfig::builder()模式构建TLS配置。

多线程处理消息#

使用多线程可以提高消息处理的效率和并发性。以下是一个使用多线程处理消息的示例代码：

1
use std::thread;
2
use rumqttc::{Client, MqttOptions, QoS};
3

4
fn main() {
5
    let mqtt_options = MqttOptions::new("test-6", "localhost", 1883);
6
    let (mut client, mut connection) = Client::new(mqtt_options, 10);
7
    client
8
        .subscribe("test/topic", QoS::AtLeastOnce)
9
        .expect("Failed to subscribe to topic");
10
    for message in connection.iter() {
11
        if let Ok(message) = message {
12
            let payload = message.payload.clone();
13
            let topic = message.topic.clone();
14
            thread::spawn(move || {
15
                println!("Received message: {} from topic: {}", payload, topic);
16
            });
17
        }
18
    }
19
}

展开收起

其中，thread::spawn()创建一个新线程来处理消息，可以使用闭包来捕获消息的内容。

总结#

rumqttc模块是一个非常方便的MQTT客户端库，它提供了一系列API，可以方便地实现MQTT协议的功能。本教程提供了几个常见的基础应用示例，希望对您有所帮助。

Rust语言从入门到精通系列 - 物联网消息传输协议MQTT(进阶)

Tue, 16 May 2023 00:00:00 GMT

rumqttc模块简介#

在Cargo.toml文件中添加rumqtt模块依赖, 示例配置如下：

1
[dependencies]
2
rumqttc = "0.21.0"

应用实践进阶#

使用QoS2传输消息#

这个示例演示如何使用rumqttc模块使用QoS2传输消息。

1
use rumqttc::{Client, MqttOptions, QoS};
2

3
fn main() {
4
    let mqtt_options = MqttOptions::new("test-qos2", "localhost", 1883);
5

6
    let (mut client, _) = Client::new(mqtt_options, 10);
7

8
    client
9
        .publish("test/topic", QoS::ExactlyOnce, false, "hello world".to_owned())
10
        .unwrap();
11
}

这个示例中，我们创建了一个MQTT客户端，连接到本地的MQTT服务器，然后发布了一条消息到test/topic主题。在调用publish方法时，我们指定了消息的QoS为ExactlyOnce，表示消息必须被传输一次，且只能被传输一次。

多客户端连接#

在实际应用中，我们通常需要同时处理多个MQTT客户端连接，可以通过创建多个Client实例来管理。rumqttc模块不提供内置连接池，但可以手动创建多个客户端连接。

1
use rumqttc::{Client, MqttOptions};
2

3
fn main() {
4
    let mut clients = Vec::new();
5

6
    for i in 0..10 {
7
        let mqtt_options = MqttOptions::new(format!("test-client-{}", i), "localhost", 1883);
8
        let (mut client, _) = Client::new(mqtt_options, 10);
9
        client.connect().unwrap();
10
        clients.push(client);
11
    }
12

13
    // Do something here
14
}

这个示例中，我们通过循环创建了10个MQTT客户端连接，每个客户端使用不同的ID连接到本地的MQTT服务器。

使用多线程#

在实际应用中，我们通常需要同时处理多个MQTT消息，这时候使用多线程可以提高性能和可靠性。Rust语言的多线程非常方便，可以使用标准库中的std::thread模块来创建线程。

1
use rumqttc::{Client, MqttOptions, QoS};
2
use std::thread;
3

4
fn main() {
5
    let mqtt_options = MqttOptions::new("test-thread", "localhost", 1883);
6

7
    let (mut client, _) = Client::new(mqtt_options, 10);
8

9
    let handle = thread::spawn(move || {
10
        client
11
            .publish("test/topic", QoS::AtLeastOnce, false, "hello world".to_owned())
12
            .unwrap();
13
    });
14

15
    handle.join().unwrap();
16
}

展开收起

这个示例中，我们创建了一个MQTT客户端，连接到本地的MQTT服务器。然后我们使用std::thread::spawn方法创建了一个新线程，这个线程会在后台发布一条消息到test/topic主题。

持久化存储消息#

通过持久化存储可以保证消息不会因为程序崩溃或网络故障而丢失。以下是一个使用SQLite数据库持久化存储消息的示例代码：

1
use std::thread;
2
use rumqttc::{Client, MqttOptions, QoS, Event, Incoming, Publish};
3

4
fn main() {
5
    let mqtt_options = MqttOptions::new("test-7", "localhost", 1883);
6
    let (mut client, mut connection) = Client::new(mqtt_options, 10);
7
    client.subscribe("test/topic", QoS::AtLeastOnce).unwrap();
8
    let mut storage = Storage::new("mqtt.db").unwrap();
9
    for event in connection.iter() {
10
        match event.unwrap() {
11
            Event::Incoming(Incoming::Publish(publish)) => {
12
                storage.insert_message(&publish).unwrap();
13
                println!("Received message: {} from topic: {}", publish.payload, publish.topic);
14
            },
15
            _ => {},
16
        }
17
    }
18
}
19

20
struct Storage {
21
    conn: rusqlite::Connection,
22
}
23

24
impl Storage {
25
    fn new(path: &str) -> rusqlite::Result<Self> {
26
        let conn = rusqlite::Connection::open(path)?;
27
        conn.execute("CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY, topic TEXT, payload TEXT, qos INTEGER)", [])?;
28
        Ok(Self { conn })
29
    }
30

31
    fn insert_message(&mut self, publish: &Publish) -> rusqlite::Result<()> {
32
        let mut stmt = self.conn.prepare("INSERT INTO messages (topic, payload, qos) VALUES (?, ?, ?)")?;
33
        let qos_val = publish.qos as i32;
34
        stmt.execute(rusqlite::params![publish.topic, publish.payload, qos_val])?;
35
        Ok(())
36
    }
37
}

展开收起

其中，Storage结构体使用SQLite数据库来持久化存储消息。在Event::Incoming(Packet::Publish(publish))分支中，将接收到的消息插入到数据库中。

总结#

rumqttc模块是一个非常方便的MQTT客户端库，它提供了一系列API，可以方便地实现MQTT协议的功能。本教程作为前一篇的进阶补充提供了常见的实际应用场景的应用示例，希望对您进一步深入的了解和掌握物联网传输协议MQTT有所帮助。

Rust语言从入门到精通系列 - MQTT协议异步API实战

Tue, 16 May 2023 00:00:00 GMT

MQTT（Message Queuing Telemetry Transport）是一种轻量级的消息传输协议，适用于物联网设备和低带宽、不稳定网络环境下的数据传输。Rust语言是一种安全、高效、并发的系统编程语言，非常适合开发物联网设备和后端服务。本教程将介绍如何使用Rust语言和rumqttc模块实现MQTT协议的异步API，并提供相关的代码示例，最佳实践和教程总结。

本篇内容主要围绕 rumqttc模块的 AsyncClient 进行，讲解异步API相关的内容.

在Cargo.toml文件中添加依赖：

1
[dependencies]
2
rumqttc = "0.21.0"

然后我们就可以开始编写代码了。

连接和订阅#

首先需要连接到MQTT服务器，并订阅一个主题。可以使用rumqttc模块提供的异步API实现。以下是示例代码：

1
use rumqttc::{AsyncClient, Event, Incoming, MqttOptions, QoS};
2

3
#[tokio::main]
4
async fn main() {
5
    let mqtt_options = MqttOptions::new("test-async", "mqtt.eclipseprojects.io", 1883);
6
    let (mut client, mut event_loop) = AsyncClient::new(mqtt_options, 10);
7

8
    // Connect to the broker
9
    client.connect().await.unwrap();
10

11
    // Subscribe to a topic
12
    client.subscribe("test/topic", QoS::AtMostOnce).await.unwrap();
13

14
    // Handle incoming events
15
    while let Some(event) = event_loop.poll().await.unwrap() {
16
        match event {
17
            Event::Incoming(Incoming::Publish(p)) => {
18
                println!("Received message: {:?}", p.payload);
19
            }
20
            _ => {}
21
        }
22
    }
23
}

展开收起

该代码创建了一个异步客户端，连接到了MQTT服务器，并订阅了一个主题。在事件循环中处理接收到的消息，如果是Publish事件，则打印出消息内容。

发布消息#

可以使用异步客户端的publish方法发布消息。以下是示例代码：

1
use rumqttc::{AsyncClient, MqttOptions, QoS};
2

3
#[tokio::main]
4
async fn main() {
5
    let mqtt_options = MqttOptions::new("test-async", "mqtt.eclipseprojects.io", 1883);
6
    let (mut client, _) = AsyncClient::new(mqtt_options, 10);
7

8
    // Connect to the broker
9
    client.connect().await.unwrap();
10

11
    // Publish a message
12
    client.publish("test/topic", QoS::AtMostOnce, false, b"Hello, MQTT!").await.unwrap();
13
}

该代码创建了一个异步客户端，连接到了MQTT服务器，并发布了一条消息到指定主题。

断开连接#

可以使用异步客户端的disconnect方法断开连接。以下是示例代码：

1
use rumqttc::{AsyncClient, MqttOptions};
2

3
#[tokio::main]
4
async fn main() {
5
    let mqtt_options = MqttOptions::new("test-async", "mqtt.eclipseprojects.io", 1883);
6
    let (mut client, _) = AsyncClient::new(mqtt_options, 10);
7

8
    // Connect to the broker
9
    client.connect().await.unwrap();
10

11
    // Disconnect from the broker
12
    client.disconnect().await.unwrap();
13
}

该代码创建了一个异步客户端，连接到了MQTT服务器，并断开了连接。

处理连接错误#

在连接或订阅过程中可能会出现错误，需要进行错误处理。可以使用Rust语言提供的Result类型和match语句处理错误。以下是示例代码：

1
use rumqttc::{AsyncClient, MqttOptions, QoS};
2

3
#[tokio::main]
4
async fn main() {
5
    let mqtt_options = MqttOptions::new("test-async", "mqtt.eclipseprojects.io", 1883);
6
    let (mut client, mut event_loop) = AsyncClient::new(mqtt_options, 10);
7

8
    // Connect to the broker
9
    if let Err(e) = client.connect().await {
10
        eprintln!("Failed to connect: {}", e);
11
        return;
12
    }
13

14
    // Subscribe to a topic
15
    if let Err(e) = client.subscribe("test/topic", QoS::AtMostOnce).await {
16
        eprintln!("Failed to subscribe: {}", e);
17
        return;
18
    }
19

20
    // Handle incoming events
21
    while let Some(event) = event_loop.poll().await {
22
        match event {
23
            Ok(Event::Incoming(Incoming::Publish(p))) => {
24
                println!("Received message: {:?}", p.payload);
25
            }
26
            Err(e) => {
27
                eprintln!("Error: {}", e);
28
                break;
29
            }
30
            _ => {}
31
        }
32
    }
33

34
    // Disconnect from the broker
35
    if let Err(e) = client.disconnect().await {
36
        eprintln!("Failed to disconnect: {}", e);
37
    }
38
}

展开收起

该代码在连接或订阅失败时打印错误信息，并退出程序。

使用TLS加密连接#

可以使用TLS加密连接来保护数据传输的安全性。可以使用MqttOptions的tls选项指定TLS配置。以下是示例代码：

1
use rumqttc::{AsyncClient, MqttOptions, QoS};
2

3
#[tokio::main]
4
async fn main() {
5
    let mqtt_options = MqttOptions::new("test-async", "mqtt.eclipseprojects.io", 8883)
6
        .set_tls(rumqttc::TlsOptions::default());
7
    let (mut client, mut event_loop) = AsyncClient::new(mqtt_options, 10);
8

9
    // Connect to the broker
10
    client.connect().await.unwrap();
11

12
    // Subscribe to a topic
13
    client.subscribe("test/topic", QoS::AtMostOnce).await.unwrap();
14

15
    // Handle incoming events
16
    while let Some(event) = event_loop.poll().await.unwrap() {
17
        match event {
18
            Event::Incoming(Incoming::Publish(p)) => {
19
                println!("Received message: {:?}", p.payload);
20
            }
21
            _ => {}
22
        }
23
    }
24

25
    // Disconnect from the broker
26
    client.disconnect().await.unwrap();
27
}

展开收起

该代码使用TLS加密连接到了MQTT服务器。

总结#

本教程介绍了如何使用Rust语言和rumqttc模块实现MQTT协议的异步API，并提供了代码示例，最佳实践和教程总结。使用异步API可以提高性能和并发处理能力，使用Result类型和match语句处理错误可以避免程序崩溃，使用TLS加密连接保护数据传输的安全性，使用QoS选项控制消息传输的可靠性和效率，使用subscribe方法订阅主题，使用publish方法发布消息，使用disconnect方法断开连接。Rust语言和rumqttc模块是开发物联网设备和后端服务的有力工具。

Rust语言从入门到精通系列 - Tonic RPC框架入门实战

Tue, 09 May 2023 00:00:00 GMT

Rust语言是一种系统级语言，被誉为“没有丧失性能的安全语言”。Rust语言的优势在于其内存安全机制，在编译时就能保证程序的内存安全。

Tonic模块是Rust语言的一个RPC（Remote Procedure Call，远程过程调用）框架，它在性能、可靠性、框架友好程度以及可扩展性等方面表现卓越。

本系列 Tonic 篇将由浅入深的从基础到实战，以一个完整的 Rust 语言子系列讲解tonic模块。

基础用法#

添加Tonic依赖#

在Rust项目的Cargo.toml文件中，加入以下依赖项：

1
[dependencies]
2
tonic = "0.9.2"

定义服务#

在Tonic中，我们需要定义一个服务（service），服务包含了多个方法（method）。下面是一个示例：

1
use tonic::{Request, Response, Status};
2

3
// 定义一个服务
4
pub struct MyService {}
5

6
// 为服务实现方法
7
#[tonic::async_trait]
8
impl MyService {
9
    async fn my_method(&self, request: Request<MyRequest>) -> Result<Response<MyResponse>, Status> {
10
        // 做一些操作
11
        // 返回结果
12
    }
13
}

启动服务#

我们使用tokio库来运行Tonic服务，示例代码如下：

1
use tokio::net::TcpListener;
2
use tonic::transport::Server;
3

4
#[tokio::main]
5
async fn main() -> Result<(), Box<dyn std::error::Error>> {
6
    let addr = "[::]:50051".parse()?;
7
    let listener = TcpListener::bind(addr).await?;
8
    let my_service = MyService {};
9

10
    println!("Server listening on {}", addr);
11

12
    Server::builder()
13
        .add_service(MyServiceServer::new(my_service))
14
        .serve_with_incoming(listener)
15
        .await?;
16

17
    Ok(())
18
}

展开收起

这个服务绑定在本地的50051端口上，并等待连接。

定义请求和响应结构体#

在Tonic中，我们需要定义请求和响应的结构体，示例代码如下：

1
#[derive(Debug)]
2
pub struct MyRequest {
3
    pub name: String,
4
}
5

6
#[derive(Debug)]
7
pub struct MyResponse {
8
    pub message: String,
9
}

实现方法#

我们在服务中，实现一些具体的方法。示例代码如下：

1
#[tonic::async_trait]
2
impl MyService {
3
    async fn my_method(&self, request: Request<MyRequest>) -> Result<Response<MyResponse>, Status> {
4
        let req = request.into_inner();
5

6
        println!("Request received: {:?}", req);
7

8
        // 构造响应
9
        let resp = MyResponse {
10
            message: format!("Hello, {}!", req.name),
11
        };
12

13
        Ok(Response::new(resp))
14
    }
15
}

展开收起

调用服务#

我们可以使用Tonic提供的客户端来调用服务。示例代码如下：

1
// 初始化客户端
2
let mut my_service_client = MyServiceClient::connect("http://[::1]:50051").await?;
3

4
// 构造请求
5
let request = Request::new(MyRequest {
6
    name: "world".into(),
7
});
8

9
// 发送请求
10
let response = my_service_client.my_method(request).await?;
11

12
println!("Response received: {:?}", response);

处理错误#

在Rust中，我们使用Result来处理错误。例如：

1
#[tonic::async_trait]
2
impl MyService {
3
    async fn my_method(&self, request: Request<MyRequest>) -> Result<Response<MyResponse>, Status> {
4
        let req = request.into_inner();
5

6
        if req.name == "" {
7
            return Err(Status::invalid_argument("name cannot be empty"));
8
        }
9

10
        // 构造响应
11
        let resp = MyResponse {
12
            message: format!("Hello, {}!", req.name),
13
        };
14

15
        Ok(Response::new(resp))
16
    }
17
}

展开收起

这个例子说明，如果请求的name字段是空字符串，将返回Status::invalid_argument错误。

使用连接池#

Tonic提供了连接池的支持，通过这个机制，可以让我们复用连接，从而减少连接的创建和销毁。示例代码如下：

1
use tonic::transport::{Endpoint, Channel, security::ServerTlsOption, client::tls::rustls::RootCertStore};
2

3
// 初始化连接池
4
let channel = Endpoint::from_static("http://[::1]:50051")
5
    .connect_lazy()
6
    .unwrap();
7

8
// 使用连接池
9
let mut my_service_client = MyServiceClient::new(channel);

自定义认证#

Tonic提供了自定义认证机制，例如，我们可以在服务端自定义一段中间件，来进行认证。示例代码如下：

1
use tonic::{Interceptor, Request, Response, Status};
2

3
struct AuthMiddleware {}
4

5
#[tonic::async_trait]
6
impl<O: Send + 'static> Interceptor<O> for AuthMiddleware {
7
    async fn call(&mut self, req: Request<O>, next: tonic::interceptor::Next<'_, O>) -> Result<Response<O>, Status> {
8
        // 检查用户是否已登录
9
        if !is_user_logged_in() {
10
            return Err(Status::unauthenticated("user is not logged in"));
11
        }
12

13
        next.run(req).await
14
    }
15
}

展开收起

这个例子说明，我们可以利用Interceptor机制，在请求处理前，统一进行认证。

支持SSL连接#

Tonic提供了SSL连接的支持，而且通过TLS选项配置加密和认证选项。示例代码如下：

1
use tonic::{transport::Channel, client::tls::rustls::RootCertStore, transport::{Endpoint, Server}};
2
use tonic::transport::server::TlsConfig;
3

4
// 初始化SSL连接
5
let root_ca = RootCertStore::from_path("ca.pem").unwrap();
6
let tls = ClientTlsConfig::new().root_ca_cert(root_ca).identity(...);
7
let channel = Endpoint::from_static("https://[::1]:50051")
8
            .tls_config(TlsConfig::new().client_tls_config(tls))
9
            .connect()
10
            .await?;
11

12
// 使用SSL连接访问
13
let mut my_service_client = MyServiceClient::new(channel);

这个例子说明，我们通过传递确切的TLS选项，在客户端连接时使用SSL。

总结#

在本教程中，我们学习了如何使用Rust语言的Tonic模块创建一个简单的gRPC服务，并深入了解了一些高级功能。我们了解了如何支持TLS加密通信，如何支持自定义的拦截器，如何支持流式传输，以及如何支持异步/非阻塞I/O。我们还提供了一些最佳实践，以帮助您编写高质量的代码。

Python 3.x从基础到实战 - 文件相关操作

Sat, 06 May 2023 00:00:00 GMT

Python是一种高级编程语言，可以轻松地处理各种文件。在Python中，我们可以使用内置的文件操作函数和模块来读取、写入、追加、创建、替换等各种文件操作。本教程将为您提供Python文件操作的详细指南，包括with语句的代码示例以及文件的高级应用示例。

open()函数#

在Python中，我们使用open()函数来打开文件。open()函数返回一个文件对象，它可以用于读取、写入和追加文件。open()函数需要两个参数：文件名和模式。文件名是要打开的文件的名称和路径。模式是打开文件的方式，例如读取、写入、追加等。

file: 可以是文件路径或文件对象。如果是文件路径，需要提供文件的完整路径和文件名，如果是文件对象，可以是一个已经打开的文件对象或者是一个文件流对象。
mode: 打开文件的模式，可以是只读模式（‘r’）、写入模式（‘w’）、追加模式（‘a’）、二进制模式（‘b’）等。
buffering: 缓冲区大小，可以设置为0表示不使用缓冲区，设置为1表示使用行缓冲，设置为大于1的整数表示使用指定大小的缓冲区。
encoding: 文件编码，用于指定文件的编码格式，例如UTF-8、GBK等。
errors: 编码错误处理方式，用于指定当读取文件时遇到编码错误时的处理方式，例如忽略错误、替换错误字符等。
newline: 行结束符，用于指定写入文件时使用的行结束符，例如’\n’表示使用换行符作为行结束符。

mode模式的常用参数及注释。

模式	描述
’r’	读取模式，打开文件用于读取（默认值）
‘w’	写入模式，打开文件用于写入，如果文件已存在，将会覆盖文件
’x’	独占模式，打开文件用于独占写入，如果文件已存在，会抛出FileExistsError异常
’a’	追加模式，打开文件用于追加写入，如果文件不存在，将会创建文件
’b’	二进制模式，打开文件用于二进制读取或写入
’t’	文本模式，打开文件用于文本读取或写入（默认值）
’+‘	读写模式，打开文件用于同时读取和写入

基础文件操作#

读取文件#

要读取文件，我们使用模式’r’来打开文件。在这种模式下，文件指针位于文件的开头。我们可以使用read()函数来读取文件的内容。read()函数返回文件的全部内容，或者如果指定了参数，则返回指定数量的字符。

1
with open('file.txt', 'r') as file:
2
    data = file.read()
3
    print(data)

在上面的代码中，我们打开了一个名为’file.txt’的文件，并将其赋值给变量’file’。然后，我们使用read()函数读取文件的全部内容，并将其赋值给变量’data’。最后，我们使用print()函数输出文件的内容。

写入文件#

要写入文件，我们使用模式’w’来打开文件。在这种模式下，如果文件不存在，则会创建一个新文件。如果文件已经存在，则会覆盖文件的内容。我们可以使用write()函数将数据写入文件。

1
with open('file.txt', 'w') as file:
2
    file.write('Hello, world!')

在上面的代码中，我们打开了一个名为’file.txt’的文件，并将其赋值给变量’file’。然后，我们使用write()函数将字符串’Hello, world!’写入文件。

追加文件#

要追加文件，我们使用模式’a’来打开文件。在这种模式下，文件指针位于文件的末尾。我们可以使用write()函数将数据追加到文件的末尾。

1
with open('file.txt', 'a') as file:
2
    file.write('\nHello, again!')

在上面的代码中，我们打开了一个名为’file.txt’的文件，并将其赋值给变量’file’。然后，我们使用write()函数将字符串’\nHello, again!’追加到文件的末尾。

创建文件#

要创建文件，我们使用模式’x’来打开文件。在这种模式下，如果文件已经存在，则会引发FileExistsError异常。如果文件不存在，则会创建一个新文件。我们可以使用write()函数将数据写入文件。

1
with open('file.txt', 'x') as file:
2
    file.write('Hello, world!')

在上面的代码中，我们打开了一个名为’file.txt’的文件，并将其赋值给变量’file’。然后，我们使用write()函数将字符串’Hello, world!’写入文件。如果文件已经存在，则会引发FileExistsError异常。

关闭文件#

在Python中，打开文件后，我们必须关闭文件，以释放资源并保存文件更改。我们可以使用close()函数来关闭文件。

1
file = open('file.txt', 'r')
2
data = file.read()
3
file.close()

在上面的代码中，我们打开了一个名为’file.txt’的文件，并将其赋值给变量’file’。然后，我们使用read()函数读取文件的全部内容，并将其赋值给变量’data’。最后，我们使用close()函数关闭文件。

但是，如果在使用文件后忘记关闭文件，则可能会导致资源泄漏和文件损坏。为了避免这种情况，我们可以使用with语句来自动关闭文件。

1
with open('file.txt', 'r') as file:
2
    data = file.read()

在上面的代码中，我们使用with语句打开一个名为’file.txt’的文件，并将其赋值给变量’file’。然后，我们使用read()函数读取文件的全部内容，并将其赋值给变量’data’。最后，with语句自动关闭文件。

文件相关场景用法#

除了基本的文件读取、写入、追加和创建操作外，Python还提供了许多高级文件操作。在本节中，我们将介绍四个高级文件应用示例。

逐行读取文件#

在Python中，我们可以使用for循环逐行读取文件。这对于大型文件非常有用，因为它允许我们一次只读取一行，而不是将整个文件读入内存。

1
with open('file.txt', 'r') as file:
2
    for line in file:
3
        print(line)

在上面的代码中，我们使用with语句打开一个名为’file.txt’的文件，并将其赋值给变量’file’。然后，我们使用for循环逐行读取文件，并将每一行打印到屏幕上。

使用json格式读写文件#

JSON是一种轻量级数据交换格式，通常用于Web应用程序的数据交换。在Python中，我们可以使用json模块来读取和写入JSON格式的文件。

1
import json
2

3
# 写入JSON格式的文件
4
data = {'name': 'John', 'age': 30, 'city': 'New York'}
5
with open('data.json', 'w') as file:
6
    json.dump(data, file)
7

8
# 读取JSON格式的文件
9
with open('data.json', 'r') as file:
10
    data = json.load(file)
11
    print(data)

在上面的代码中，我们导入了json模块。然后，我们使用字典对象创建一个名为’data’的变量。接下来，我们使用json.dump()函数将’data’写入一个名为’data.json’的文件中。最后，我们使用json.load()函数从’data.json’文件中读取数据，并将其赋值给变量’data’。然后，我们使用print()函数输出变量’data’。

压缩和解压文件#

在Python中，我们可以使用gzip模块来压缩和解压文件。gzip模块提供了GzipFile类，它允许我们打开压缩文件，并在其中读取和写入数据。

1
import gzip
2

3
# 压缩文件
4
with open('file.txt', 'rb') as file_in:
5
    with gzip.open('file.txt.gz', 'wb') as file_out:
6
        file_out.write(file_in.read())
7

8
# 解压文件
9
with gzip.open('file.txt.gz', 'rb') as file_in:
10
    with open('file.txt', 'wb') as file_out:
11
        file_out.write(file_in.read())

在上面的代码中，我们导入了gzip模块。然后，我们使用with语句打开一个名为’file.txt’的文件，并将其赋值给变量’file_in’。接下来，我们使用with语句打开一个名为’file.txt.gz’的压缩文件，并将其赋值给变量’file_out’。然后，我们使用write()函数将’file_in’中的数据写入’file_out’中。最后，我们使用with语句打开一个名为’file.txt.gz’的压缩文件，并将其赋值给变量’file_in’。接下来，我们使用with语句打开一个名为’file.txt’的文件，并将其赋值给变量’file_out’。然后，我们使用write()函数将’file_in’中的数据写入’file_out’中。

使用CSV格式读写文件#

CSV是一种常用的电子表格文件格式，通常用于数据交换。在Python中，我们可以使用csv模块来读取和写入CSV格式的文件。

1
import csv
2

3
# 写入CSV格式的文件
4
data = [['name', 'age', 'city'], ['John', '30', 'New York'], ['Mary', '25', 'Los Angeles']]
5
with open('data.csv', 'w', newline='') as file:
6
    writer = csv.writer(file)
7
    writer.writerows(data)
8

9
# 读取CSV格式的文件
10
with open('data.csv', 'r') as file:
11
    reader = csv.reader(file)
12
    for row in reader:
13
        print(row)

在上面的代码中，我们导入了csv模块。然后，我们使用一个名为’data’的列表对象创建一个CSV格式的数据。接下来，我们使用csv.writer()函数将’data’写入一个名为’data.csv’的文件中。注意，我们需要使用newline=”参数来避免在写入文件时出现空行。最后，我们使用csv.reader()函数从’data.csv’文件中读取数据，并使用for循环逐行打印数据。

结论#

在本教程中，我们学习了Python文件操作的基础知识，包括打开、关闭、读取、写入、追加和创建文件。我们还介绍了with语句的使用，以及文件的高级应用示例，包括逐行读取文件、使用json格式读写文件、压缩和解压文件以及使用CSV格式读写文件。这些知识将帮助您在Python中处理各种文件，使您的编程更加高效和有趣。

Struct Util 权威指南 - 框架简介

Mon, 01 May 2023 00:00:00 GMT

Struct Util 是一个 Java 语言开发的结构化数据映射处理工具。Struct Util 主要解决两个方面的问题。第一个方面将*.xls, *.csv 等配置友好型数据源转换为业务侧友好型的 bean 结构，对配置数据和使用数据进行解耦，让开发和运营实现共赢。第二方面解决了数据表热重载，数据有条件过滤，表结构跨表引用等等应用相关的问题。

StructUtil是博主个人作品, 稍微有自吹自擂的嫌疑, 欢迎:star:收藏。哈哈, 因为是个人作品，应该是足够”权威”了。嘻嘻~~

由于包名和包路径不符合 maven repo 的管理要求，没有推送到 maven repo，有兴趣尝试的同学可以尝试 github 下载或者自行编译发布本地。

功能特性#

低侵入。对已有的代码仅需使用 StructField 和 StructSheet 两个注解
高性能、低内存占用。使用增量或 Stream API 的方式避免大文件读取带来的低性能、高内存占用的问题
扩展性。提供 WorkerMatcher、StructHandler、Converter 等扩展点供用户实现自定义扩展功能
结构化数据自动校验和检查。自动检查校验结构化数据及依赖之间的关系。避免出现循环依赖等问题
丰富的内置解析器。内置提供 .xls、.xlsx、.json、.xml 四种常见结构化数据的解析器（扩展中）
丰富的 JDK 原生类的类型转换支持
自定义类型转换器{Converter}
灵活的结构化数据整理机制。输出的结果支持 Array、List、Map、Vector、Set 等 JDK 内置或自定义的集合容器
灵活的文件变更监听和结构化数据文件动态加载能力
支持 Record 类型(JDK 16+).

架构设计#

参考资料#

Struct Util 权威指南 - 基础应用入门实战

Mon, 01 May 2023 00:00:00 GMT

Struct Util 是一个 Java 语言开发的结构化数据映射处理工具。Struct Util 主要解决两个方面的问题。第一个方面将*.xls, *.csv 等配置友好型数据源转换为业务侧友好型的 bean 结构，对配置数据和使用数据进行解耦，让开发和运营、策划三方实现共赢。第二方面解决了数据表热重载，数据有条件过滤，表结构跨表引用等等应用相关的问题。

StructUtil是博主个人作品, 稍微有自吹自擂的嫌疑, 欢迎:star:收藏。哈哈, 因为是个人作品，应该是足够”权威”了。嘻嘻~~

基础入门#

框架核心由两个注解组成，业务代码也是围绕着两个注解实现的。下面我们根据注解中定义的属性学习一下 @StructSheet 和 @StructField 两个注解。

@StructSheet 注解#

定义数据文件的结构.

注解名称	缺省值	可选字段	备注
fileName	”	N	数据文件名称, 带文件的后缀名. e.g. struct.xlsx
sheetName	’Sheet1’	Y	表单名称. 针对 Excel 文件的包含多个 Sheet
startOrder	1	Y	控制文件读取的开始. 缺省为: 1 从 excel 的 1 行(第一行为 0)或文件的第一行开始
endOrder	-1	Y	控制文件读取的结束. 缺省为:-1
matcher	WorkerMatcher.class	Y	自定义 WorkHandler, 可以根据条件指定处理的 StructHandler.
filter	StructBeanFilter.class	Y	过滤、筛选符合条件的数据结构.

@StructField 注解#

定义列结构.

注解名称	缺省值	可选字段	备注
name	”	Y	数据文件中的列名, 当设置非空字符串时，使用注解的值替代类文件中的字段名
ref	Object.class	Y	引用其他结构
refGroupBy	{}	Y	当 ref 值有效时, 引用的结构数据根据字段进行分组
refUniqueKey	{}	Y	当 ref 值有效时, 引用的结构数据根据字段转换为 Map
aggregateBy	”	Y	根据父结构中的字段值，对子结构进行聚合. 类似于 groupBy 的功能.
aggregateType	Object.class	Y	当 aggregateBy 生效时，聚合的集合类型. 不支持 Map
required	false	Y	字段值非空检查. 设置为 True 时, 字段值必须为非 null 的值.
converter	无	Y	将数据文件中的数据转换为期望的 JO

ref, refGroupBy, refUniqueKey 引用关系，groupby 将子数据集进行分组，uniqueKey 将子数据集的键值对的 key，主要是根据子数据集的字段进行数据划分和处理。

aggregateBy, aggregateType 使用父集合中的数据进行聚合处理，类型进支持数组和 List，暂时不支持聚合键值对。

converter 支持可扩展的字段类型转换器。

定义 Animal 类型#

定义一个 Animal 的 Struct 结构，包含 name age weight 三个字段。结构对应的数据文件为”cfg_animal.xlsx”。

1
@StructSheet(fileName = "../cfg_animal.xlsx")
2
public class Animal {
3
    private String name;
4
    private int age;
5
    private int weight;
6
}

使用 StructWorker 进行数据加载。

1
@Test
2
public void test() {
3
    StructWorker<Animal> worker = WorkerUtil.newWorker("./data/", Animal.class);
4
    ArrayList<Animal> list = worker.load(ArrayList::new);
5
    //    ...
6
}

使用 @StructOptional 注解聚合异构对象#

某些业务场景中我们可能需要聚合不同数据结构的类型到同一个表中。

1
@StructSheet(fileName = "../cfg_animal.xlsx")
2
public class Animal {
3
    private String name;
4
    private int age;
5
    private int weight;
6
    @StructOptional(value = {
7
            @StructField(ref = ExtraData1.class, refUniqueKey = "id"),
8
            @StructField(ref = ExtraData2.class, refUniqueKey = "id")
9
    })
10
    private Object extra;
11
}

根据 value 的 @StructField 顺序尝试解析引用数据，一直到找到某个值为止。例如动物的科属目信息，每个动物皆不相同，需要在总 Animal 信息集成。

Struct Util 权威指南 - 与Spring Framework框架集成

Mon, 01 May 2023 00:00:00 GMT

StructUtil是博主个人作品, 稍微有自吹自擂的嫌疑, 欢迎:star:收藏。哈哈, 因为是个人作品，应该是足够”权威”了。嘻嘻~~

struct-spring 模块#

struct-spring 主要是针对 struct-core 的扩展，用于支持 Spring Framework，并利用 Spring 框架的众多特性扩展增强 struct-core 功能。

新增了@AutoStruct @StructScan @StructStoreOptions 三个注解。

首先引入依赖包

1
implementation('org.structutil:struct-spring:{VERSION}')

@AutoStruct#

结构体自动托管注解, 显示的指明这个类是一个 Struct，并且需要托管给 Spring Framework 容器。

属性	缺省值	可选字段	备注
clzOfStore	”	Y	数据结构存储的集合类型 ListStructStore MapStructStore 或者其他 StructStore 接口的自定义实现
mapKey	”	Y	当 MapStructStore 结构时, 用于解决键值对的 key
keyResolverBeanName	”	Y	当 MapStructStore 结构时, 用于解决键值对的 key 的容器中 resolver 的名称
keyResolverBeanClass	StructKeyResolver.class	Y	当 MapStructStore 结构时, 用于解决键值对的 key 的类对象

示例代码如下：

1
@AutoStruct(keyResolverBeanName = "dataStructKeyResolver")
2
@StructSheet(fileName = "cfg_animal.xlsx", sheetName = "Sheet1")
3
public class Animal {
4
//    ...
5
}

或者 XML 风格

1
<bean id="store_1" class="org.struct.spring.support.MapStructStore">
2
    <property name="clzOfBean" value="org.struct.examples.Animal"/>
3
    <property name="keyResolverBeanName" value="dataStructKeyResolver"/>
4
</bean>

@StructScan#

托管数据结构扫描器。集成到 Spring Framework 框架中，再启动时扫描类路径并处理托管的 Struct 示例。

1
public @interface StructScan {
2

3
    /**
4
     * Alias for {@link #basePackages}.
5
     * <p>Allows for more concise annotation declarations if no other attributes
6
     * are needed &mdash; for example, {@code @ComponentScan("org.my.pkg")}
7
     * instead of {@code @ComponentScan(basePackages = "org.my.pkg")}.
8
     */
9
    String[] value() default {};
10

11
    /**
12
     * Base packages to scan for annotated components.
13
     * <p>{@link #value} is an alias for (and mutually exclusive with) this
14
     * attribute.
15
     * <p>Use {@link #basePackageClasses} for a type-safe alternative to
16
     * String-based package names.
17
     */
18
    String[] basePackages() default {};
19

20
    /**
21
     * Type-safe alternative to {@link #basePackages} for specifying the packages
22
     * to scan for annotated components. The package of each class specified will be scanned.
23
     * <p>Consider creating a special no-op marker class or interface in each package
24
     * that serves no purpose other than being referenced by this attribute.
25
     */
26
    Class<?>[] basePackageClasses() default {};
27

28
    /**
29
     * The {@link BeanNameGenerator} class to be used for naming detected components
30
     * within the Spring container.
31
     * <p>The default value of the {@link BeanNameGenerator} interface itself indicates
32
     * that the scanner used to process this {@code @ComponentScan} annotation should
33
     * use its inherited bean name generator, e.g. the default
34
     * {@link AnnotationBeanNameGenerator} or any custom instance supplied to the
35
     * application context at bootstrap time.
36
     *
37
     * @see AnnotationConfigApplicationContext#setBeanNameGenerator(BeanNameGenerator)
38
     */
39
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
40

41
}

展开收起

@StructStoreOptions 配置#

属性	缺省值	可选字段	备注
workspace	’./data/‘	Y	配置数据的根目录
lazyLoad	false	Y	是否允许异步加载配置数据
waitForInit	false	Y	当其他线程正在加载数据时，是否同步等待初始化完成

Struct 数据管理#

集成到 Spring Framework 的最大一点好处就是可以托管给 Spring 容器管理我们的配置数据，并使用 IOC 特性和业务解耦。

Struct 数据管理服务 `StructStoreService`#

1
public class StructStoreService implements BeanPostProcessor, SmartInitializingSingleton, DisposableBean {
2
    //    ....
3
}

StructStoreService 类实现了三个 Spring 框架的接口 BeanPostProcessor, SmartInitializingSingleton, DisposableBean，用于管理 StructStore 的初始化和完整的生命周期。

Service 中总结和内置博主业务中常用的一些方法。列表如下：

方法	备注
void initialize(Class clzOfBean)	初始化
void reload(Class clzOfBean)	重加载
void dispose(Class clzOfBean)	销毁
List getAll(Class clzOfBean)	获取全部 Struct 实例
B get(Class clzOfBean, K key)	根据 key 获取 Struct 实例
B getOrDefault(Class clzOfBean, K key, B dv)	根据 key 获取 Struct 实例，不存在时返回缺省值
Optional tryGet(Class clzOfBean, K key)	尝试根据 key 获取 Struct 实例
List lookup(Class clzOfBean, K… keys)	根据 key 列表获取 Struct 实例列表
List lookup(Class clzOfBean, Predicate filter)	根据条件筛选 Struct 实例列表

列表数据结构存储 `ListStructStore`#

以 List 的形式管理 Struct 数据。

键值对数据结构存储 `MapStructStore`#

以 Map 的形式管理 Struct 数据。

StructKeyResolver#

通过传入 Bean 并获取 MapStructStore 的 key 字段值。

1
/**
2
 * {@link MapStructStore} key's resolver.
3
 *
4
 * @author TinyZ.
5
 * @version 2020.07.17
6
 */
7
@FunctionalInterface
8
public interface StructKeyResolver<K, B> {
9

10
    K resolve(B bean);
11
}

Struct Util 权威指南 - 集成到Spring Boot全家桶

Mon, 01 May 2023 00:00:00 GMT

StructUtil是博主个人作品, 稍微有自吹自擂的嫌疑, 欢迎:star:收藏。哈哈, 因为是个人作品，应该是足够”权威”了。嘻嘻~~

struct-spring-boot-starter 模块#

struct-spring-boot-starter 主要是针对 struct-spring 的扩展，用于支持 Spring Boot 框架，通过自动化配置，降低 struct-spring 的使用门槛。

模块依赖 Spring Boot 2.5.x 版本, 更高版本未经过测试.

首先引入依赖包

1
implementation('org.structutil:struct-spring-boot-starter:{VERSION}')

前缀 struct 配置#

注解名称	缺省值	可选字段	备注
structRequiredDefault	false	Y	字段依赖缺省值, 字段必须不为null
ignoreEmptyRow	true	Y	是否忽略数据源中的空行
arrayConverter.stringSeparator	’\|‘	Y	数组转换器的分隔符
arrayConverter.stringTrim	true	Y	是否调用trim方法处理字符串
arrayConverter.ignoreBlank	false	Y	是否忽略空字符串

前缀 struct.store.service 配置#

定义数据文件的结构.

注解名称	缺省值	可选字段	备注
workspace	’./data/‘	N	工作空间根目录路径
lazyLoad	true	Y	是否按需加载，异步加载.
watchFile	true	Y	是否启用文件变动监听
scheduleInitialDelay	10000	Y	watchFile为true时有效，初始定时检查任务的时间.
scheduleDelay	5000	Y	watchFile为true时有效，定时检查任务的间隔时间.
scheduleTimeUnit	SECONDS	Y	watchFile为true时有效，定时检查任务的时间单位.
banner	true	Y	打印Struct Util的Banner.

Spring 框架缺省配置#

1
#===================================== Struct Util Configuration ======================================
2
#   是否启用spring-boot-starter自动配置. 默认:true
3
struct.store.enable=true
4
#   是否开启StructStoreService服务. 默认:true
5
struct.store.service.enable=true
6
#   工作空间
7
struct.store.service.workspace=./data/
8
#   StructStore是否通过懒加载方式初始化. 默认:true
9
struct.store.service.lazy-load=false
10
#   是否启用FileWatchService监控文件变更.  默认:true
11
struct.store.service.watch-file=true
12
#   文件变更监控的扫描定时任务初始间隔. 默认:10
13
struct.store.service.schedule-initial-delay=10
14
#   文件变更监控的扫描间隔. 默认:5
15
struct.store.service.schedule-delay=5
16
#   文件变更监控的扫描间隔时间单位. 默认:秒
17
struct.store.service.schedule-time-unit=SECONDS
18
#   懒加载模式下，在读取数据时, StructStore为初始化完成时，是否同步等待加载完成. 魔人:true
19
struct.store.service.sync-wait-for-init=true

展开收起

Struct Util 权威指南 - 通过 SPI 实现自定义扩展

Mon, 01 May 2023 00:00:00 GMT

StructUtil是博主个人作品, 稍微有自吹自擂的嫌疑, 欢迎:star:收藏。哈哈, 因为是个人作品，应该是足够”权威”了。嘻嘻~~

SPI 扩展#

Struct Util 提供了 Converters, Converter, StructFactoryBean, StructHandler四个扩展点，允许用户进行功能扩展。

EnhancedServiceLoader#

相比于 JDK 内置的 SPI 功能解决了加载异常处理，懒加载等问题。核心加载代码如下：

1
void handleDefinitionFile(String dir, ClassLoader classLoader, List<ExtensionDefinition> output) throws IOException {
2
    String fileName = dir + this.service.getName();
3
    Enumeration<URL> urls = classLoader != null
4
            ? classLoader.getResources(fileName)
5
            : ClassLoader.getSystemResources(fileName);
6
    while (urls.hasMoreElements()) {
7
        URL url = urls.nextElement();
8
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), StandardCharsets.UTF_8))) {
9
            String line = null;
10
            while (null != (line = reader.readLine())) {
11
                line = line.trim();
12
                if (line.length() > 0) {
13
                    try {
14
                        output.add(this.createExtensionDefinition(line, classLoader));
15
                    } catch (LinkageError | ClassNotFoundException e) {
16
                        LOGGER.warn("load [{}] class failure. {}", line, e.getMessage());
17
                    }
18
                }
19
            }
20
        } catch (Throwable e) {
21
            LOGGER.warn("handle extension definition file error.", e);
22
        }
23
    }
24
}
25

26
ExtensionDefinition createExtensionDefinition(String clzName, ClassLoader loader) throws ClassNotFoundException {
27
    Class<?> clzOfService = Class.forName(clzName, true, loader);
28
    String name = null;
29
    int order = 0;
30
    SPI anno = AnnotationUtils.findAnnotation(SPI.class, clzOfService);
31
    if (anno != null) {
32
        name = anno.name();
33
        order = anno.order();
34
    }
35
    return new ExtensionDefinition(name, clzOfService, order);
36
}

展开收起

自定义 Converter#

Struct Util内置了常用的类型转换器, 当用户有特殊转换需求时，可以通过扩展 Converter 接口实现转换业务，并通过 SPI 机制自动注册到系统中。以下是一个简单的字符串转数组的转换器实例。

1
public class StringToArrayConverter implements Converter {
2

3
    @Override
4
    public Object convert(Object originValue, Class<?> targetType) {
5
        if (!targetType.isArray() || String.class != originValue.getClass()) {
6
            return null;
7
        }
8
        String content = (String) originValue;
9
        Class<?> componentType = targetType.getComponentType();
10
        String[] data = content.split(separator);
11
        if (exceptBlank) {
12
            data = Arrays.stream(data)
13
                    .map(String::trim)
14
                    .filter(s -> !s.isEmpty())
15
                    .toArray(String[]::new);
16
        }
17
        Object array = Array.newInstance(componentType, data.length);
18
        for (int i = 0; i < data.length; i++) {
19
            Array.set(array, i, ConverterUtil.covert(data[i], componentType));
20
        }
21
        return array;
22
    }
23
}

展开收起

Struct Util 权威指南 - 配置文件的热重载

Mon, 01 May 2023 00:00:00 GMT

StructUtil是博主个人作品, 稍微有自吹自擂的嫌疑, 欢迎:star:收藏。哈哈, 因为是个人作品，应该是足够”权威”了。嘻嘻~~

WatchService 注册监听文件变动#

在 WatchService 注册需要监听的目录路径或文件路径，并指定仅关注 ENTRY_MODIFY 事件，路径相关的全部变动的事件通过 WatchKey#pollEvents()方法获取。核心实现业务代码如下：

1
public FileWatcherService register(String dir) throws IOException {
2
    return this.register(Paths.get(Objects.requireNonNull(dir, "dir")));
3
}
4

5
public FileWatcherService register(Path dir) throws IOException {
6
    Objects.requireNonNull(dir, "dir");
7
    WatchKey key = dir.register(ws, StandardWatchEventKinds.ENTRY_MODIFY);
8
    Path p = keys.putIfAbsent(key, dir);
9
    if (null == p) {
10
        LOGGER.info("Register file watcher service. path: {}", dir.toAbsolutePath());
11
    }
12
    return this;
13
}
14

15
public FileWatcherService registerAll(String path) throws IOException {
16
    return this.registerAll(Paths.get(path));
17
}
18

19
/**
20
    * Register the given directory, and all its sub-directories, with the
21
    * WatchService.
22
    */
23
public FileWatcherService registerAll(final Path start) throws IOException {
24
    Objects.requireNonNull(start, "start");
25
    // register directory and sub-directories
26
    Files.walkFileTree(start, new SimpleFileVisitor<>() {
27
        @Override
28
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
29
            register(dir);
30
            return FileVisitResult.CONTINUE;
31
        }
32
    });
33
    return this;
34
}

展开收起

注册文件变动钩子#

将路径和文件变动注册到 WatchService 之后，我们还可以注册自定义的 Hook，为了实现 StructStore 的 reload 热重载，我们再 Hook 中调用 reload，当然，也可以执行多个其他自定义方法。

1
public FileWatcherService registerHook(String fileName, Runnable hook) {
2
    return this.registerHook(Paths.get(fileName), hook);
3
}
4

5
public FileWatcherService registerHook(Path path, Runnable hook) {
6
    List<Runnable> list = this.hooksMap.computeIfAbsent(path, p -> Collections.synchronizedList(new ArrayList<>()));
7
    list.add(hook);
8
    LOGGER.info("Register file hook. path: {}", path.toAbsolutePath());
9
    return this;
10
}
11

12
public FileWatcherService deregisterHook(String fileName) {
13
    return this.deregisterHook(Paths.get(fileName));
14
}
15

16
public FileWatcherService deregisterHook(Path path) {
17
    List<Runnable> l = this.hooksMap.remove(path);
18
    if (null != l) {
19
        LOGGER.info("Deregister file hook. path: {}", path.toAbsolutePath());
20
    }
21
    return this;
22
}

展开收起

示例#

1
@Test
2
public void test() throws IOException {
3
    FileWatcherService service = FileWatcherService.newBuilder().setWatchService(mockMs)
4
            .setScheduleInitialDelay(10L)
5
            .setScheduleTimeUnit(TimeUnit.DAYS)
6
            .setScheduleDelay(999L)
7
            .setExecutor(Executors.newScheduledThreadPool(1, r -> new Thread(r, "test")))
8
            .build();
9
    service.bootstrap();
10
    service.register("./");
11

12
    service.registerHook("./", () -> {
13
    });
14
    // service.deregisterHook("./");
15
    service.run();
16
}

展开收起

核心业务代码解析#

实现热重载的第一步就是要监听文件的变动，在文件变动时，调用 reload 方法对 Struct 数据进行重加载。Struct Util 中使用 JDK 内置的 WatchService 实现对文件系统的监听。

1
/**
2
* Schedule process the file watch events.
3
*/
4
private void process() {
5
    try {
6
        WatchKey key;
7
        Path dir;
8
        if ((key = ws.poll()) == null
9
                || (dir = keys.get(key)) == null) {
10
            LOGGER.debug("watch key not registered. key:{}", key);
11
            return;
12
        }
13
        for (WatchEvent<?> event : key.pollEvents()) {
14
            WatchEvent.Kind<?> kind = event.kind();
15
            if (kind == StandardWatchEventKinds.OVERFLOW) {
16
                continue;
17
            }
18
            WatchEvent<Path> ev = (WatchEvent<Path>) event;
19
            Path name = ev.context();
20
            Path child = dir.resolve(name);
21
            List<Runnable> l = hooksMap.get(child);
22
            if (l != null) {
23
                try {
24
                    l.forEach(Runnable::run);
25
                } catch (Exception e) {
26
                    LOGGER.error("process data file failure. file:{}", child.toAbsolutePath(), e);
27
                    throw e;
28
                }
29
            }
30
        }
31
        boolean valid = key.reset();
32
        if (!valid) {
33
            this.keys.remove(key);
34
        }
35
    } catch (Throwable e) {
36
        LOGGER.error("file watcher service throw an unknown exception.", e);
37
    }
38
}

展开收起

WatchService 的 poll 方法拉取新的文件变动事件，假如没有我们注册的的 WatchKey 则退出。否则使用 WatchKey#pollEvents()获取文件变动事件。

StandardWatchEventKind 主要由四个事件组成，分别为：

OVERFLOW：事件丢失或失去
ENTRY_CREATE：目录内实体创建或本目录重命名
ENTRY_MODIFY：目录内实体修改
ENTRY_DELETE：目录内实体删除或重命名

OVERFLOW 基本上忽略不处理，主要处理 ENTRY_CREATE 和 ENTRY_MODIFY 两种文件变动事件，ENTRY_DELETE 在游戏行业处理的比较少。

总结#

本文讲解了 StructUtil 使用 WatchService 实现文件和目录路径监听，并监听文件变动事件，注册文件变动 Hook，并使用 Hook 实现文件的业务热重载功能。

Rust语言从入门到精通系列 - 从Ping-Pong示例入门Tokio模块

Sun, 30 Apr 2023 00:00:00 GMT

Tokio 是一个异步 I/O 框架，它提供了一种高效的方式来编写异步代码。它使用 Rust 语言的 Futures 库来管理异步任务，并使用 Reactor 模式来处理 I/O 事件。

本系列 Tokio 篇将由浅入深的从基础到实战，以一个完整的 Rust 语言子系列讲述网络编程。

为什么要使用 Tokio？#

在 Rust 中，使用异步编程可以提高程序的性能和响应速度，但是异步编程往往需要编写大量的样板代码和复杂的控制流程。Tokio 提供了一种简单的方式来编写异步代码，它使用 Futures 库来管理异步任务，并提供了一组工具来处理异步 I/O 事件。

如何使用 Tokio？#

使用 Tokio 编写异步代码需要掌握以下几个概念：

Future：表示一个异步任务，可以理解为一个异步函数的返回值；
Task：表示一个异步任务的执行上下文，可以理解为一个异步函数的执行环境；
Reactor：表示一个 I/O 事件的处理器，可以理解为一个事件循环；
Runtime：表示一个异步任务的执行环境，可以理解为一个异步函数的运行时环境。

下面我们将使用 Tokio 编写一个最基础的服务器和客户端程序，以便了解 Tokio 的基本用法。

编写服务器#

我们将编写一个简单的 PingPong 服务器，它接收客户端的 Ping 请求，并返回 Pong 响应。首先，我们需要创建一个异步任务来处理客户端的请求。我们可以使用 Tokio 提供的async关键字来定义一个异步函数：

1
async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
2
    // ...
3
}

这个异步函数接收一个TcpStream对象，表示一个客户端连接。我们可以在函数内部处理客户端的请求，并返回一个Result对象表示异步任务的执行结果。在处理客户端请求之前，我们需要先向客户端发送一个欢迎消息：

1
async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
2
    println!("new client connected");
3

4
    let mut buf = [0; 1024];
5
    stream.write_all(b"Welcome to the PingPong server!\n").await?;
6

7
    // ...
8
}

在发送欢迎消息之后，我们需要不断地从客户端读取数据，并返回 Pong 响应。我们可以使用一个无限循环来实现这个功能：

1
async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
2
    println!("new client connected");
3

4
    let mut buf = [0; 1024];
5
    stream.write_all(b"Welcome to the PingPong server!\n").await?;
6

7
    loop {
8
        let n = stream.read(&mut buf).await?;
9
        if n == 0 {
10
            break;
11
        }
12
        stream.write_all(b"Pong\n").await?;
13
    }
14

15
    println!("client disconnected");
16
    Ok(())
17
}

展开收起

在循环中，我们使用stream.read()方法从客户端读取数据，并使用stream.write_all()方法向客户端发送 Pong 响应。如果客户端关闭了连接，我们就退出循环并返回Ok(())表示异步任务执行成功。

现在我们已经编写了一个异步任务来处理客户端请求，接下来我们需要创建一个 Reactor 来处理 I/O 事件。我们可以使用 Tokio 提供的TcpListener对象来监听客户端连接：

1
#[tokio::main]
2
async fn main() -> Result<(), Box<dyn Error>> {
3
    let addr = "127.0.0.1:8080";
4
    let listener = TcpListener::bind(addr).await?;
5
    println!("listening on {}", addr);
6

7
    loop {
8
        let (stream, _) = listener.accept().await?;
9
        tokio::spawn(async move {
10
            if let Err(e) = handle_client(stream).await {
11
                eprintln!("error: {}", e);
12
            }
13
        });
14
    }
15
}

展开收起

在main函数中，我们首先创建一个TcpListener对象来监听客户端连接。然后我们使用一个无限循环来等待客户端连接，并使用listener.accept()方法来接收客户端连接。当有新的客户端连接时，我们就创建一个新的异步任务来处理客户端请求，并使用tokio::spawn()方法将任务提交到 Reactor 中执行。

现在我们已经完成了一个最基础的 PingPong 服务器，可以使用cargo run命令来运行程序，并使用 telnet 命令来测试服务器：

Terminal window

1
$ cargo run
2
    Finished dev [unoptimized + debuginfo] target(s) in 0.08s
3
     Running `target/debug/pingpong`
4
listening on 127.0.0.1:8080

Terminal window

1
$ telnet localhost 8080
2
Trying 127.0.0.1...
3
Connected to localhost.
4
Escape character is '^]'.
5
Welcome to the PingPong server!
6
ping
7
Pong
8
ping
9
Pong
10
^]
11
telnet> quit
12
Connection closed.

编写客户端#

现在我们已经编写了一个最基础的 PingPong 服务器，接下来我们将编写一个客户端程序来连接服务器并发送 Ping 请求。首先，我们需要创建一个异步任务来连接服务器：

1
async fn connect() -> Result<(), Box<dyn Error>> {
2
    let addr = "127.0.0.1:8080";
3
    let mut stream = TcpStream::connect(addr).await?;
4
    println!("connected to {}", addr);
5

6
    // ...
7
}

这个异步任务使用TcpStream::connect()方法来连接服务器，并返回一个Result对象表示连接结果。在连接成功之后，我们可以向服务器发送一个 Ping 请求：

1
async fn connect() -> Result<(), Box<dyn Error>> {
2
    let addr = "127.0.0.1:8080";
3
    let mut stream = TcpStream::connect(addr).await?;
4
    println!("connected to {}", addr);
5

6
    stream.write_all(b"Ping\n").await?;
7
    let mut buf = [0; 1024];
8
    let n = stream.read(&mut buf).await?;
9
    let pong = std::str::from_utf8(&buf[..n])?;
10
    println!("{}", pong);
11

12
    Ok(())
13
}

在发送 Ping 请求之后，我们使用stream.read()方法从服务器读取响应，并使用std::str::from_utf8()方法将响应转换为字符串。最后，我们将响应打印到控制台上，并返回Ok(())表示异步任务执行成功。

现在我们已经编写了一个异步任务来连接服务器并发送 Ping 请求，接下来我们需要在main函数中启动这个任务：

1
#[tokio::main]
2
async fn main() -> Result<(), Box<dyn Error>> {
3
    connect().await?;
4
    Ok(())
5
}

现在我们已经完成了一个最基础的 PingPong 客户端，可以使用cargo run命令来运行程序，并查看控制台输出：

Terminal window

1
$ cargo run
2
    Finished dev [unoptimized + debuginfo] target(s) in 0.08s
3
     Running `target/debug/pingpong`
4
connected to 127.0.0.1:8080
5
Pong

完整代码#

最后，我们将完整的服务器和客户端代码放在一起，以便读者参考：

1
use std::error::Error;
2
use tokio::io::{AsyncReadExt, AsyncWriteExt};
3
use tokio::net::{TcpListener, TcpStream};
4

5
async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
6
    println!("new client connected");
7

8
    let mut buf = [0; 1024];
9
    stream.write_all(b"Welcome to the PingPong server!\n").await?;
10

11
    loop {
12
        let n = stream.read(&mut buf).await?;
13
        if n == 0 {
14
            break;
15
        }
16
        stream.write_all(b"Pong\n").await?;
17
    }
18

19
    println!("client disconnected");
20
    Ok(())
21
}
22

23
#[tokio::main]
24
async fn main() -> Result<(), Box<dyn Error>> {
25
    let addr = "127.0.0.1:8080";
26
    let listener = TcpListener::bind(addr).await?;
27
    println!("listening on {}", addr);
28

29
    loop {
30
        let (stream, _) = listener.accept().await?;
31
        tokio::spawn(async move {
32
            if let Err(e) = handle_client(stream).await {
33
                eprintln!("error: {}", e);
34
            }
35
        });
36
    }
37
}
38

39
async fn connect() -> Result<(), Box<dyn Error>> {
40
    let addr = "127.0.0.1:8080";
41
    let mut stream = TcpStream::connect(addr).await?;
42
    println!("connected to {}", addr);
43

44
    stream.write_all(b"Ping\n").await?;
45
    let mut buf = [0; 1024];
46
    let n = stream.read(&mut buf).await?;
47
    let pong = std::str::from_utf8(&buf[..n])?;
48
    println!("{}", pong);
49

50
    Ok(())
51
}
52

53
#[tokio::main]
54
async fn main() -> Result<(), Box<dyn Error>> {
55
    connect().await?;
56
    Ok(())
57
}

展开收起

总结#

通过本文的介绍，我们了解了 Tokio 的基本用法，并编写了一个最基础的 PingPong 服务器和客户端程序。Tokio 提供了一种简单的方式来编写异步代码，可以帮助我们提高程序的性能和响应速度。在实际开发中，我们可以根据需要使用 Tokio 提供的各种工具来编写更加复杂的异步程序。

Rust语言从入门到精通系列 - 深入理解Tokio的Channel(上)

Sun, 30 Apr 2023 00:00:00 GMT

Rust 语言是一种系统级编程语言，它具有强类型和内存安全性。Rust 语言中的 Tokio 模块是一个异步编程库，它提供了一种高效的方式来处理异步任务。其中，channel 是 Tokio 模块中的一个重要组成部分，它可以用于在异步任务之间传递数据。在本教程中，我们将介绍 Rust 语言中的 Tokio 模块 channel，并提供几个示例，以帮助您更好地理解它的使用方法。

什么是 Tokio 模块 Channel？#

Tokio 模块中的 channel 是一种用于在异步任务之间传递数据的机制。它类似于操作系统中的管道，可以在不同的异步任务之间传递数据。Tokio 模块中的 channel 具有以下特点：

可以在异步任务之间传递任何类型的数据。
支持多个生产者和消费者。
支持异步操作。

Tokio 模块中的 channel 分为两种类型：mpsc 和 oneshot。其中，mpsc 是多个生产者和单个消费者的 channel，而 oneshot 是单个生产者和单个消费者的 channel。

创建一个 mpsc channel#

在 Rust 语言中，使用 Tokio 模块创建一个 mpsc channel 非常简单。首先，需要在 Cargo.toml 文件中添加 Tokio 模块的依赖：

1
[dependencies]
2
tokio = { version = "1.28.0", features = ["full"] }

然后，在代码中导入 Tokio 模块和 mpsc channel：

1
use tokio::sync::mpsc;

接下来，可以使用 mpsc::channel()函数创建一个 mpsc channel：

1
let (tx, rx) = mpsc::channel(32);

在这个例子中，我们创建了一个大小为 32 的 mpsc channel，并返回了两个对象：tx 和 rx。tx 是一个发送者对象，它可以用于向 channel 中发送数据，而 rx 是一个接收者对象，它可以用于从 channel 中接收数据。

发送和接收字符串#

下面是一个简单的示例，演示如何在异步任务之间发送和接收字符串：

1
use tokio::sync::mpsc;
2

3
#[tokio::main]
4
async fn main() {
5
    let (mut tx, mut rx) = mpsc::channel(32);
6

7
    tokio::spawn(async move {
8
        tx.send("hello".to_string()).await.unwrap();
9
        tx.send("world".to_string()).await.unwrap();
10
    });
11

12
    while let Some(msg) = rx.recv().await {
13
        println!("{}", msg);
14
    }
15
}

展开收起

在这个例子中，我们首先创建了一个大小为 32 的 mpsc channel。然后，我们使用 tokio::spawn()函数创建了一个异步任务，该任务向 channel 中发送了两个字符串。最后，我们使用 while 循环从 channel 中接收数据，并打印出来。

发送和接收数字#

下面是一个示例，演示如何在异步任务之间发送和接收数字：

1
use tokio::sync::mpsc;
2

3
#[tokio::main]
4
async fn main() {
5
    let (mut tx, mut rx) = mpsc::channel(32);
6

7
    tokio::spawn(async move {
8
        tx.send(1).await.unwrap();
9
        tx.send(2).await.unwrap();
10
        tx.send(3).await.unwrap();
11
    });
12

13
    while let Some(msg) = rx.recv().await {
14
        println!("{}", msg);
15
    }
16
}

展开收起

在这个例子中，我们创建了一个大小为 32 的 mpsc channel。然后，我们使用 tokio::spawn()函数创建了一个异步任务，该任务向 channel 中发送了三个数字。最后，我们使用 while 循环从 channel 中接收数据，并打印出来。

发送和接收结构体#

下面是一个示例，演示如何在异步任务之间发送和接收结构体：

1
use tokio::sync::mpsc;
2

3
#[derive(Debug)]
4
struct Point {
5
    x: i32,
6
    y: i32,
7
}
8

9
#[tokio::main]
10
async fn main() {
11
    let (mut tx, mut rx) = mpsc::channel(32);
12

13
    tokio::spawn(async move {
14
        tx.send(Point { x: 1, y: 2 }).await.unwrap();
15
        tx.send(Point { x: 3, y: 4 }).await.unwrap();
16
    });
17

18
    while let Some(msg) = rx.recv().await {
19
        println!("{:?}", msg);
20
    }
21
}

展开收起

在这个例子中，我们创建了一个大小为 32 的 mpsc channel。然后，我们使用 tokio::spawn()函数创建了一个异步任务，该任务向 channel 中发送了两个结构体。最后，我们使用 while 循环从 channel 中接收数据，并打印出来。

发送和接收元组#

下面是一个示例，演示如何在异步任务之间发送和接收元组：

1
use tokio::sync::mpsc;
2

3
#[tokio::main]
4
async fn main() {
5
    let (mut tx, mut rx) = mpsc::channel(32);
6

7
    tokio::spawn(async move {
8
        tx.send((1, 2)).await.unwrap();
9
        tx.send((3, 4)).await.unwrap();
10
    });
11

12
    while let Some(msg) = rx.recv().await {
13
        println!("{:?}", msg);
14
    }
15
}

展开收起

在这个例子中，我们创建了一个大小为 32 的 mpsc channel。然后，我们使用 tokio::spawn()函数创建了一个异步任务，该任务向 channel 中发送了两个元组。最后，我们使用 while 循环从 channel 中接收数据，并打印出来。

发送和接收枚举#

下面是一个示例，演示如何在异步任务之间发送和接收枚举：

1
use tokio::sync::mpsc;
2

3
enum Message {
4
    Text(String),
5
    Number(i32),
6
}
7

8
#[tokio::main]
9
async fn main() {
10
    let (mut tx, mut rx) = mpsc::channel(32);
11

12
    tokio::spawn(async move {
13
        tx.send(Message::Text("hello".to_string())).await.unwrap();
14
        tx.send(Message::Number(123)).await.unwrap();
15
    });
16

17
    while let Some(msg) = rx.recv().await {
18
        match msg {
19
            Message::Text(s) => println!("{}", s),
20
            Message::Number(n) => println!("{}", n),
21
        }
22
    }
23
}

展开收起

在这个例子中，我们创建了一个大小为 32 的 mpsc channel。然后，我们使用 tokio::spawn()函数创建了一个异步任务，该任务向 channel 中发送了两个枚举。最后，我们使用 match 语句从 channel 中接收数据，并打印出来。

多个生产者和单个消费者#

下面是一个示例，演示如何在异步任务之间使用多个生产者和单个消费者：

1
use tokio::sync::mpsc;
2

3
#[tokio::main]
4
async fn main() {
5
    let (tx1, mut rx) = mpsc::channel(32);
6
    let tx2 = tx1.clone();
7
    let tx3 = tx1.clone();
8

9
    tokio::spawn(async move {
10
        tx1.send("hello".to_string()).await.unwrap();
11
    });
12

13
    tokio::spawn(async move {
14
        tx2.send("world".to_string()).await.unwrap();
15
    });
16

17
    tokio::spawn(async move {
18
        tx3.send("!".to_string()).await.unwrap();
19
    });
20

21
    while let Some(msg) = rx.recv().await {
22
        println!("{}", msg);
23
    }
24
}

展开收起

在这个例子中，我们创建了一个大小为 32 的 mpsc channel，并使用 tx1.clone()函数创建了两个新的发送者对象：tx2 和 tx3。然后，我们使用 tokio::spawn()函数创建了三个异步任务，每个任务向 channel 中发送一个字符串。最后，我们使用 while 循环从 channel 中接收数据，并打印出来。

使用 BufferedSink 发送数据#

下面是一个示例，演示如何使用 BufferedSink 发送数据：

1
use std::io::Write;
2
use tokio::io::BufWriter;
3
use tokio::sync::mpsc;
4

5
#[tokio::main]
6
async fn main() {
7
    let (mut tx, mut rx) = mpsc::channel(32);
8

9
    tokio::spawn(async move {
10
        let mut writer = BufWriter::new(std::io::stdout());
11
        while let Some(msg) = rx.recv().await {
12
            writer.write_all(msg.as_bytes()).unwrap();
13
            writer.flush().unwrap();
14
        }
15
    });
16

17
    tx.send("hello\n".to_string()).await.unwrap();
18
    tx.send("world\n".to_string()).await.unwrap();
19
}

展开收起

在这个例子中，我们创建了一个大小为 32 的 mpsc channel。然后，我们使用 tokio::spawn()函数创建了一个异步任务，该任务使用 BufferedSink 将数据写入标准输出。最后，我们使用 tx.send()函数向 channel 中发送两个字符串。

使用 select!宏选择最先到达的消息#

下面是一个示例，演示如何使用 select!宏选择最先到达的消息：

1
use tokio::sync::mpsc;
2

3
#[tokio::main]
4
async fn main() {
5
    let (mut tx1, mut rx1) = mpsc::channel(32);
6
    let (mut tx2, mut rx2) = mpsc::channel(32);
7

8
    tokio::spawn(async move {
9
        tx1.send("hello".to_string()).await.unwrap();
10
    });
11

12
    tokio::spawn(async move {
13
        tx2.send("world".to_string()).await.unwrap();
14
    });
15

16
    loop {
17
        tokio::select! {
18
            Some(msg) = rx1.recv() => println!("{}", msg),
19
            Some(msg) = rx2.recv() => println!("{}", msg),
20
            else => break,
21
        }
22
    }
23
}

展开收起

在这个例子中，我们创建了两个大小为 32 的 mpsc channel。然后，我们使用 tokio::spawn()函数创建了两个异步任务，每个任务向 channel 中发送一个字符串。最后，我们使用 tokio::select!宏选择最先到达的消息，并打印出来。

结论#

在本教程中，我们介绍了 Rust 语言中的 Tokio 模块 channel，并提供了 8 个示例，以帮助您更好地理解它的使用方法。无论您是新手还是有经验的 Rust 开发人员，都可以从这些示例中学习到有用的知识。如果您想深入了解 Tokio 模块的其他功能，请查看 Tokio 模块的官方文档。

Rust语言从入门到精通系列 - 深入理解Tokio的Channel(中)

Sun, 30 Apr 2023 00:00:00 GMT

Rust 语言的 tokio 模块提供了一种高效的异步编程方式，其中的 channel 模块是其核心组件之一。本教程将介绍 tokio 模块 channel 的除了上文提到的 mspc::Channel 之外，还有三种类型，分别为：oneshot、broadcast 和 watch，本文分别分析它们的使用场景、业务特点和优缺点。

Channel 是一种用于在不同线程之间传递数据的通信机制。它可以让不同的线程之间通过发送和接收消息来传递数据，从而实现线程之间的协作和同步。

在 Rust 语言中，tokio 模块的 channel 组件提供了一种异步的、高效的、类型安全的 channel 实现。它支持多种类型的 channel，包括 oneshot、broadcast 和 watch。

oneshot channel#

oneshot channel 是一种只能发送一次消息的 channel。它的特点是发送端只能发送一次消息，接收端只能接收一次消息。一旦消息被发送或接收，channel 就会被关闭。

oneshot channel 适用于以下场景：

线程之间需要传递一次性的消息。
线程之间需要传递一个返回值。
线程之间需要传递一个事件通知。

oneshot channel 的业务特点如下：

只能发送一次消息，保证了消息的唯一性。
只能接收一次消息，保证了消息的完整性。
发送和接收操作都是非阻塞的，可以提高程序的并发性能。

oneshot channel 的优点包括：

简单易用，只需要发送和接收消息即可。
安全可靠，保证了消息的唯一性和完整性。
高效性能，发送和接收操作都是非阻塞的。

缺点包括：

只能发送一次消息，不适用于需要多次传递消息的场景。
无法处理多个接收端的情况。

示例代码#

下面是一个使用 oneshot channel 传递返回值的示例代码：

1
use tokio::sync::oneshot;
2

3
async fn do_something() -> i32 {
4
    // 创建一个oneshot channel
5
    let (tx, rx) = oneshot::channel();
6

7
    // 在一个异步任务中发送消息
8
    tokio::spawn(async move {
9
        let result = 42;
10
        tx.send(result).unwrap();
11
    });
12

13
    // 在当前任务中接收消息
14
    let result = rx.await.unwrap();
15
    result
16
}
17

18
#[tokio::main]
19
async fn main() {
20
    let result = do_something().await;
21
    println!("result = {}", result);
22
}

展开收起

broadcast channel#

broadcast channel 是一种可以发送多次消息的 channel。它的特点是可以有多个接收端，每个接收端都可以接收到发送端发送的所有消息。

broadcast channel 适用于以下场景：

线程之间需要传递多次消息。
线程之间需要广播消息。

broadcast channel 的业务特点如下：

可以发送多次消息，适用于需要多次传递消息的场景。
可以有多个接收端，适用于需要广播消息的场景。
发送和接收操作都是非阻塞的，可以提高程序的并发性能。

broadcast channel 的优点包括：

可以发送多次消息，适用于需要多次传递消息的场景。
可以有多个接收端，适用于需要广播消息的场景。
高效性能，发送和接收操作都是非阻塞的。

缺点包括：

无法保证消息的顺序性。
需要额外的处理逻辑来处理多个接收端的情况。

示例代码#

下面是一个使用 broadcast channel 广播消息的示例代码：

1
use tokio::sync::broadcast;
2

3
async fn do_something() {
4
    // 创建一个broadcast channel
5
    let (tx, mut rx) = broadcast::channel(10);
6

7
    // 在一个异步任务中发送消息
8
    tokio::spawn(async move {
9
        for i in 0..10 {
10
            tx.send(i).unwrap();
11
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
12
        }
13
    });
14

15
    // 在多个异步任务中接收消息
16
    for _ in 0..3 {
17
        let mut rx = rx.clone();
18
        tokio::spawn(async move {
19
            loop {
20
                match rx.recv().await {
21
                    Ok(msg) => println!("recv msg = {}", msg),
22
                    Err(_) => break,
23
                }
24
            }
25
        });
26
    }
27
}
28

29
#[tokio::main]
30
async fn main() {
31
    do_something().await;
32
}

展开收起

watch channel#

watch channel 是一种可以发送多次消息的 channel。它的特点是可以有多个接收端，每个接收端都可以接收到发送端发送的最新消息。

watch channel 适用于以下场景：

线程之间需要传递多次消息。
线程之间需要订阅最新消息。

watch channel 的业务特点如下：

可以发送多次消息，适用于需要多次传递消息的场景。
可以有多个接收端，适用于需要订阅最新消息的场景。
发送和接收操作都是非阻塞的，可以提高程序的并发性能。

watch channel 的优点包括：

可以发送多次消息，适用于需要多次传递消息的场景。
可以有多个接收端，适用于需要订阅最新消息的场景。
高效性能，发送和接收操作都是非阻塞的。

缺点包括：

无法保证消息的顺序性。
需要额外的处理逻辑来处理多个接收端的情况。

示例代码#

下面是一个使用 watch channel 订阅最新消息的示例代码：

1
use tokio::sync::watch;
2

3
async fn do_something() {
4
    // 创建一个watch channel
5
    let (tx, mut rx) = watch::channel(0);
6

7
    // 在一个异步任务中发送消息
8
    tokio::spawn(async move {
9
        for i in 0..10 {
10
            tx.send(i).unwrap();
11
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
12
        }
13
    });
14

15
    // 在多个异步任务中接收消息
16
    for _ in 0..3 {
17
        let mut rx = rx.clone();
18
        tokio::spawn(async move {
19
            loop {
20
                let msg = rx.recv().await.unwrap();
21
                println!("recv msg = {}", msg);
22
            }
23
        });
24
    }
25
}
26

27
#[tokio::main]
28
async fn main() {
29
    do_something().await;
30
}

展开收起

总结#

tokio 模块的 channel 组件是一种高效的异步通信机制，可以用于线程之间的协作和同步。其中的 oneshot、broadcast 和 watch 三种类型的 channel 各有特点，适用于不同的场景。在实际开发中，需要根据业务需求选择合适的类型，并进行合理的使用和处理。

Rust语言从入门到精通系列 - 深入理解Tokio的Channel(下)

Sun, 30 Apr 2023 00:00:00 GMT

Channel 是一种在多线程环境下进行通信的机制，可以让线程之间互相发送消息和共享数据。Rust 语言中的 Tokio 模块提供了一种异步的 Channel 实现，使得我们可以在异步程序中方便地进行消息传递和数据共享。

在本教程是 Channel 的下篇，我们将介绍如何使用 Tokio 模块的 Channel，包括如何使用异步 Channel 和如何使用标准库中的同步 Channel 来扩展 Tokio 的 Channel。我们还将讨论背压和有界队列的概念，并提供相关的实践和示例代码。

异步 Channel#

异步 Channel 是 Tokio 模块中的一种实现，它使用了 async/await 语法和 futures-rs 库来实现异步通信。在使用异步 Channel 之前，我们需要在项目的 Cargo.toml 文件中添加 tokio 和 futures-rs 的依赖：

1
[dependencies]
2
tokio = { version = "1.28.0", features = ["full"] }
3
futures = "0.3.17"

接下来，我们可以使用 tokio::sync::mpsc 模块中的 unbounded_channel 函数来创建一个异步 Channel：

1
use tokio::sync::mpsc;
2

3
#[tokio::main]
4
async fn main() {
5
    let (mut tx, mut rx) = mpsc::unbounded_channel();
6
    // ...
7
}

在上面的代码中，我们使用了 tokio::main 宏来启动异步运行时，并使用 mpsc::unbounded_channel 函数创建了一个异步 Channel。该函数返回了两个值，一个是发送端（tx），一个是接收端（rx）。

接下来，我们可以使用 tx.send 方法向 Channel 中发送消息，使用 rx.recv 方法从 Channel 中接收消息。这些方法都是异步的，因此我们需要在使用它们时使用 await 关键字。

1
use tokio::sync::mpsc;
2

3
#[tokio::main]
4
async fn main() {
5
    let (mut tx, mut rx) = mpsc::unbounded_channel();
6
    tokio::spawn(async move {
7
        tx.send("hello").await.unwrap();
8
    });
9
    let msg = rx.recv().await.unwrap();
10
    println!("{}", msg);
11
}

在上面的代码中，我们使用了 tokio::spawn 函数创建了一个异步任务，该任务向 Channel 中发送了一条消息。接着，我们使用 rx.recv 方法从 Channel 中接收消息，并将消息打印出来。

扩展异步 Channel#

异步 Channel 在 Tokio 中是一个非常有用的工具，但是它有一些限制。例如，它只支持无界队列，这意味着当发送者发送消息时，如果接收者没有及时接收消息，那么消息将一直积累在队列中，直到内存耗尽。

为了解决这个问题，我们可以使用 async-channel 模块来扩展 Tokio 的异步 Channel。async-channel 是一个基于 futures-rs 的异步通信库，它提供了有界队列和背压功能。

在使用 async-channel 之前，我们需要在项目的 Cargo.toml 文件中添加 async-channel 的依赖：

1
[dependencies]
2
tokio = { version = "1.28.0", features = ["full"] }
3
futures = "0.3.17"
4
async-channel = "1.7.3"

接下来，我们可以使用 async_channel::bounded 函数来创建一个有界队列的异步 Channel：

1
use async_channel::{bounded, Sender, Receiver};
2

3
#[tokio::main]
4
async fn main() {
5
    let (tx, rx) = bounded(10);
6
    // ...
7
}

在上面的代码中，我们使用了 async_channel::bounded 函数创建了一个有界队列的异步 Channel。该函数返回了两个值，一个是发送端（tx），一个是接收端（rx）。在这个例子中，我们创建了一个容量为 10 的有界队列。

1
use async_channel::{bounded, Sender, Receiver};
2

3
#[tokio::main]
4
async fn main() {
5
    let (tx, rx) = bounded(10);
6
    tokio::spawn(async move {
7
        tx.send("hello").await.unwrap();
8
    });
9
    let msg = rx.recv().await.unwrap();
10
    println!("{}", msg);
11
}

同步 Channel#

除了异步 Channel 之外，我们还可以使用标准库中的同步 Channel 来扩展 Tokio 的 Channel。标准库中的同步 Channel 使用了 std::sync::mpsc 模块来实现多线程之间的通信。

在使用同步 Channel 之前，我们需要在项目的 Cargo.toml 文件中添加 tokio 的依赖：

1
[dependencies]
2
tokio = { version = "1.14.0", features = ["full"] }

接下来，我们可以使用 std::sync::mpsc 模块中的 channel 函数来创建一个同步 Channel：

1
use std::sync::mpsc;
2

3
fn main() {
4
    let (tx, rx) = mpsc::channel();
5
    // ...
6
}

在上面的代码中，我们使用了 mpsc::channel 函数创建了一个同步 Channel。该函数返回了两个值，一个是发送端（tx），一个是接收端（rx）。

接下来，我们可以使用 tx.send 方法向 Channel 中发送消息，使用 rx.recv 方法从 Channel 中接收消息。这些方法都是阻塞的，因此我们不需要使用 await 关键字。

1
use std::sync::mpsc;
2

3
fn main() {
4
    let (tx, rx) = mpsc::channel();
5
    std::thread::spawn(move || {
6
        tx.send("hello").unwrap();
7
    });
8
    let msg = rx.recv().unwrap();
9
    println!("{}", msg);
10
}

在上面的代码中，我们使用了 std::thread::spawn 函数创建了一个线程，该线程向 Channel 中发送了一条消息。接着，我们使用 rx.recv 方法从 Channel 中接收消息，并将消息打印出来。

扩展同步 Channel#

同步 Channel 在标准库中是一个非常有用的工具，但是它也有一些限制。例如，它只支持阻塞式的消息传递，这意味着当发送者发送消息时，如果接收者没有及时接收消息，那么发送者将一直阻塞，直到消息被接收。

为了解决这个问题，我们可以使用有界队列和背压来扩展同步 Channel。有界队列和背压可以使用 crossbeam-channel 模块来实现。

在使用 crossbeam-channel 之前，我们需要在项目的 Cargo.toml 文件中添加 crossbeam-channel 的依赖：

1
[dependencies]
2
crossbeam-channel = "0.5.1"

接下来，我们可以使用 crossbeam_channel::bounded 函数来创建一个有界队列的同步 Channel：

1
use crossbeam_channel::{bounded, Sender, Receiver};
2

3
fn main() {
4
    let (tx, rx) = bounded(10);
5
    // ...
6
}

在上面的代码中，我们使用了 crossbeam_channel::bounded 函数创建了一个有界队列的同步 Channel。该函数返回了两个值，一个是发送端（tx），一个是接收端（rx）。在这个例子中，我们创建了一个容量为 10 的有界队列。

1
use crossbeam_channel::{bounded, Sender, Receiver};
2

3
fn main() {
4
    let (tx, rx) = bounded(10);
5
    std::thread::spawn(move || {
6
        tx.send("hello").unwrap();
7
    });
8
    let msg = rx.recv().unwrap();
9
    println!("{}", msg);
10
}

背压和有界队列#

在异步编程中，背压和有界队列是非常重要的概念。背压是一种流量控制机制，用于控制消息发送的速度，以避免消息积压和内存耗尽。有界队列是一种限制队列长度的机制，用于控制消息的数量，以避免队列溢出和内存耗尽。

在 Tokio 中，我们可以使用 async-channel 模块和 crossbeam-channel 模块来实现背压和有界队列。

使用 async-channel 实现背压和有界队列#

在 async-channel 中，我们可以使用 Sender::try_send 方法来实现背压和有界队列。try_send 方法尝试向 Channel 中发送一条消息，如果 Channel 已满，则返回错误。这样，我们就可以在发送消息时进行流量控制和队列长度控制。

1
use async_channel::{bounded, Sender, Receiver};
2

3
#[tokio::main]
4
async fn main() {
5
    let (tx, rx) = bounded(10);
6
    tokio::spawn(async move {
7
        loop {
8
            if let Err(_) = tx.try_send("hello") {
9
                // Channel is full, wait for a moment
10
                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
11
            }
12
        }
13
    });
14
    loop {
15
        let msg = rx.recv().await.unwrap();
16
        // Process the message
17
    }
18
}

展开收起

在上面的代码中，我们使用了 tx.try_send 方法向 Channel 中发送消息，如果 Channel 已满，则等待 1 秒钟。接下来，我们使用 rx.recv 方法从 Channel 中接收消息，并进行处理。

使用 crossbeam-channel 实现背压和有界队列#

在 crossbeam-channel 中，我们可以使用 Sender::try_send 方法和 Receiver::recv_timeout 方法来实现背压和有界队列。try_send 方法尝试向 Channel 中发送一条消息，如果 Channel 已满，则返回错误。recv_timeout 方法尝试从 Channel 中接收一条消息，如果 Channel 为空，则等待一段时间后返回错误。这样，我们就可以在发送消息时进行流量控制和队列长度控制。

1
use crossbeam_channel::{bounded, Sender, Receiver};
2

3
fn main() {
4
    let (tx, rx) = bounded(10);
5
    std::thread::spawn(move || {
6
        loop {
7
            if let Err(_) = tx.try_send("hello") {
8
                // Channel is full, wait for a moment
9
                std::thread::sleep(std::time::Duration::from_secs(1));
10
            }
11
        }
12
    });
13
    loop {
14
        match rx.recv_timeout(std::time::Duration::from_secs(1)) {
15
            Ok(msg) => {
16
                // Process the message
17
            }
18
            Err(_) => {
19
                // Channel is empty, wait for a moment
20
            }
21
        }
22
    }
23
}

展开收起

在上面的代码中，我们使用了 tx.try_send 方法向 Channel 中发送消息，如果 Channel 已满，则等待 1 秒钟。接下来，我们使用 rx.recv_timeout 方法从 Channel 中接收消息，并进行处理。如果 Channel 为空，则等待 1 秒钟后继续尝试接收消息。

总结#

在本教程中，我们介绍了如何使用 Tokio 模块的 Channel，包括如何使用异步 Channel 和如何使用标准库中的同步 Channel 来扩展 Tokio 的 Channel。我们还讨论了背压和有界队列的概念，并提供了相关的实践和示例代码。

异步 Channel 是 Tokio 中非常有用的工具，它可以帮助我们在异步程序中方便地进行消息传递和数据共享。然而，由于它只支持无界队列，因此在某些情况下可能会导致内存耗尽。为了解决这个问题，我们可以使用 async-channel 模块来扩展 Tokio 的异步 Channel，实现有界队列和背压功能。

同步 Channel 在标准库中是一个非常有用的工具，它可以帮助我们在多线程程序中方便地进行消息传递和数据共享。然而，由于它只支持阻塞式的消息传递，因此在某些情况下可能会导致发送者一直阻塞，直到消息被接收。为了解决这个问题，我们可以使用 crossbeam-channel 模块来扩展同步 Channel，实现有界队列和背压功能。

Rust语言从入门到精通系列 - 深入理解Tokio的AsyncRead和AsyncWrite

Sun, 30 Apr 2023 00:00:00 GMT

Rust 语言是一门高性能、安全、并发的编程语言，越来越受到开发者的关注和喜爱。而 Tokio 是 Rust 语言中一个非常流行的异步运行时，它提供了一系列的异步 I/O 操作，其中包括 AsyncRead 和 AsyncWrite 模块。这两个模块是非常重要的，它们可以让我们在异步编程中更加方便地读写数据。本教程将围绕这两个模块，提供基础和进阶用法的示例，帮助读者更好地理解和使用它们。

基础用法#

从文件中读取数据#

1
use tokio::fs::File;
2
use tokio::io::{self, AsyncReadExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut file = File::open("test.txt").await?;
7
    let mut buffer = [0; 10];
8
    let n = file.read(&mut buffer).await?;
9
    println!("The bytes read: {:?}", &buffer[..n]);
10
    Ok(())
11
}

这个示例演示了如何使用 AsyncRead 模块从文件中读取数据。首先，我们使用File::open函数打开文件，然后使用read方法从文件中读取数据。在这个示例中，我们读取了 10 个字节的数据，并将其存储在一个长度为 10 的缓冲区中。最后，我们打印出读取的字节。

从 TCP 连接中读取数据#

1
use tokio::net::TcpStream;
2
use tokio::io::{self, AsyncReadExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
7
    let mut buffer = [0; 10];
8
    let n = stream.read(&mut buffer).await?;
9
    println!("The bytes read: {:?}", &buffer[..n]);
10
    Ok(())
11
}

这个示例演示了如何使用 AsyncRead 模块从 TCP 连接中读取数据。首先，我们使用TcpStream::connect函数连接到一个 TCP 服务器，然后使用read方法从连接中读取数据。在这个示例中，我们读取了 10 个字节的数据，并将其存储在一个长度为 10 的缓冲区中。最后，我们打印出读取的字节。

向文件中写入数据#

1
use tokio::fs::File;
2
use tokio::io::{self, AsyncWriteExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut file = File::create("test.txt").await?;
7
    let buffer = b"Hello, world!";
8
    file.write_all(buffer).await?;
9
    Ok(())
10
}

这个示例演示了如何使用 AsyncWrite 模块向文件中写入数据。首先，我们使用File::create函数创建一个新的文件，然后使用write_all方法将数据写入文件中。在这个示例中，我们向文件中写入了一个字符串”Hello, world!”。

向 TCP 连接中写入数据#

1
use tokio::net::TcpStream;
2
use tokio::io::{self, AsyncWriteExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
7
    let buffer = b"Hello, world!";
8
    stream.write_all(buffer).await?;
9
    Ok(())
10
}

这个示例演示了如何使用 AsyncWrite 模块向 TCP 连接中写入数据。首先，我们使用TcpStream::connect函数连接到一个 TCP 服务器，然后使用write_all方法将数据写入连接中。在这个示例中，我们向连接中写入了一个字符串”Hello, world!”。

读取文件中的全部数据#

1
use tokio::fs::File;
2
use tokio::io::{self, AsyncReadExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut file = File::open("test.txt").await?;
7
    let mut buffer = Vec::new();
8
    file.read_to_end(&mut buffer).await?;
9
    println!("The bytes read: {:?}", buffer);
10
    Ok(())
11
}

这个示例演示了如何使用 AsyncRead 模块读取文件中的全部数据。首先，我们使用File::open函数打开文件，然后使用read_to_end方法读取文件中的全部数据。在这个示例中，我们将读取到的数据存储在一个动态数组中，并打印出读取的字节。

复制文件#

1
use tokio::fs::{self, File};
2
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut source_file = File::open("source.txt").await?;
7
    let mut dest_file = File::create("dest.txt").await?;
8
    let mut buffer = [0; 1024];
9
    loop {
10
        let n = source_file.read(&mut buffer).await?;
11
        if n == 0 {
12
            break;
13
        }
14
        dest_file.write_all(&buffer[..n]).await?;
15
    }
16
    Ok(())
17
}

展开收起

这个示例演示了如何使用 AsyncRead 和 AsyncWrite 模块复制文件。首先，我们使用File::open函数打开源文件，使用File::create函数创建目标文件。然后，我们使用一个循环，每次读取 1024 字节的数据，并将其写入目标文件中，直到源文件读取完毕。在这个示例中，我们使用了read和write_all方法。

使用 BufReader 和 BufWriter#

1
use tokio::fs::File;
2
use tokio::io::{self, AsyncBufReadExt, AsyncWriteExt, BufReader, BufWriter};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut file = File::open("test.txt").await?;
7
    let mut reader = BufReader::new(file);
8
    let mut writer = BufWriter::new(io::stdout());
9
    let mut line = String::new();
10
    loop {
11
        let n = reader.read_line(&mut line).await?;
12
        if n == 0 {
13
            break;
14
        }
15
        writer.write_all(line.as_bytes()).await?;
16
        line.clear();
17
    }
18
    Ok(())
19
}

展开收起

这个示例演示了如何使用 BufReader 和 BufWriter 来进行异步读写。首先，我们使用File::open函数打开文件，然后使用BufReader::new函数将文件包装成一个缓冲读取器，使用BufWriter::new函数将标准输出包装成一个缓冲写入器。然后，我们使用一个循环，每次读取一行数据，并将其写入标准输出中。在这个示例中，我们使用了read_line和write_all方法。

使用 split 和 join#

1
use tokio::fs::File;
2
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut file = File::open("test.txt").await?;
7
    let mut buffer = Vec::new();
8
    file.read_to_end(&mut buffer).await?;
9
    let mut parts = buffer.split(|&b| b == b'\n');
10
    let mut tasks = Vec::new();
11
    while let Some(part) = parts.next() {
12
        let task = tokio::spawn(async move {
13
            let mut file = File::create("output.txt").await?;
14
            file.write_all(part).await?;
15
            Ok(())
16
        });
17
        tasks.push(task);
18
    }
19
    for task in tasks {
20
        task.await?;
21
    }
22
    Ok(())
23
}

展开收起

这个示例演示了如何使用 split 和 join 来进行异步读写。首先，我们使用File::open函数打开文件，然后使用read_to_end方法读取文件中的全部数据，并将其存储在一个动态数组中。然后，我们使用split方法将数据按照换行符分割成多个部分。接着，我们使用一个循环，每次将一个部分异步地写入一个新的文件中，并使用tokio::spawn函数创建一个异步任务。最后，我们使用join函数等待所有的异步任务完成。在这个示例中，我们使用了write_all方法。

使用 timeout#

1
use tokio::net::TcpStream;
2
use tokio::io::{self, AsyncReadExt};
3

4
#[tokio::main]
5
async fn main() -> io::Result<()> {
6
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
7
    let mut buffer = [0; 10];
8
    let n = tokio::time::timeout(std::time::Duration::from_secs(5), stream.read(&mut buffer)).await??;
9
    println!("The bytes read: {:?}", &buffer[..n]);
10
    Ok(())
11
}

这个示例演示了如何使用 timeout 来设置异步读取的超时时间。首先，我们使用TcpStream::connect函数连接到一个 TCP 服务器，然后使用read方法从连接中读取数据。在这个示例中，我们使用了timeout函数来设置读取的超时时间为 5 秒。如果在 5 秒内没有读取到数据，将返回一个错误。在这个示例中，我们使用了time::timeout函数。

总结#

本教程围绕 Tokio 模块的 AsyncRead 和 AsyncWrite 模块，提供了基础和进阶用法的示例。通过学习这些示例，读者可以更好地理解和使用这两个模块，从而更加方便地进行异步读写操作。当然，这些示例只是冰山一角，读者可以通过进一步的学习和实践，掌握更多的异步编程技巧。

Rust语言从入门到精通系列 - 深入理解Tokio的select!宏(上)

Sun, 30 Apr 2023 00:00:00 GMT

Tokio 是一个基于 Rust 语言的异步编程框架，它提供了一组工具和库，使得异步编程变得更加容易和高效。其中最重要的组件之一就是 select!宏。

select!宏是 Tokio 中的一个核心宏，它可以让我们同时监听多个异步事件，一旦其中一个事件触发，就可以立即执行相应的代码。在本教程中，我们将详细介绍 select!宏的基础用法和进阶用法，并提供多个示例来帮助您更好地理解和掌握这个宏的使用方法。

基础用法#

在介绍 select!宏的基础用法之前，我们需要先了解一下 Tokio 中的 Future 和 Task。

Future#

Future 是 Tokio 中的一个重要概念，它代表了一个异步操作的未来结果。在 Rust 中，Future 是一个 trait，它定义了异步操作的执行过程和返回值。我们可以通过实现 Future trait 来定义自己的异步操作。

例如，下面的代码定义了一个简单的 Future，它返回一个字符串：

1
use std::future::Future;
2
use std::pin::Pin;
3
use std::task::{Context, Poll};
4

5
struct MyFuture;
6

7
impl Future for MyFuture {
8
    type Output = String;
9

10
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
11
        Poll::Ready(String::from("Hello, world!"))
12
    }
13
}

在这个例子中，我们实现了 Future trait，并在 poll 函数中返回了一个包含字符串“Hello, world!”的 Ready 枚举值。这个 Future 的类型是 MyFuture，它的 Output 类型是 String。

Task#

Task 是 Tokio 中的另一个重要概念，它代表了一个异步操作的执行上下文。每个 Task 都有一个关联的 Future，它负责执行 Future 中定义的异步操作，并在操作完成时返回结果。

在 Tokio 中，每个 Task 都由一个 Executor 来管理。Executor 是一个可以执行异步操作的线程池，它负责调度和执行所有的异步操作。当我们创建一个 Task 时，它会被分配到 Executor 中的一个线程上，并在该线程上执行异步操作。

现在我们已经了解了 Future 和 Task 的基本概念，下面让我们来介绍 select!宏的基础用法。

基本语法#

select!宏的基本语法如下：

1
select! {
2
    pattern1 => {
3
        // 处理pattern1的代码
4
    }
5
    pattern2 => {
6
        // 处理pattern2的代码
7
    }
8
    // ...
9
}

其中，pattern1、pattern2 等是一组用于匹配异步事件的模式。每个模式都可以与一个关联的 Future 相关联，如果该 Future 的状态与模式匹配，则执行相应的代码块。

下面是一个简单的示例，它演示了如何使用 select!宏同时监听两个 Future 的状态：

1
use tokio::time::{sleep, Duration};
2

3
async fn future1() -> String {
4
    sleep(Duration::from_secs(1)).await;
5
    String::from("future1")
6
}
7

8
async fn future2() -> String {
9
    sleep(Duration::from_secs(2)).await;
10
    String::from("future2")
11
}
12

13
#[tokio::main]
14
async fn main() {
15
    select! {
16
        result1 = future1().fuse() => {
17
            println!("future1 completed with result: {}", result1);
18
        }
19
        result2 = future2().fuse() => {
20
            println!("future2 completed with result: {}", result2);
21
        }
22
    }
23
}

展开收起

在这个示例中，我们定义了两个 Future：future1 和 future2。future1 会在 1 秒后返回一个字符串“future1”，而 future2 会在 2 秒后返回一个字符串“future2”。在 main 函数中，我们使用 select!宏同时监听这两个 Future 的状态，并在其中一个 Future 完成时打印出其返回值。

同时监听多个 Future#

select!宏最常用的场景之一就是同时监听多个 Future 的状态。下面是一个示例，它演示了如何使用 select!宏同时监听三个 Future 的状态：

1
use tokio::time::{sleep, Duration};
2

3
async fn future1() -> String {
4
    sleep(Duration::from_secs(1)).await;
5
    String::from("future1")
6
}
7

8
async fn future2() -> String {
9
    sleep(Duration::from_secs(2)).await;
10
    String::from("future2")
11
}
12

13
async fn future3() -> String {
14
    sleep(Duration::from_secs(3)).await;
15
    String::from("future3")
16
}
17

18
#[tokio::main]
19
async fn main() {
20
    select! {
21
        result1 = future1().fuse() => {
22
            println!("future1 completed with result: {}", result1);
23
        }
24
        result2 = future2().fuse() => {
25
            println!("future2 completed with result: {}", result2);
26
        }
27
        result3 = future3().fuse() => {
28
            println!("future3 completed with result: {}", result3);
29
        }
30
    }
31
}

展开收起

在这个示例中，我们定义了三个 Future：future1、future2 和 future3。它们分别在 1 秒、2 秒和 3 秒后返回一个字符串。在 main 函数中，我们使用 select!宏同时监听这三个 Future 的状态，并在其中一个 Future 完成时打印出其返回值。

同时监听 Future 和 Channel#

除了监听多个 Future 的状态，select!宏还可以同时监听 Future 和 Channel 的状态。下面是一个示例，它演示了如何使用 select!宏同时监听一个 Future 和一个 Channel 的状态：

1
use tokio::sync::mpsc;
2
use tokio::time::{sleep, Duration};
3

4
async fn future1() -> String {
5
    sleep(Duration::from_secs(1)).await;
6
    String::from("future1")
7
}
8

9
#[tokio::main]
10
async fn main() {
11
    let (tx, mut rx) = mpsc::channel(10);
12

13
    tokio::spawn(async move {
14
        for i in 1..=5 {
15
            tx.send(i).await.unwrap();
16
            sleep(Duration::from_secs(1)).await;
17
        }
18
    });
19

20
    select! {
21
        result1 = future1().fuse() => {
22
            println!("future1 completed with result: {}", result1);
23
        }
24
        msg = rx.recv() => {
25
            println!("received message: {:?}", msg);
26
        }
27
    }
28
}

展开收起

在这个示例中，我们定义了一个 Future：future1，它会在 1 秒后返回一个字符串。我们还创建了一个 Channel，它可以用于在异步任务之间传递消息。在 main 函数中，我们使用 select!宏同时监听 future1 和 Channel 的状态，并在其中一个事件触发时打印出相应的信息。

同时监听多个 Channel#

select!宏还可以同时监听多个 Channel 的状态。下面是一个示例，它演示了如何使用 select!宏同时监听两个 Channel 的状态：

1
use tokio::sync::mpsc;
2
use tokio::time::{sleep, Duration};
3

4
#[tokio::main]
5
async fn main() {
6
    let (tx1, mut rx1) = mpsc::channel(10);
7
    let (tx2, mut rx2) = mpsc::channel(10);
8

9
    tokio::spawn(async move {
10
        for i in 1..=5 {
11
            tx1.send(i).await.unwrap();
12
            sleep(Duration::from_secs(1)).await;
13
        }
14
    });
15

16
    tokio::spawn(async move {
17
        for i in 1..=5 {
18
            tx2.send(i * 2).await.unwrap();
19
            sleep(Duration::from_secs(2)).await;
20
        }
21
    });
22

23
    select! {
24
        msg1 = rx1.recv() => {
25
            println!("received message from channel 1: {:?}", msg1);
26
        }
27
        msg2 = rx2.recv() => {
28
            println!("received message from channel 2: {:?}", msg2);
29
        }
30
    }
31
}

展开收起

在这个示例中，我们创建了两个 Channel：rx1 和 rx2。它们分别在 1 秒和 2 秒后发送一系列整数。在 main 函数中，我们使用 select!宏同时监听这两个 Channel 的状态，并在其中一个 Channel 有消息到达时打印出相应的信息。

同时监听多个 Future 和 Channel#

select!宏还可以同时监听多个 Future 和 Channel 的状态。下面是一个示例，它演示了如何使用 select!宏同时监听两个 Future 和两个 Channel 的状态：

1
use tokio::sync::mpsc;
2
use tokio::time::{sleep, Duration};
3

4
async fn future1() -> String {
5
    sleep(Duration::from_secs(1)).await;
6
    String::from("future1")
7
}
8

9
async fn future2() -> String {
10
    sleep(Duration::from_secs(2)).await;
11
    String::from("future2")
12
}
13

14
#[tokio::main]
15
async fn main() {
16
    let (tx1, mut rx1) = mpsc::channel(10);
17
    let (tx2, mut rx2) = mpsc::channel(10);
18

19
    tokio::spawn(async move {
20
        for i in 1..=5 {
21
            tx1.send(i).await.unwrap();
22
            sleep(Duration::from_secs(1)).await;
23
        }
24
    });
25

26
    tokio::spawn(async move {
27
        for i in 1..=5 {
28
            tx2.send(i * 2).await.unwrap();
29
            sleep(Duration::from_secs(2)).await;
30
        }
31
    });
32

33
    select! {
34
        result1 = future1().fuse() => {
35
            println!("future1 completed with result: {}", result1);
36
        }
37
        result2 = future2().fuse() => {
38
            println!("future2 completed with result: {}", result2);
39
        }
40
        msg1 = rx1.recv() => {
41
            println!("received message from channel 1: {:?}", msg1);
42
        }
43
        msg2 = rx2.recv() => {
44
            println!("received message from channel 2: {:?}", msg2);
45
        }
46
    }
47
}

展开收起

在这个示例中，我们创建了两个 Future：future1 和 future2，以及两个 Channel：rx1 和 rx2。它们分别在不同的时间发送一系列整数和字符串。在 main 函数中，我们使用 select!宏同时监听这四个事件的状态，并在其中一个事件触发时打印出相应的信息。

使用 timeout#

select!宏还支持使用 timeout 来限制异步操作的执行时间。下面是一个示例，它演示了如何使用 select!宏和 timeout 来限制异步操作的执行时间：

1
use tokio::time::{sleep, Duration};
2

3
async fn future1() -> String {
4
    sleep(Duration::from_secs(1)).await;
5
    String::from("future1")
6
}
7

8
#[tokio::main]
9
async fn main() {
10
    select! {
11
        result1 = future1().fuse() => {
12
            println!("future1 completed with result: {}", result1);
13
        }
14
        _ = sleep(Duration::from_secs(2)).fuse() => {
15
            println!("timeout");
16
        }
17
    }
18
}

展开收起

在这个示例中，我们定义了一个 Future：future1，它会在 1 秒后返回一个字符串。在 main 函数中，我们使用 select!宏同时监听 future1 和一个 2 秒的 timeout。如果 future1 在 2 秒内完成，就会打印出其返回值；否则，会打印出“timeout”。

使用 select!宏的默认分支#

最后一个基础用法示例演示了如何使用 select!宏的默认分支。默认分支可以用于处理所有未匹配的事件，这样我们就可以在一个 select!宏中同时监听多个异步事件，而不需要为每个事件都提供一个匹配模式。

1
use tokio::time::{sleep, Duration};
2

3
async fn future1() -> String {
4
    sleep(Duration::from_secs(1)).await;
5
    String::from("future1")
6
}
7

8
async fn future2() -> String {
9
    sleep(Duration::from_secs(2)).await;
10
    String::from("future2")
11
}
12

13
#[tokio::main]
14
async fn main() {
15
    select! {
16
        result1 = future1().fuse() => {
17
            println!("future1 completed with result: {}", result1);
18
        }
19
        result2 = future2().fuse() => {
20
            println!("future2 completed with result: {}", result2);
21
        }
22
        _ = tokio::time::sleep(Duration::from_secs(3)).fuse() => {
23
            println!("timeout");
24
        }
25
        _ = std::future::pending().fuse() => {
26
            println!("pending");
27
        }
28
        _ = tokio::signal::ctrl_c().fuse() => {
29
            println!("ctrl-c");
30
        }
31
        _ = tokio::io::stdin().read_line(&mut String::new()).fuse() => {
32
            println!("stdin");
33
        }
34
        _ = tokio::net::TcpListener::bind("127.0.0.1:8080").unwrap().accept().fuse() => {
35
            println!("tcp listener");
36
        }
37
        _ = tokio::fs::File::open("test.txt").await.fuse() => {
38
            println!("file open");
39
        }
40
        _ = tokio::process::Command::new("ls").spawn().unwrap().fuse() => {
41
            println!("command");
42
        }
43
        _ => {
44
            println!("default");
45
        }
46
    }
47
}

展开收起

在这个示例中，我们使用 select!宏同时监听多个异步事件，包括两个 Future、一个 timeout、一个 pending、一个 ctrl-c 信号、一个 stdin 读取、一个 TCP 监听、一个文件打开和一个命令执行。在这些事件中，我们只为前面两个 Future 提供了匹配模式，而其他事件都使用了默认分支来处理。

结语#

在本篇教程中，我们介绍了 Rust 语言中的 Tokio 模块 select!宏的基础用法，并提供了一些示例代码。通过学习这些内容，我们可以更好地掌握这个宏的使用，从而编写出更加高效和高质量的异步代码。

Rust语言从入门到精通系列 - 深入理解Tokio的select!宏(下)

Sun, 30 Apr 2023 00:00:00 GMT

Tokio 是一个基于 Rust 语言的异步编程框架，它提供了一组工具和库，使得异步编程变得更加容易和高效。其中最重要的组件之一就是 select!宏。

select!宏是 Tokio 中的一个核心宏，它可以让我们同时监听多个异步事件，一旦其中一个事件触发，就可以立即执行相应的代码。在本教程中，我们将详细介绍 select!宏的进阶用法，并提供多个示例来帮助您更好地理解和掌握这个宏的使用方法。

进阶用法#

除了基础用法之外，select!宏还有一些进阶用法，可以帮助我们更好地利用这个宏的强大功能。下面让我们来介绍一些进阶用法，并提供相应的示例。

使用 select!宏的循环#

select!宏可以嵌套在循环语句中，以便我们可以持续监听异步事件的状态。下面是一个示例，它演示了如何使用 select!宏在循环中持续监听两个 Future 的状态：

1
use tokio::time::{sleep, Duration};
2

3
async fn future1() -> String {
4
    sleep(Duration::from_secs(1)).await;
5
    String::from("future1")
6
}
7

8
async fn future2() -> String {
9
    sleep(Duration::from_secs(2)).await;
10
    String::from("future2")
11
}
12

13
#[tokio::main]
14
async fn main() {
15
    loop {
16
        select! {
17
            result1 = future1().fuse() => {
18
                println!("future1 completed with result: {}", result1);
19
            }
20
            result2 = future2().fuse() => {
21
                println!("future2 completed with result: {}", result2);
22
            }
23
        }
24
    }
25
}

展开收起

在这个示例中，我们使用 select!宏在一个无限循环中持续监听 future1 和 future2 的状态。这样，无论何时其中一个 Future 完成，我们都可以立即处理其结果。

使用 select!宏的复合模式#

select!宏还支持使用复合模式来匹配多个事件。复合模式由多个简单模式组成，它们之间使用|运算符连接。下面是一个示例，它演示了如何使用复合模式来监听多个 Future 的状态：

1
use tokio::time::{sleep, Duration};
2

3
async fn future1() -> String {
4
    sleep(Duration::from_secs(1)).await;
5
    String::from("future1")
6
}
7

8
async fn future2() -> String {
9
    sleep(Duration::from_secs(2)).await;
10
    String::from("future2")
11
}
12

13
#[tokio::main]
14
async fn main() {
15
    loop {
16
        select! {
17
            result1 = future1().fuse() | result2 = future2().fuse() => {
18
                if let Some(result) = result1 {
19
                    println!("future1 completed with result: {}", result);
20
                }
21
                if let Some(result) = result2 {
22
                    println!("future2 completed with result: {}", result);
23
                }
24
            }
25
        }
26
    }
27
}

展开收起

在这个示例中，我们使用复合模式来监听 future1 和 future2 的状态。如果其中一个 Future 完成，我们就可以在代码块中处理其结果。

使用 loop 和 break 来实现多次选择#

假设我们有一个异步任务task，我们希望在它完成之前等待一段时间，如果这段时间内它还没有完成，就认为它已经超时了。但是，我们希望在超时之后再等待一段时间，如果这段时间内它还没有完成，就再次认为它已经超时了。这时，我们可以使用 loop 和 break 来实现多次选择：

1
use tokio::select;
2
use tokio::time::{Duration, sleep};
3

4
#[tokio::main]
5
async fn main() {
6
    let mut task = async {
7
        // 异步任务的代码
8
    };
9

10
    loop {
11
        let result = select! {
12
            result = task => result,
13
            _ = sleep(Duration::from_secs(5)) => {
14
                println!("task timeout");
15
                None
16
            }
17
        };
18

19
        if let Some(result) = result {
20
            println!("completed task result: {}", result);
21
            break;
22
        }
23
    }
24
}

展开收起

在这个示例中，我们定义了一个异步任务task，并使用select!宏来等待它完成。同时，我们还使用了sleep函数来等待 5 秒钟。当task完成时，我们会返回它的结果；当 5 秒钟过去后，我们会返回一个None。在loop中，我们会不断地使用select!宏来等待task的完成或超时，并根据返回值来决定是否跳出循环。

使用 if let 来处理多个异步任务的结果#

假设我们有多个异步任务task1、task2和task3，我们希望在它们全部完成后对它们的结果进行处理。这时，我们可以使用 if let 来处理多个异步任务的结果：

1
use tokio::select;
2

3
#[tokio::main]
4
async fn main() {
5
    let mut task1 = async {
6
        // 异步任务1的代码
7
        Ok("task1 result")
8
    };
9
    let mut task2 = async {
10
        // 异步任务2的代码
11
        Ok("task2 result")
12
    };
13
    let mut task3 = async {
14
        // 异步任务3的代码
15
        Ok("task3 result")
16
    };
17

18
    let mut result1 = None;
19
    let mut result2 = None;
20
    let mut result3 = None;
21

22
    select! {
23
        r = task1 => {
24
            result1 = Some(r);
25
        },
26
        r = task2 => {
27
            result2 = Some(r);
28
        },
29
        r = task3 => {
30
            result3 = Some(r);
31
        }
32
    }
33

34
    if let (Some(result1), Some(result2), Some(result3)) = (result1, result2, result3) {
35
        println!("completed task results: {}, {}, {}", result1, result2, result3);
36
    }
37
}

展开收起

在这个示例中，我们定义了多个异步任务，并使用select!宏来等待它们全部完成。同时，我们使用了三个变量result1、result2和result3来存储它们的结果。在if let中，我们会判断这三个变量是否都有值，如果都有值，就打印出它们的结果。

使用 select!宏来实现异步任务的取消#

假设我们有一个异步任务task，我们希望在它完成之前等待一段时间，如果这段时间内它还没有完成，就取消它。这时，我们可以使用 select!宏来实现异步任务的取消：

1
use tokio::select;
2
use tokio::time::{Duration, sleep};
3

4
#[tokio::main]
5
async fn main() {
6
    let mut task = async {
7
        // 异步任务的代码
8
    };
9

10
    let result = select! {
11
        result = task => result,
12
        _ = sleep(Duration::from_secs(5)) => {
13
            task.abort();
14
            None
15
        }
16
    };
17

18
    match result {
19
        Some(result) => println!("completed task result: {}", result),
20
        None => println!("task cancelled")
21
    }
22
}

展开收起

在这个示例中，我们定义了一个异步任务task，并使用select!宏来等待它完成。同时，我们还使用了sleep函数来等待 5 秒钟。当task完成时，我们会返回它的结果；当 5 秒钟过去后，我们会取消task。最后，我们会根据result的值来打印出完成的任务的结果或取消信息。

结语#

在本篇教程中，我们介绍了 Rust 语言中的 Tokio 模块 select!宏的进阶用法，并提供了一些示例代码。通过学习这些内容，我们可以更好地掌握这个宏的使用，从而编写出更加高效和高质量的异步代码。

Rust语言从入门到精通系列 - 深入理解Tokio的Stream

Sun, 30 Apr 2023 00:00:00 GMT

在 Rust 语言中，Tokio 是一个非常流行的异步编程框架。它提供了一系列的模块，其中最常用的就是 Stream 模块。Stream 模块允许我们以异步的方式处理数据流，这在很多情况下非常有用。在本教程中，我们将介绍 Stream 模块的基础用法和进阶用法，并提供示例。

基础用法#

在本节中，我们将介绍 Stream 模块的基础用法，并提供基础示例。

从 Vec 中创建 Stream#

首先，我们将从一个 Vec 中创建一个 Stream。假设我们有一个包含数字 1 到 10 的 Vec，我们可以使用stream::iter函数来创建一个 Stream。

1
/* [dependencies] tokio = { version = "*", features = ["full"] } tokio-stream = "*" */
2
use tokio_stream::StreamExt;
3

4
#[tokio::main]
5
async fn main() {
6
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
7
    let mut stream = tokio_stream::iter(vec);
8

9
    while let Some(num) = stream.next().await {
10
        println!("{}", num);
11
    }
12
}

在上面的代码中，我们使用了StreamExt trait 中的next方法来遍历 Stream 中的每个元素。注意，我们需要使用await关键字来等待每个元素的到来。

从文件中创建 Stream#

接下来，我们将介绍如何从文件中创建一个 Stream。假设我们有一个名为data.txt的文件，其中包含一些文本行。我们可以使用tokio::fs::File::open方法来打开文件，并使用tokio::io::BufReader来读取文件中的每一行。

1
use tokio::io::{AsyncBufReadExt, BufReader};
2
use tokio::fs::File;
3

4
#[tokio::main]
5
async fn main() {
6
    let file = File::open("data.txt").await.unwrap();
7
    let mut reader = BufReader::new(file).lines();
8

9
    while let Some(line) = reader.next_line().await.unwrap() {
10
        println!("{}", line);
11
    }
12
}

在上面的代码中，我们使用了AsyncBufReadExt trait 中的next_line方法来遍历 Stream 中的每个元素。注意，我们需要使用await关键字来等待每个元素的到来。

使用 Stream 的 map 方法#

接下来，我们将介绍如何使用 Stream 的map方法来对 Stream 中的元素进行转换。假设我们有一个包含数字 1 到 10 的 Vec，我们可以使用stream::iter函数来创建一个 Stream，并使用map方法将每个数字乘以 2。

1
use tokio_stream::StreamExt;
2

3
#[tokio::main]
4
async fn main() {
5
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
6
    let mut stream = tokio_stream::iter(vec).map(|x| x * 2);
7

8
    while let Some(num) = stream.next().await {
9
        println!("{}", num);
10
    }
11
}

在上面的代码中，我们使用了map方法将每个数字乘以 2。这种方式非常适合对 Stream 中的元素进行转换。

使用 Stream 的 filter 方法#

接下来，我们将介绍如何使用 Stream 的filter方法来过滤 Stream 中的元素。假设我们有一个包含数字 1 到 10 的 Vec，我们可以使用stream::iter函数来创建一个 Stream，并使用filter方法将大于 5 的数字过滤出来。

1
use tokio_stream::StreamExt;
2

3
#[tokio::main]
4
async fn main() {
5
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
6
    let mut stream = tokio_stream::iter(vec).filter(|x| *x > 5);
7

8
    while let Some(num) = stream.next().await {
9
        println!("{}", num);
10
    }
11
}

在上面的代码中，我们使用了filter方法将大于 5 的数字过滤出来。这种方式非常适合对 Stream 中的元素进行过滤。

使用 Stream 的 take 方法#

接下来，我们将介绍如何使用 Stream 的take方法来限制 Stream 中的元素数量。假设我们有一个包含数字 1 到 10 的 Vec，我们可以使用stream::iter函数来创建一个 Stream，并使用take方法限制只输出前 3 个数字。

1
use tokio_stream::StreamExt;
2

3
#[tokio::main]
4
async fn main() {
5
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
6
    let mut stream = tokio_stream::iter(vec).take(3);
7

8
    while let Some(num) = stream.next().await {
9
        println!("{}", num);
10
    }
11
}

在上面的代码中，我们使用了take方法限制只输出前 3 个数字。这种方式非常适合对 Stream 中的元素数量进行限制。

使用 Stream 的 fold 方法#

最后，我们将介绍如何使用 Stream 的fold方法来对 Stream 中的元素进行累加。假设我们有一个包含数字 1 到 10 的 Vec，我们可以使用stream::iter函数来创建一个 Stream，并使用fold方法将每个数字相加。

1
use tokio_stream::StreamExt;
2

3
#[tokio::main]
4
async fn main() {
5
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
6
    let sum = tokio_stream::iter(vec).fold(0, |acc, x| async move { acc + x }).await;
7

8
    println!("{}", sum);
9
}

在上面的代码中，我们使用了fold方法将每个数字相加。注意，我们需要使用async move关键字来让闭包具有异步能力。

进阶用法#

在本节中，我们将介绍 Stream 模块的进阶用法，并提供进阶示例。

使用 Stream 的 buffer_unordered 方法#

首先，我们将介绍如何使用 Stream 的buffer_unordered方法来并发处理 Stream 中的元素。假设我们有一个包含数字 1 到 10 的 Vec，我们可以使用stream::iter函数来创建一个 Stream，并使用buffer_unordered方法并发处理每个数字。

1
use tokio_stream::StreamExt;
2

3
#[tokio::main]
4
async fn main() {
5
    let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
6
    let mut stream = tokio_stream::iter(vec).buffer_unordered(4);
7

8
    while let Some(num) = stream.next().await {
9
        println!("{}", num);
10
    }
11
}

在上面的代码中，我们使用了buffer_unordered方法并发处理每个数字。注意，我们需要使用await关键字来等待每个元素的到来。

使用 Stream 的 zip 方法#

接下来，我们将介绍如何使用 Stream 的zip方法将两个 Stream 合并为一个 Stream。假设我们有两个包含数字 1 到 5 的 Vec，我们可以使用stream::iter函数来创建两个 Stream，并使用zip方法将它们合并为一个 Stream。

1
use tokio_stream::StreamExt;
2

3
#[tokio::main]
4
async fn main() {
5
    let vec1 = vec![1, 2, 3, 4, 5];
6
    let vec2 = vec![6, 7, 8, 9, 10];
7
    let mut stream1 = tokio_stream::iter(vec1);
8
    let mut stream2 = tokio_stream::iter(vec2);
9
    let mut stream = stream1.zip(stream2);
10

11
    while let Some((num1, num2)) = stream.next().await {
12
        println!("{} {}", num1, num2);
13
    }
14
}

在上面的代码中，我们使用了zip方法将两个 Stream 合并为一个 Stream。注意，我们需要使用await关键字来等待每个元素的到来。

使用 Stream 的 forward 方法#

最后，我们将介绍如何使用 Stream 的forward方法将一个 Stream 转发到另一个 Stream。假设我们有一个名为data.txt的文件，其中包含一些文本行。我们可以使用tokio::fs::File::open方法来打开文件，并使用tokio::io::BufReader来读取文件中的每一行。然后，我们可以使用forward方法将读取的每一行转发到标准输出。

1
use tokio::io::{AsyncBufReadExt, BufReader};
2
use tokio::fs::File;
3
use tokio_stream::StreamExt;
4

5
#[tokio::main]
6
async fn main() {
7
    let file = File::open("data.txt").await.unwrap();
8
    let mut reader = BufReader::new(file).lines();
9
    let stdout = tokio::io::stdout();
10
    let mut writer = tokio::io::BufWriter::new(stdout);
11

12
    reader.forward(&mut writer).await.unwrap();
13
}

在上面的代码中，我们使用了forward方法将读取的每一行转发到标准输出。注意，我们需要使用await关键字来等待每个元素的到来。

结论#

在本教程中，我们介绍了 Rust 语言中的 Tokio 模块 Stream 的基础用法和进阶用法。Stream 模块提供了一种非常方便的方式来处理数据流，这在异步编程中非常有用。我们希望这个教程可以帮助你更好地理解 Stream 模块的用法和特性。

Rust语言从入门到精通系列 - Tokio结合tracing模块实践

Sun, 30 Apr 2023 00:00:00 GMT

在 Rust 语言中，Tokio 是一个非常流行的异步运行时，它提供了高效的异步 I/O 操作和任务调度。而 Tracing 则是一个用于应用程序跟踪的框架，它可以帮助我们理解应用程序的行为和性能，并在调试和故障排除时提供有用的信息。

在本教程中，我们将介绍如何使用 Tokio 和 Tracing 模块来构建一个异步的网络应用程序，并使用 Tracing 来记录应用程序的行为和性能。我们将从安装和配置开始，然后介绍如何使用 Tokio 和 Tracing 来编写异步网络代码，最后提供一些示例代码来帮助您开始构建自己的应用程序。

安装和配置#

在使用 Tokio 和 Tracing 之前，我们需要安装它们并配置我们的 Rust 开发环境。首先，我们需要确保我们的 Rust 版本是最新的，并且我们已经安装了 Cargo。

接下来，我们需要将 Tokio 和 Tracing 添加到我们的 Cargo.toml 文件中：

1
[dependencies]
2
tokio = { version = "1", features = ["full"] }
3
tracing = "0.1"
4
tracing-futures = "0.2"
5
tracing-attributes = "0.1"

这将使 Cargo 下载并安装 Tokio 和 Tracing 及其相关依赖项。

使用 Tokio 和 Tracing 编写异步网络代码#

现在，我们已经安装了 Tokio 和 Tracing，让我们开始编写异步网络代码。首先，我们需要导入 Tokio 和 Tracing 模块：

1
use tokio::net::TcpListener;
2
use tokio::io::{AsyncReadExt, AsyncWriteExt};
3
use tracing::{debug, error, info, span, Level};
4
use tracing_futures::Instrument;

接下来，我们需要编写一个异步函数来处理客户端连接。这个函数将接受一个 TcpStream 作为参数，并将客户端的数据读取到一个缓冲区中，然后将响应写回客户端。

1
async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn std::error::Error>> {
2
    let mut buf = [0; 1024];
3

4
    loop {
5
        let n = stream.read(&mut buf).await?;
6

7
        if n == 0 {
8
            return Ok(());
9
        }
10

11
        stream.write_all(&buf[0..n]).await?;
12
    }
13
}

现在，我们需要编写一个异步函数来监听传入的连接。这个函数将创建一个 TcpListener 并循环接受传入的连接。对于每个新连接，它将使用 handle_client 函数处理它。

1
async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
2
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
3
    loop {
4
        let (stream, _) = listener.accept().await?;
5
        let span = span!(Level::INFO, "client", remote_addr = %stream.peer_addr()?);
6
        let _enter = span.enter();
7

8
        debug!("accepted connection");
9

10
        tokio::spawn(async move {
11
            handle_client(stream)
12
                .instrument(span!(Level::INFO, "handle_client"))
13
                .await
14
                .unwrap_or_else(|e| error!("error: {:?}", e));
15
        });
16
    }
17

18
    Ok(())
19
}

展开收起

在这个函数中，我们使用 tokio::spawn 来启动一个新的异步任务来处理每个客户端连接。我们还使用 Tracing 来记录我们的应用程序行为和性能。

示例代码#

下面是一个完整的示例代码，演示如何使用 Tokio 和 Tracing 来构建一个异步的网络应用程序：

1
use tokio::net::TcpListener;
2
use tokio::io::{AsyncReadExt, AsyncWriteExt};
3
use tracing::{debug, error, info, span, Level};
4
use tracing_futures::Instrument;
5

6
async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn std::error::Error>> {
7
    let mut buf = [0; 1024];
8

9
    loop {
10
        let n = stream.read(&mut buf).await?;
11

12
        if n == 0 {
13
            return Ok(());
14
        }
15

16
        stream.write_all(&buf[0..n]).await?;
17
    }
18
}
19

20
async fn run_server() -> Result<(), Box<dyn std::error::Error>> {
21
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
22
    loop {
23
        let (stream, _) = listener.accept().await?;
24
        let span = span!(Level::INFO, "client", remote_addr = %stream.peer_addr()?);
25
        let _enter = span.enter();
26

27
        debug!("accepted connection");
28

29
        tokio::spawn(async move {
30
            handle_client(stream)
31
                .instrument(span!(Level::INFO, "handle_client"))
32
                .await
33
                .unwrap_or_else(|e| error!("error: {:?}", e));
34
        });
35
    }
36

37
    Ok(())
38
}
39

40
#[tokio::main]
41
async fn main() -> Result<(), Box<dyn std::error::Error>> {
42
    tracing_subscriber::fmt::init();
43

44
    info!("starting server");
45

46
    run_server().await?;
47

48
    Ok(())
49
}

展开收起

在这个示例代码中，我们使用 tokio::main 宏来启动我们的异步应用程序。我们还使用 Tracing 的 fmt 订阅者来记录应用程序的行为和性能。

结论#

在本教程中，我们介绍了如何使用 Tokio 和 Tracing 模块来构建一个异步的网络应用程序，并使用 Tracing 来记录应用程序的行为和性能。我们还提供了一些示例代码来帮助您开始构建自己的应用程序。

如果您想深入了解 Tokio 和 Tracing，可以查看官方文档和示例代码，以及其他开发者的博客和文章。祝您在 Rust 语言中编写高效的异步应用程序！

Rust语言从入门到精通系列 - Tokio进行优雅的停机

Sun, 30 Apr 2023 00:00:00 GMT

在进行高并发、网络编程时，优雅停机是一个非常重要的问题。在 Rust 语言中，Tokio 是一个非常流行的异步编程框架，它提供了一些优雅停机的机制，本文将围绕 Tokio 模块的优雅停机进行详细的讲解。

Tokio 模块简介#

Tokio 是 Rust 语言中的异步编程框架，它提供了一些基础的异步编程工具，如异步 IO、任务调度等。Tokio 的异步编程模型基于 Future 和 Task，其中 Future 代表异步计算的结果，而 Task 则代表异步计算的执行上下文。Tokio 的任务调度器会负责管理所有的 Task，并在 Future 完成时将其推入相应的 Task 中执行。

优雅停机的意义#

在进行网络编程时，服务器需要处理大量的请求，而在某些情况下，服务器需要停止服务。如果直接关闭服务器，会导致正在处理的请求被中断，可能会导致数据丢失或者服务不可用。因此，在关闭服务器时，需要进行优雅停机，即在关闭服务器之前，需要等待所有请求处理完毕，并且不再接受新的请求。

Tokio 模块的优雅停机#

在 Tokio 模块中，提供了一些优雅停机的机制，包括：

优雅停机信号
优雅停机超时
优雅停机任务

下面将详细介绍这些机制。

优雅停机信号#

优雅停机信号是一种通知服务器进行优雅停机的机制。在 Unix 系统中，常用的优雅停机信号是 SIGTERM 和 SIGINT。当收到这些信号时，服务器应该停止接受新的请求，并等待正在处理的请求完成。

在 Tokio 模块中，可以使用 tokio_signal 模块来监听优雅停机信号。下面是一个示例代码：

1
use tokio::signal::unix::{Signal, SIGTERM, SIGINT};
2

3
#[tokio::main]
4
async fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    // 创建信号监听器
6
    let mut sigterm = Signal::new(SIGTERM)?;
7
    let mut sigint = Signal::new(SIGINT)?;
8

9
    // 等待信号
10
    tokio::select! {
11
        _ = sigterm.recv() => {
12
            println!("Received SIGTERM, shutting down gracefully...");
13
        }
14
        _ = sigint.recv() => {
15
            println!("Received SIGINT, shutting down gracefully...");
16
        }
17
    }
18

19
    Ok(())
20
}

展开收起

在上面的代码中，我们使用 Signal::new 函数创建了两个信号监听器，分别监听 SIGTERM 和 SIGINT 信号。然后使用 tokio::select!宏来等待信号的到来，如果收到信号，则输出相应的日志信息。

优雅停机超时#

在等待正在处理的请求完成时，可能会出现请求处理时间过长的情况。为了避免服务停机时间过长，需要设置一个优雅停机的超时时间。如果在超时时间内，请求还没有处理完成，则直接关闭服务器。

在 Tokio 模块中，可以使用 tokio::time 模块来设置超时时间。下面是一个示例代码：

1
use tokio::signal::unix::{Signal, SIGTERM, SIGINT};
2
use tokio::time::{sleep, Duration};
3

4
const GRACEFUL_SHUTDOWN_TIMEOUT: u64 = 30;
5

6
#[tokio::main]
7
async fn main() -> Result<(), Box<dyn std::error::Error>> {
8
    // 创建信号监听器
9
    let mut sigterm = Signal::new(SIGTERM)?;
10
    let mut sigint = Signal::new(SIGINT)?;
11

12
    // 等待信号
13
    tokio::select! {
14
        _ = sigterm.recv() => {
15
            println!("Received SIGTERM, shutting down gracefully...");
16
        }
17
        _ = sigint.recv() => {
18
            println!("Received SIGINT, shutting down gracefully...");
19
        }
20
    }
21

22
    // 等待请求处理完成
23
    let start_time = std::time::Instant::now();
24
    while start_time.elapsed().as_secs() < GRACEFUL_SHUTDOWN_TIMEOUT {
25
        if is_all_request_completed() {
26
            break;
27
        }
28
        sleep(Duration::from_secs(1)).await;
29
    }
30

31
    // 如果请求还没有处理完成，则直接关闭服务器
32
    if !is_all_request_completed() {
33
        println!("Graceful shutdown timeout, closing server...");
34
    }
35

36
    Ok(())
37
}
38

39
fn is_all_request_completed() -> bool {
40
    // 判断是否所有请求都已经处理完成
41
    true
42
}

展开收起

在上面的代码中，我们使用 tokio::time::sleep 函数来等待请求处理完成，并设置了一个超时时间。如果在超时时间内，请求还没有处理完成，则直接关闭服务器。

优雅停机任务#

在等待正在处理的请求完成时，可能需要执行一些清理操作，如关闭数据库连接、释放资源等。为了避免这些清理操作被中断，需要将它们封装成一个优雅停机任务，在服务器关闭之前执行。

在 Tokio 模块中，可以使用 tokio::task::spawn_blocking 函数来创建一个优雅停机任务。下面是一个示例代码：

1
use tokio::signal::unix::{Signal, SIGTERM, SIGINT};
2
use tokio::time::{sleep, Duration};
3
use tokio::task::spawn_blocking;
4

5
const GRACEFUL_SHUTDOWN_TIMEOUT: u64 = 30;
6

7
#[tokio::main]
8
async fn main() -> Result<(), Box<dyn std::error::Error>> {
9
    // 创建信号监听器
10
    let mut sigterm = Signal::new(SIGTERM)?;
11
    let mut sigint = Signal::new(SIGINT)?;
12

13
    // 等待信号
14
    tokio::select! {
15
        _ = sigterm.recv() => {
16
            println!("Received SIGTERM, shutting down gracefully...");
17
        }
18
        _ = sigint.recv() => {
19
            println!("Received SIGINT, shutting down gracefully...");
20
        }
21
    }
22

23
    // 执行优雅停机任务
24
    let graceful_shutdown_task = spawn_blocking(|| {
25
        // 执行清理操作
26
        cleanup();
27
    });
28

29
    // 等待请求处理完成
30
    let start_time = std::time::Instant::now();
31
    while start_time.elapsed().as_secs() < GRACEFUL_SHUTDOWN_TIMEOUT {
32
        if is_all_request_completed() {
33
            break;
34
        }
35
        sleep(Duration::from_secs(1)).await;
36
    }
37

38
    // 等待优雅停机任务完成
39
    graceful_shutdown_task.await.unwrap();
40

41
    // 如果请求还没有处理完成，则直接关闭服务器
42
    if !is_all_request_completed() {
43
        println!("Graceful shutdown timeout, closing server...");
44
    }
45

46
    Ok(())
47
}
48

49
fn is_all_request_completed() -> bool {
50
    // 判断是否所有请求都已经处理完成
51
    true
52
}
53

54
fn cleanup() {
55
    // 执行清理操作
56
}

展开收起

在上面的代码中，我们使用 tokio::task::spawn_blocking 函数创建了一个优雅停机任务，用于执行清理操作。在等待请求处理完成时，我们等待这个任务完成，并在关闭服务器之前执行清理操作。

总结#

在本文中，我们介绍了 Tokio 模块的优雅停机机制，包括优雅停机信号、优雅停机超时和优雅停机任务。这些机制可以帮助我们在服务器关闭时，避免数据丢失和服务不可用的问题。在实际应用中，我们应该根据具体情况选择合适的优雅停机机制，并且在优雅停机任务中执行必要的清理操作。

简单的Golang泛型教程

Thu, 27 Apr 2023 00:00:00 GMT

Python 3.x从基础到实战 - 检查磁盘可用空间

Thu, 27 Apr 2023 00:00:00 GMT

在 Linux 服务器上，磁盘空间的使用情况是一个非常重要的指标。如果服务器上的磁盘空间不足，可能会导致服务器崩溃，影响网站的正常运行。为了避免这种情况的发生，我们需要定期检查服务器上的磁盘空间，并及时清理不必要的文件。本文将介绍如何使用 Python 3脚本检查 Linux 服务器上的磁盘空间。

使用psutil模块实现#

首先，我们需要安装psutil模块。psutil是一个跨平台的库，用于获取系统信息，包括磁盘使用情况、CPU使用情况等。我们可以使用以下命令来安装psutil：

Terminal window

1
pip3 install psutil

获取磁盘使用情况#

我们将使用psutil模块来获取磁盘使用情况。以下是获取磁盘使用情况的示例代码：

1
import psutil
2

3
# 获取磁盘使用情况
4
disk_usage = psutil.disk_usage('/')
5

6
# 打印磁盘使用情况
7
print(f"Total: {disk_usage.total / (1024*1024*1024):.2f} GB")
8
print(f"Used: {disk_usage.used / (1024*1024*1024):.2f} GB")
9
print(f"Free: {disk_usage.free / (1024*1024*1024):.2f} GB")

在这个示例中，我们使用psutil.disk_usage()函数来获取磁盘使用情况。该函数需要传递一个参数，即要获取使用情况的磁盘路径。在这个示例中，我们传递了根目录/作为参数。psutil.disk_usage()函数返回一个namedtuple对象，其中包含总容量、已用容量和可用容量等信息。

获取磁盘挂载点#

在Linux系统中，磁盘可以挂载到不同的目录下。如果您的系统中有多个磁盘，您可能需要检查每个磁盘的可用空间。以下是获取磁盘挂载点的示例代码：

1
import psutil
2

3
# 获取磁盘挂载点
4
disk_partitions = psutil.disk_partitions()
5

6
# 打印磁盘挂载点
7
for partition in disk_partitions:
8
    print(f"Device: {partition.device}")
9
    print(f"Mountpoint: {partition.mountpoint}")
10
    print(f"File system type: {partition.fstype}")
11
    print()

在这个示例中，我们使用psutil.disk_partitions()函数来获取磁盘挂载点。该函数返回一个列表，其中包含每个挂载点的信息，包括设备、挂载点和文件系统类型等。

检查磁盘可用空间#

现在我们已经了解了如何获取磁盘使用情况和磁盘挂载点，让我们编写一个脚本来检查磁盘的可用空间。以下是检查磁盘可用空间的示例代码：

1
import psutil
2
import os
3

4
# 获取磁盘挂载点
5
disk_partitions = psutil.disk_partitions()
6

7
# 遍历每个挂载点
8
for partition in disk_partitions:
9
    # 获取磁盘使用情况
10
    disk_usage = psutil.disk_usage(partition.mountpoint)
11

12
    # 计算磁盘可用空间的百分比
13
    free_percent = disk_usage.free / disk_usage.total * 100
14

15
    # 如果磁盘可用空间小于10%，发送警告邮件
16
    if free_percent < 10:
17
        # 获取主机名
18
        hostname = os.uname()[1]
19

20
        # 构造邮件内容
21
        subject = f"Disk space warning on {hostname}"
22
        message = f"The disk {partition.device} ({partition.mountpoint}) is running out of space ({free_percent:.2f}% free)."
23

24
        # 发送邮件
25
        send_email(subject, message)

展开收起

在这个示例中，我们遍历了每个磁盘挂载点，并使用psutil.disk_usage()函数获取了每个挂载点的使用情况。然后，我们计算了每个挂载点的可用空间百分比，并检查了是否小于10%。如果是，我们将发送一封警告邮件。

使用 `du` 命令实现#

使用 du 命令检查磁盘空间#

du 命令是 Linux 系统中一个非常有用的命令，可以用来查看当前目录或文件的磁盘使用情况。在 Python 3 中，我们可以使用 subprocess 模块来执行 du 命令，并将其输出解析为 Python 对象。

以下是一个简单的 Python 3 脚本，用于检查服务器上特定目录的磁盘使用情况：

1
import subprocess
2

3
def get_directory_size(path):
4
    """Return the total size of the files in the given directory and subdirectories."""
5
    cmd = ["du", "-sh", path]
6
    result = subprocess.run(cmd, stdout=subprocess.PIPE)
7
    output = result.stdout.decode("utf-8").strip()
8
    size = output.split()[0]
9
    return size
10

11
# Example usage:
12
size = get_directory_size("/var/www/html")
13
print("Size of /var/www/html: {}".format(size))

在上面的示例中，我们定义了一个名为 get_directory_size 的函数，该函数接受一个路径作为参数，并返回该目录及其子目录中文件的总大小。该函数使用 subprocess.run 函数来执行 du 命令，并将其输出解析为 Python 对象。然后，我们从输出中提取出目录的大小，并将其作为字符串返回。

要使用此函数，只需调用 get_directory_size 并传递要检查的目录的路径即可。在上面的示例中，我们检查了 /var/www/html 目录的大小，并将结果打印到控制台上。

检查多个目录的磁盘空间#

如果您需要检查多个目录的磁盘使用情况，可以使用一个简单的循环来遍历目录列表，并调用 get_directory_size 函数来获取每个目录的大小。以下是一个示例脚本，用于检查多个目录的磁盘使用情况：

1
import subprocess
2

3
def get_directory_size(path):
4
    """Return the total size of the files in the given directory and subdirectories."""
5
    cmd = ["du", "-sh", path]
6
    result = subprocess.run(cmd, stdout=subprocess.PIPE)
7
    output = result.stdout.decode("utf-8").strip()
8
    size = output.split()[0]
9
    return size
10

11
# List of directories to check
12
directories = ["/var/www/html", "/var/log", "/etc"]
13

14
# Loop through directories and print their sizes
15
for directory in directories:
16
    size = get_directory_size(directory)
17
    print("Size of {}: {}".format(directory, size))

展开收起

在上面的示例中，我们定义了一个名为 directories 的列表，其中包含要检查的目录的路径。然后，我们使用一个简单的循环遍历该列表，并调用 get_directory_size 函数来获取每个目录的大小。

检查磁盘空间使用率#

除了检查单个目录或多个目录的磁盘使用情况之外，我们还可以使用 Python 3 来检查整个磁盘的使用情况。以下是一个示例脚本，用于检查磁盘使用率：

1
import subprocess
2

3
def get_disk_usage():
4
    """Return the disk usage of the root filesystem in percent."""
5
    cmd = ["df", "-h", "/"]
6
    result = subprocess.run(cmd, stdout=subprocess.PIPE)
7
    output = result.stdout.decode("utf-8").strip()
8
    usage = int(output.split("\n")[1].split()[4].replace("%", ""))
9
    return usage
10

11
# Example usage:
12
usage = get_disk_usage()
13
print("Disk usage: {}%".format(usage))

在上面的示例中，我们定义了一个名为 get_disk_usage 的函数，该函数返回根文件系统的磁盘使用率。该函数使用 subprocess.run 函数来执行 df 命令，并将其输出解析为 Python 对象。然后，我们从输出中提取出磁盘使用率，并将其作为整数返回。

要使用此函数，只需调用 get_disk_usage 并将其结果打印到控制台上即可。

发送邮件#

在上面的示例中，我们调用了一个名为send_email()的函数来发送邮件。这个函数需要进行自定义实现。以下是一个简单的send_email()函数的示例代码：

1
import smtplib
2
from email.mime.text import MIMEText
3
from email.header import Header
4

5
def send_email(subject, message):
6
    # 邮件发送者和接收者
7
    sender = 'sender@example.com'
8
    receiver = 'receiver@example.com'
9

10
    # 邮件主题和内容
11
    msg = MIMEText(message, 'plain', 'utf-8')
12
    msg['Subject'] = Header(subject, 'utf-8')
13

14
    # 发送邮件
15
    smtp = smtplib.SMTP('smtp.example.com')
16
    smtp.login(sender, 'password')
17
    smtp.sendmail(sender, receiver, msg.as_string())
18
    smtp.quit()

展开收起

在这个示例中，我们使用smtplib模块来发送邮件。首先，我们指定了邮件发送者和接收者的地址。然后，我们使用MIMEText类创建了一个邮件对象，并指定了邮件的主题和内容。最后，我们使用SMTP类连接到邮件服务器，并使用login()方法进行身份验证。然后，我们使用sendmail()方法发送邮件，并使用quit()方法关闭连接。

结论#

在这篇教程中，我们使用Python 3编写了一个脚本来检查Linux服务器的磁盘可用空间。我们使用了psutil和os模块来获取磁盘信息，并编写了一个简单的函数来发送警告邮件。这个脚本可以帮助您在磁盘空间不足时及时采取措施，避免系统崩溃。

Python 3.x从基础到实战 - 检查内存可用大小

Thu, 27 Apr 2023 00:00:00 GMT

在Linux服务器管理中，内存是一个非常重要的资源。如果服务器的内存不足，可能会导致服务器崩溃或者无法正常工作。因此，检查Linux服务器内存可用大小是非常必要的。本文将介绍如何使用Python 3实现检查Linux服务器内存可用大小的方法，包括使用Python标准库实现和使用Linux命令实现两种方式。

使用 `psutil` 标准库实现#

Python标准库中有一个psutil模块，它提供了一个跨平台的API，可以用来获取系统信息，包括CPU、内存、磁盘、网络等。我们可以使用psutil模块来获取Linux服务器的内存信息。

首先，我们需要安装psutil模块。在Linux服务器上，可以使用以下命令来安装：

Terminal window

1
pip3 install psutil

安装完成后，我们可以开始编写Python代码。以下是一个示例代码，它可以获取Linux服务器的内存信息，并计算可用内存的大小：

1
import psutil
2

3
# 获取内存信息
4
mem = psutil.virtual_memory()
5

6
# 计算可用内存大小
7
available_mem = mem.available / (1024 * 1024)
8

9
# 打印可用内存大小
10
print("可用内存大小：%.2f MB" % available_mem)

在上面的代码中，我们使用psutil.virtual_memory()函数来获取内存信息。这个函数返回一个namedtuple对象，包含了各种内存信息，包括总内存、可用内存、已使用内存、缓冲区等。我们可以通过访问这个对象的属性来获取相应的内存信息。

在上面的示例代码中，我们获取了可用内存的大小，然后将其转换为MB单位，并打印出来。

使用Linux `free` 命令实现#

除了使用Python标准库外，我们还可以使用Linux命令来获取Linux服务器的内存信息。Linux系统中有一个free命令，可以用来查看内存使用情况。我们可以使用Python的subprocess模块来执行free命令，并解析命令的输出结果来获取内存信息。

以下是一个示例代码，它可以使用free命令获取Linux服务器的内存信息，并计算可用内存的大小：

1
import subprocess
2

3
# 执行free命令，获取内存信息
4
output = subprocess.check_output(["free", "-m"]).decode()
5

6
# 解析输出结果，获取可用内存大小
7
for line in output.split("\n"):
8
    if "Mem" in line:
9
        mem_info = line.split()
10
        total_mem = int(mem_info[1])
11
        used_mem = int(mem_info[2])
12
        free_mem = int(mem_info[3])
13
        available_mem = free_mem + int(mem_info[6])
14
        break
15

16
# 打印可用内存大小
17
print("可用内存大小：{} MB".format(available_mem))

展开收起

在上面的代码中，我们使用subprocess.check_output()函数执行free -m命令，并将命令的输出结果转换为字符串类型。然后，我们遍历输出结果的每一行，找到包含Mem关键字的行，解析这一行的内容，获取总内存、已使用内存、空闲内存、可用内存等信息。最后，我们计算可用内存的大小，并打印出来。

总结#

本文介绍了两种方法，使用Python 3实现检查Linux服务器内存可用大小。第一种方法是使用Python标准库中的psutil模块，它提供了一个跨平台的API，可以用来获取系统信息。第二种方法是使用Linux命令free，并使用Python的subprocess模块来执行命令并解析命令的输出结果。无论是哪种方法，都可以方便地获取Linux服务器的内存信息，并计算可用内存的大小。

Python 3.x从基础到实战 - 检查内存可用大小

Thu, 27 Apr 2023 00:00:00 GMT

使用 `psutil` 标准库实现#

首先，我们需要安装psutil模块。在Linux服务器上，可以使用以下命令来安装：

Terminal window

1
pip3 install psutil

安装完成后，我们可以开始编写Python代码。以下是一个示例代码，它可以获取Linux服务器的内存信息，并计算可用内存的大小：

1
import psutil
2

3
# 获取内存信息
4
mem = psutil.virtual_memory()
5

6
# 计算可用内存大小
7
available_mem = mem.available / (1024 * 1024)
8

9
# 打印可用内存大小
10
print("可用内存大小：%.2f MB" % available_mem)

在上面的示例代码中，我们获取了可用内存的大小，然后将其转换为MB单位，并打印出来。

使用Linux `free` 命令实现#

以下是一个示例代码，它可以使用free命令获取Linux服务器的内存信息，并计算可用内存的大小：

1
import subprocess
2

3
# 执行free命令，获取内存信息
4
output = subprocess.check_output(["free", "-m"]).decode()
5

6
# 解析输出结果，获取可用内存大小
7
for line in output.split("\n"):
8
    if "Mem" in line:
9
        mem_info = line.split()
10
        total_mem = int(mem_info[1])
11
        used_mem = int(mem_info[2])
12
        free_mem = int(mem_info[3])
13
        available_mem = free_mem + int(mem_info[6])
14
        break
15

16
# 打印可用内存大小
17
print("可用内存大小：{} MB".format(available_mem))

展开收起

总结#

Rust语言从入门到精通系列 - 支持WASM的高性能绘图库Plotters

Sun, 23 Apr 2023 00:00:00 GMT

Plotters 是一个基于 Rust 语言的绘图库，由 Eonil 和其他贡献者开发。它的目标是提供一个简单易用的 API，可以轻松地创建各种类型的图表，并支持多种输出格式。Plotters 使用 Rust 语言的强类型系统和高性能，可以生成高质量的图表。

Plotters 提供了多种类型的图表，包括线图、柱状图、散点图等等。它还支持多种输出格式，包括 PNG、SVG、PDF 等等。使用 Plotters 可以轻松地创建高质量的图表，同时还可以自定义图表的样式和布局。

用法实战#

安装 Plotters#

在使用 Plotters 之前，需要安装 Plotters。可以通过以下命令安装 Plotters：

Terminal window

1
cargo install plotters

绘制折线图#

下面是一个简单的例子，演示如何使用 Plotters 绘制折线图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("折线图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart.draw_series(LineSeries::new(
16
        vec![(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]
17
            .iter()
18
            .map(|x| (*x, *x)),
19
        &BLUE,
20
    ))?;
21

22
    Ok(())
23
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用LineSeries对象绘制了一条折线。LineSeries对象需要一个元组列表作为输入，每个元组包含一个 x 坐标和一个 y 坐标。在这个例子中，我们绘制了一条从(0,0)到(9,9)的折线。

绘制柱状图#

下面是一个简单的例子，演示如何使用 Plotters 绘制柱状图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("柱状图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart.draw_series(
16
        Histogram::vertical(&chart)
17
            .margin(5)
18
            .style(GREEN.filled())
19
            .data(vec![2, 3, 4, 5, 6, 7, 8, 9]),
20
    )?;
21

22
    Ok(())
23
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用Histogram对象绘制了一组柱状。Histogram对象需要一个整数向量作为输入，每个整数表示一个柱状的高度。在这个例子中，我们绘制了一组高度为 2 到 9 的柱状。

绘制散点图#

下面是一个简单的例子，演示如何使用 Plotters 绘制散点图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("散点图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart.draw_series(
16
        PointSeries::of_element(
17
            [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)],
18
            5,
19
            &BLUE,
20
            &|c, s, st| {
21
                return EmptyElement::at(c) + Circle::new((0, 0), s, st.filled());
22
            },
23
        ),
24
    )?;
25

26
    Ok(())
27
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用PointSeries对象绘制了一组散点。PointSeries对象需要一个元组列表作为输入，每个元组包含一个 x 坐标和一个 y 坐标。在这个例子中，我们绘制了一组从(0,0)到(9,9)的散点。

绘制饼图#

下面是一个简单的例子，演示如何使用 Plotters 绘制饼图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let data = vec![("A", 10), ("B", 20), ("C", 30), ("D", 40)];
8

9
    let sum = data.iter().map(|(_, v)| v).sum::<i32>() as f64;
10

11
    let mut chart = ChartBuilder::on(&root)
12
        .caption("饼图", ("sans-serif", 30))
13
        .build_ranged(0.0..1.0, 0.0..1.0)?;
14

15
    chart.draw_series(
16
        data.iter()
17
            .map(|(label, value)| {
18
                let value = *value as f64 / sum;
19
                Sector::new(
20
                    (0.5, 0.5),
21
                    value,
22
                    (0.0, 0.0),
23
                    (HSLColor(0.0, 1.0, 0.5), BLACK),
24
                )
25
                .label(label)
26
                .legend(move |(x, y)| {
27
                    Rectangle::new([(x - 5, y - 5), (x + 5, y + 5)], HSLColor(0.0, 1.0, 0.5).filled())
28
                })
29
            })
30
            .collect::<Vec<_>>(),
31
    )?;
32

33
    Ok(())
34
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题。最后，我们使用Sector对象绘制了一组扇形。Sector对象需要一个位置、角度、半径、颜色和标签等参数。在这个例子中，我们绘制了一组占比为 10%、20%、30%和 40%的扇形。

绘制等高线图#

下面是一个简单的例子，演示如何使用 Plotters 绘制等高线图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("等高线图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = (0..=100).map(|i| {
16
        let x = i as f64 / 10.0;
17
        let y = i as f64 / 10.0;
18
        (x, y, (x * x + y * y).sin())
19
    });
20

21
    chart.draw_series(
22
        ContourSeries::new(
23
            data,
24
            (0..=10).map(|i| i as f64),
25
            (0..=10).map(|i| i as f64),
26
            &Palette::viridis(),
27
        )
28
        .levels(20),
29
    )?;
30

31
    Ok(())
32
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用ContourSeries对象绘制了一组等高线。ContourSeries对象需要一个元组列表作为输入，每个元组包含一个 x 坐标、一个 y 坐标和一个高度。在这个例子中，我们绘制了一个以(0,0)为中心的高斯分布等高线。

绘制热力图#

下面是一个简单的例子，演示如何使用 Plotters 绘制热力图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("热力图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = (0..=100).map(|i| {
16
        let x = i as f64 / 10.0;
17
        let y = i as f64 / 10.0;
18
        (x, y, (x * x + y * y).sin())
19
    });
20

21
    chart.draw_series(
22
        Heatmap::new(data, &Palette::viridis())
23
            .x_label("X")
24
            .y_label("Y"),
25
    )?;
26

27
    Ok(())
28
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用Heatmap对象绘制了一个热力图。Heatmap对象需要一个元组列表作为输入，每个元组包含一个 x 坐标、一个 y 坐标和一个高度。在这个例子中，我们绘制了一个以(0,0)为中心的高斯分布热力图。

绘制箱线图#

下面是一个简单的例子，演示如何使用 Plotters 绘制箱线图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("箱线图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = vec![
16
        ("A", vec![2, 3, 4, 5, 6, 7, 8, 9]),
17
        ("B", vec![3, 4, 5, 6, 7, 8, 9, 10]),
18
        ("C", vec![4, 5, 6, 7, 8, 9, 10, 11]),
19
        ("D", vec![5, 6, 7, 8, 9, 10, 11, 12]),
20
    ];
21

22
    chart.draw_series(
23
        data.iter()
24
            .enumerate()
25
            .map(|(i, (label, values))| {
26
                BoxPlot::new_horizontal(
27
                    values.iter().map(|&v| (v - 2) as f64),
28
                    i as f64,
29
                    &BLACK,
30
                )
31
                .label(label)
32
            })
33
            .collect::<Vec<_>>(),
34
    )?;
35

36
    Ok(())
37
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用BoxPlot对象绘制了一组箱线。BoxPlot对象需要一个浮点数向量作为输入，每个浮点数表示一个箱线的高度。在这个例子中，我们绘制了一组包含四个箱线的箱线图。

绘制极坐标图#

下面是一个简单的例子，演示如何使用 Plotters 绘制极坐标图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("极坐标图", ("sans-serif", 30))
9
        .build_cartesian_2d(-1.2..1.2, -1.2..1.2)?;
10

11
    chart.configure_mesh().draw()?;
12

13
    chart.draw_series(LineSeries::new(
14
        (-100..=100)
15
            .map(|i| {
16
                let t = i as f64 / 100.0 * std::f64::consts::PI * 2.0;
17
                (t.cos(), t.sin())
18
            })
19
            .take(101),
20
        &RED,
21
    ))?;
22

23
    Ok(())
24
}

展开收起

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题。最后，我们使用LineSeries对象绘制了一条极坐标线。LineSeries对象需要一个元组列表作为输入，每个元组包含一个角度和一个半径。在这个例子中，我们绘制了一条从 0 度到 360 度的极坐标线。

自定义样式#

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("Custom Style Chart", ("sans-serif", 20))
9
        .x_label_area_size(30)
10
        .y_label_area_size(30)
11
        .build_cartesian_2d(0f32..10f32, 0f32..10f32)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart
16
        .draw_series(LineSeries::new(
17
            (0..10).map(|x| (x as f32, (x as f32).powf(2.0))),
18
            &RED.stroke_width(2),
19
        ))?
20
        .label("y=x^2");
21

22
    chart
23
        .draw_series(LineSeries::new(
24
            (0..10).map(|x| (x as f32, (x as f32).powf(2.0) + 2.0)),
25
            &BLUE.stroke_width(2),
26
        ))?
27
        .label("y=x^2+2");
28

29
    chart
30
        .configure_series_labels()
31
        .background_style(&WHITE.mix(0.8))
32
        .border_style(&BLACK)
33
        .draw()?;
34

35
    Ok(())
36
}

展开收起

这个示例创建了一个自定义样式的图表。我们使用stroke_width方法设置了线段的宽度，使用mix方法设置了标签的背景色。我们还使用border_style方法设置了标签的边框颜色。

使用 CSV 文件绘制线图#

下面是一个使用 CSV 文件绘制线图的示例代码：

1
use plotters::prelude::*;
2
use std::fs::File;
3
use std::io::{BufRead, BufReader};
4

5
fn main() -> Result<(), Box<dyn std::error::Error>> {
6
    let root = BitMapBackend::new("line_csv.png", (640, 480)).into_drawing_area();
7
    root.fill(&WHITE)?;
8

9
    let mut chart = ChartBuilder::on(&root)
10
        .caption("Line Chart with CSV", ("sans-serif", 40))
11
        .set_label_area_size(LabelAreaPosition::Left, 50)
12
        .set_label_area_size(LabelAreaPosition::Bottom, 50)
13
        .build_cartesian_2d(0..10, 0..10)?;
14

15
    chart.configure_mesh().draw()?;
16

17
    let file = File::open("data.csv").unwrap();
18
    let reader = BufReader::new(file);
19

20
    let data: Vec<(i32, i32)> = reader
21
        .lines()
22
        .map(|line| {
23
            let line = line.unwrap();
24
            let parts: Vec<&str> = line.split(',').collect();
25
            let x = parts[0].parse::<i32>().unwrap();
26
            let y = parts[1].parse::<i32>().unwrap();
27
            (x, y)
28
        })
29
        .collect();
30

31
    chart.draw_series(LineSeries::new(data, &RED))?;
32

33
    Ok(())
34
}

展开收起

在上述代码中，我们首先创建了一个BitMapBackend对象，用于指定输出格式和大小。然后，我们创建了一个ChartBuilder对象，用于指定图表的标题和坐标轴等属性。接着，我们读取了一个名为data.csv的 CSV 文件，并将其转换为一个包含(i32, i32)元组的向量。最后，我们通过chart.draw_series方法将线图绘制到图表中。

绘制带有标签的散点图#

下面是一个绘制带有标签的散点图的示例代码：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("scatter.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("Scatter Chart with Labels", ("sans-serif", 40))
9
        .set_label_area_size(LabelAreaPosition::Left, 50)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 50)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = [
16
        ("A", (1, 2)),
17
        ("B", (2, 3)),
18
        ("C", (3, 4)),
19
        ("D", (4, 5)),
20
        ("E", (5, 6)),
21
    ];
22

23
    chart.draw_series(
24
        data.iter()
25
            .map(|(label, (x, y))| {
26
                Circle::new((*x, *y), 5, BLUE.filled())
27
                    .label(*label)
28
                    .legend(*label)
29
            })
30
            .collect::<Vec<_>>(),
31
    )?;
32

33
    chart
34
        .configure_series_labels()
35
        .background_style(&WHITE.mix(0.8))
36
        .border_style(&BLACK)
37
        .draw()?;
38

39
    Ok(())
40
}

展开收起

在上述代码中，我们首先创建了一个BitMapBackend对象，用于指定输出格式和大小。然后，我们创建了一个ChartBuilder对象，用于指定图表的标题和坐标轴等属性。接着，我们创建了一个包含标签的散点数据，并使用Circle对象绘制散点图。最后，我们通过chart.configure_series_labels方法绘制标签。

绘制堆叠柱状图#

下面是一个绘制堆叠柱状图的示例代码：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("stacked_bar.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("Stacked Bar Chart", ("sans-serif", 40))
9
        .set_label_area_size(LabelAreaPosition::Left, 50)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 50)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = vec![
16
        ("A", vec![2, 3, 1, 4, 2]),
17
        ("B", vec![1, 4, 3, 2, 1]),
18
        ("C", vec![3, 2, 4, 1, 3]),
19
    ];
20

21
    chart.draw_series(
22
        data.iter()
23
            .enumerate()
24
            .map(|(i, (label, values))| {
25
                let color = Palette99::pick(i);
26
                let values = values.iter().map(|v| *v as i64).collect::<Vec<_>>();
27
                let sum = values.iter().sum::<i64>();
28
                let offset = if i == 0 { 0 } else { data[i - 1].1.iter().sum::<i32>() };
29
                let data = values.iter().enumerate().map(|(j, v)| (j as i32 + offset, *v)).collect::<Vec<_>>();
30
                BarChart::new(data, 0.5)
31
                    .style(color.filled())
32
                    .label(label)
33
                    .legend(format!("{} ({}%)", label, v as f64 / sum as f64 * 100.0))
34
            })
35
            .collect::<Vec<_>>(),
36
    )?;
37

38
    chart
39
        .configure_series_labels()
40
        .background_style(&WHITE.mix(0.8))
41
        .border_style(&BLACK)
42
        .draw()?;
43

44
    Ok(())
45
}

展开收起

在上述代码中，我们首先创建了一个BitMapBackend对象，用于指定输出格式和大小。然后，我们创建了一个ChartBuilder对象，用于指定图表的标题和坐标轴等属性。接着，我们创建了一个包含堆叠柱状数据，并使用BarChart对象绘制堆叠柱状图。最后，我们通过chart.configure_series_labels方法绘制标签。

总结#

Plotters 是一个强大的绘图库，可以用于创建各种类型的图表。它提供了易于使用的 API，可以轻松地创建高质量的图表，并支持多种输出格式。在使用 Plotters 时，我们可以遵循最佳实践，以提高代码的可读性和可维护性。

Rust语言从入门到精通系列 - 轻量级Http客户端Hyper

Sun, 23 Apr 2023 00:00:00 GMT

Hyper 是一个用于构建 HTTP 客户端和服务器的 Rust 语言库。它提供了一个简单易用的 API，使得开发者可以轻松地构建高性能、可靠的 HTTP 应用程序。Hyper 的设计目标是安全、高效和易于使用。

Hyper 的主要特点包括：

支持 HTTP/1 和 HTTP/2 协议
纯 Rust 实现，无需外部依赖
支持异步 I/O 和多线程
提供简单易用的 API

在本教程中，我们将介绍 Hyper 的基础用法和进阶用法，并提供一些最佳实践。

相比于系列文章中介绍的 reqwest, Hyper 设计的更底层，模块化的设计，可以最大限度的允许用户在硬件配置较低的嵌入式设备上使用。假如只是需要一个“好用”的 Http 客户端，推荐使用 reqwest 模块

基础用法#

发送 HTTP 请求#

使用 Hyper 发送 HTTP 请求非常简单。下面是一个简单的示例，它使用 Hyper 发送一个 GET 请求并打印响应的内容：

注意: 以下示例已更新为 reqwest（推荐用于 HTTP 客户端场景）。Hyper 0.10.x 同步 API 已废弃，Hyper 1.x 仅支持异步且 API 完全不同。如需底层 HTTP 控制，请参考 Hyper 1.x 文档。

1
use reqwest::blocking::Client;
2

3
fn main() {
4
    let client = Client::new();
5
    let res = client.get("http://example.com").send().unwrap();
6
    println!("{}", res.status());
7
    println!("{:?}", res.headers());
8
    println!("{}", res.text().unwrap());
9
}

在这个示例中，我们使用 reqwest::blocking::Client 创建了一个 HTTP 客户端，发送 GET 请求并打印响应的状态码、头和内容。Hyper 0.10.x 的同步 API（Client::new(), client.get().send()）已不再可用。

发送 POST 请求#

Hyper 还支持发送 POST 请求。下面是一个简单的示例，它使用 Hyper 发送一个 POST 请求并打印响应的内容：

1
use reqwest::blocking::Client;
2

3
fn main() {
4
    let client = Client::new();
5
    let res = client.post("http://example.com")
6
        .body("hello world")
7
        .send()
8
        .unwrap();
9
    println!("{}", res.status());
10
    println!("{:?}", res.headers());
11
    println!("{}", res.text().unwrap());
12
}

在这个示例中，我们使用 reqwest 发送 POST 请求。Hyper 0.10.x 的 Request::post().body() 同步模式已废弃。

使用代理服务器#

Hyper 还支持使用代理服务器发送 HTTP 请求。下面是一个简单的示例，它使用 Hyper 发送一个通过代理服务器的 HTTP 请求并打印响应的内容：

1
use reqwest::blocking::Client;
2

3
fn main() {
4
    let client = Client::builder()
5
        .proxy(reqwest::Proxy::http("http://proxy.example.com").unwrap())
6
        .build()
7
        .unwrap();
8
    let res = client.get("http://example.com").send().unwrap();
9
    println!("{}", res.status());
10
    println!("{:?}", res.headers());
11
    println!("{}", res.text().unwrap());
12
}

在这个示例中，我们使用 reqwest 设置代理服务器。Hyper 0.10.x 的 Client::builder().proxy() 同步模式已废弃。

使用自定义头#

Hyper 还支持使用自定义头发送 HTTP 请求。下面是一个简单的示例，它使用 Hyper 发送一个带有自定义头的 HTTP 请求并打印响应的内容：

1
use reqwest::blocking::Client;
2
use reqwest::header::{USER_AGENT, HeaderValue};
3

4
fn main() {
5
    let client = Client::new();
6
    let res = client.get("http://example.com")
7
        .header(USER_AGENT, HeaderValue::from_static("my-user-agent"))
8
        .send()
9
        .unwrap();
10
    println!("{}", res.status());
11
    println!("{:?}", res.headers());
12
    println!("{}", res.text().unwrap());
13
}

在这个示例中，我们使用 reqwest 设置自定义请求头。Hyper 0.10.x 的同步请求构建模式已废弃。

使用异步 I/O#

Hyper 支持异步 I/O，这使得它可以处理大量的并发请求。下面是一个简单的示例，它使用 Hyper 异步发送 HTTP 请求并打印响应的内容：

1
use reqwest::Client;
2

3
#[tokio::main]
4
async fn main() {
5
    let client = Client::new();
6
    let res = client.get("http://example.com").send().await.unwrap();
7
    println!("{}", res.status());
8
    println!("{:?}", res.headers());
9
    println!("{}", res.text().await.unwrap());
10
}

在这个示例中，我们使用 reqwest 异步客户端。Hyper 1.x 异步客户端示例（需 hyper_util + http_body_util）：

1
use hyper_util::client::legacy::Client;
2
use hyper_util::rt::TokioExecutor;
3
use http_body_util::BodyExt;
4
use hyper::Request;
5

6
#[tokio::main]
7
async fn main() {
8
    let client: Client<_, String> = Client::builder(TokioExecutor::new()).build_http();
9
    let req = Request::builder()
10
        .uri("http://example.com")
11
        .body(String::new())
12
        .unwrap();
13
    let res = client.request(req).await.unwrap();
14
    println!("{}", res.status());
15
    let body = res.into_body().collect().await.unwrap().to_bytes();
16
    println!("{}", String::from_utf8_lossy(&body));
17
}

展开收起

Hyper 0.10.x 的 client.get(uri).await 模式已废弃，Hyper 1.x 需通过 hyper_util::client::legacy::Client 构建请求。

使用 Cookies#

Hyper 还支持使用 Cookies 发送 HTTP 请求。下面是一个简单的示例，它使用 Hyper 发送一个带有 Cookies 的 HTTP 请求并打印响应的内容：

1
use reqwest::blocking::Client;
2
use reqwest::header::{COOKIE, SET_COOKIE};
3

4
fn main() {
5
    let client = Client::new();
6
    let res = client.get("http://example.com")
7
        .header(COOKIE, "name=value")
8
        .send()
9
        .unwrap();
10
    println!("{}", res.status());
11
    if let Some(cookie) = res.headers().get(SET_COOKIE) {
12
        println!("{}", cookie.to_str().unwrap());
13
    }
14
    println!("{}", res.text().unwrap());
15
}

展开收起

在这个示例中，我们使用 reqwest 通过 Header 方式发送 Cookie。Hyper 0.10.x 的同步 Cookie 模式已废弃。

处理错误#

Hyper 的 API 返回的结果类型是Result，因此我们可以使用标准的 Rust 错误处理机制来处理错误。下面是一个简单的示例，它使用 Hyper 发送一个 HTTP 请求并处理错误：

1
use reqwest::blocking::Client;
2
use std::error::Error;
3

4
fn main() -> Result<(), Box<dyn Error>> {
5
    let client = Client::new();
6
    let res = client.get("http://example.com").send()?;
7
    println!("{}", res.status());
8
    println!("{:?}", res.headers());
9
    println!("{}", res.text()?);
10
    Ok(())
11
}

在这个示例中，我们使用 reqwest 并通过 ? 操作符处理错误。Hyper 0.10.x 的同步 client.get(uri)?.send()? 模式已废弃。

进阶用法#

使用连接池#

Hyper 支持使用连接池来提高 HTTP 请求的性能。下面是一个简单的示例，它使用 Hyper 连接池发送 HTTP 请求并打印响应的内容：

1
use reqwest::blocking::Client;
2
use std::time::Duration;
3

4
fn main() {
5
    let client = Client::builder()
6
        .pool_idle_timeout(Duration::from_secs(30))
7
        .build()
8
        .unwrap();
9
    let res = client.get("https://example.com").send().unwrap();
10
    println!("{}", res.status());
11
    println!("{}", res.text().unwrap());
12
}

在这个示例中，我们使用 reqwest 连接池配置。Hyper 0.10.x 的 HttpConnector/HttpsConnector/rt::run/concat2 模式已全部废弃，Hyper 1.x 需通过 hyper_util 管理。

使用 WebSocket#

Hyper 还支持使用 WebSocket 协议。下面是一个简单的示例，它使用 Hyper 创建一个 WebSocket 连接并发送消息：

注意: Hyper 本身不提供 WebSocket 客户端 API。以下示例使用 tokio-tungstenite 直接连接 WebSocket。

1
use tokio_tungstenite::tungstenite::Message;
2
use futures_util::StreamExt;
3
use tokio_tungstenite::connect_async;
4

5
#[tokio::main]
6
async fn main() {
7
    let (ws_stream, _) = connect_async("ws://example.com").await.unwrap();
8
    let (mut write, mut read) = ws_stream.split();
9
    write.send(Message::Text("hello world".into())).await.unwrap();
10
    while let Some(msg) = read.next().await {
11
        let msg = msg.unwrap();
12
        println!("{}", msg.to_text().unwrap());
13
    }
14
}

在这个示例中，我们使用 tokio-tungstenite 创建 WebSocket 连接。Hyper 0.10.x 的 client.websocket(uri) 方法不存在，WebSocket 需使用专用库如 tokio-tungstenite。

处理连接超时#

Hyper 支持设置连接和请求的超时时间。下面是一个简单的示例，它使用 Hyper 发送一个 HTTP 请求，并设置连接和请求的超时时间：

1
use reqwest::blocking::Client;
2
use std::time::Duration;
3

4
fn main() {
5
    let client = Client::builder()
6
        .timeout(Duration::from_secs(10))
7
        .pool_idle_timeout(Duration::from_secs(30))
8
        .build()
9
        .unwrap();
10
    let res = client.get("http://example.com").send().unwrap();
11
    println!("{}", res.status());
12
    println!("{}", res.text().unwrap());
13
}

在这个示例中，我们使用 reqwest 设置请求超时和连接池超时。Hyper 0.10.x 的 keep_alive_timeout()/timeout().send().map()/tokio::run() 模式已废弃。

使用自定义 TLS 配置#

Hyper 支持使用自定义的 TLS 配置来发送 HTTPS 请求。下面是一个简单的示例，它使用 Hyper 发送一个带有自定义 TLS 配置的 HTTPS 请求并打印响应的内容：

1
use reqwest::blocking::Client;
2
use std::error::Error;
3
use std::path::Path;
4

5
fn main() -> Result<(), Box<dyn Error>> {
6
    let client = Client::builder()
7
        .add_root_certificate(reqwest::Certificate::from_pem(
8
            &std::fs::read(Path::new("cert.pem"))?,
9
        )?)
10
        .build()?;
11
    let res = client.get("https://example.com").send()?;
12
    println!("{}", res.status());
13
    println!("{}", res.text()?);
14
    Ok(())
15
}

展开收起

在这个示例中，我们使用 reqwest 加载自定义 TLS 证书。Hyper 0.10.x 的 hyper_tls::HttpsConnector::with_connector() 模式已废弃，现代 Rust 推荐使用 reqwest 的 add_root_certificate() 或 hyper-rustls。

最佳实践#

使用连接池提高性能

Hyper 提供了连接池的功能，可以有效地提高 HTTP 请求的性能。在实际开发中，我们应该尽可能地使用连接池来发送 HTTP 请求，以提高性能和减少资源消耗。

使用异步 I/O 提高并发性能

Hyper 使用异步 I/O 实现了高性能的 HTTP 客户端和服务器端，我们应该尽可能地使用异步 I/O 来提高并发性能。

使用 HTTPS 保证安全性

在发送 HTTP 请求时，我们应该尽可能地使用 HTTPS 来保证通信的安全性。Hyper 提供了对 HTTPS 的支持，可以轻松地实现 HTTPS 通信。

使用请求/响应拦截器进行处理

Hyper 提供了请求/响应拦截器的功能，可以对 HTTP 请求和响应进行处理。在实际开发中，我们应该尽可能地使用请求/响应拦截器来实现一些通用的处理逻辑，例如日志记录、错误处理等。

总结#

Hyper 是 Rust 语言中一个非常流行的 HTTP 客户端和服务器端开发库，它提供了一套简单易用的 API，可以轻松地构建高性能的 Web 应用程序。在本教程中，我们介绍了 Hyper 的基础用法和进阶用法，并提供了一些最佳实践和示例代码。希望这个教程能够帮助你更好地了解 Hyper，并在实际开发中使用它。

Rust语言从入门到精通系列 - 二进制自压缩序列化bincode模块

Sun, 23 Apr 2023 00:00:00 GMT

Bincode 是一个用于 Rust 语言的二进制编码库，用于将 Rust 结构体序列化为二进制格式，或者将二进制格式反序列化为 Rust 结构体。它支持大多数 Rust 原生类型和自定义类型，并且可以高效地处理大型数据结构。Bincode 还支持压缩和解压缩，以减小序列化后的数据大小。

基础用法#

序列化和反序列化一个简单的结构体#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Person {
5
    name: String,
6
    age: u8,
7
}
8

9
fn main() {
10
    let person = Person {
11
        name: "Alice".to_string(),
12
        age: 25,
13
    };
14

15
    // Serialize
16
    let encoded: Vec<u8> = serialize(&person).unwrap();
17

18
    // Deserialize
19
    let decoded: Person = deserialize(&encoded[..]).unwrap();
20

21
    assert_eq!(person, decoded);
22
}

展开收起

在这个示例中，我们定义了一个Person结构体，它有一个name字段和一个age字段。我们将其序列化为一个字节数组，然后将其反序列化回Person结构体，并将其与原始结构体进行比较。

序列化和反序列化一个嵌套结构体#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Address {
5
    street: String,
6
    city: String,
7
    zip: String,
8
}
9

10
#[derive(Serialize, Deserialize, Debug, PartialEq)]
11
struct Person {
12
    name: String,
13
    age: u8,
14
    address: Address,
15
}
16

17
fn main() {
18
    let person = Person {
19
        name: "Alice".to_string(),
20
        age: 25,
21
        address: Address {
22
            street: "123 Main St".to_string(),
23
            city: "Anytown".to_string(),
24
            zip: "12345".to_string(),
25
        },
26
    };
27

28
    // Serialize
29
    let encoded: Vec<u8> = serialize(&person).unwrap();
30

31
    // Deserialize
32
    let decoded: Person = deserialize(&encoded[..]).unwrap();
33

34
    assert_eq!(person, decoded);
35
}

展开收起

这个示例中，我们定义了一个Person结构体，它包含一个嵌套的Address结构体。我们将其序列化为一个字节数组，然后将其反序列化回Person结构体，并将其与原始结构体进行比较。

序列化和反序列化一个向量#

1
use bincode::{serialize, deserialize};
2

3
fn main() {
4
    let numbers = vec![1, 2, 3, 4, 5];
5

6
    // Serialize
7
    let encoded: Vec<u8> = serialize(&numbers).unwrap();
8

9
    // Deserialize
10
    let decoded: Vec<i32> = deserialize(&encoded[..]).unwrap();
11

12
    assert_eq!(numbers, decoded);
13
}

在这个示例中，我们定义了一个包含整数的向量。我们将其序列化为一个字节数组，然后将其反序列化回一个整数向量，并将其与原始向量进行比较。

序列化和反序列化一个哈希表#

1
use std::collections::HashMap;
2
use bincode::{serialize, deserialize};
3

4
fn main() {
5
    let mut map = HashMap::new();
6
    map.insert("Alice", 25);
7
    map.insert("Bob", 30);
8
    map.insert("Charlie", 35);
9

10
    // Serialize
11
    let encoded: Vec<u8> = serialize(&map).unwrap();
12

13
    // Deserialize
14
    let decoded: HashMap<&str, i32> = deserialize(&encoded[..]).unwrap();
15

16
    assert_eq!(map, decoded);
17
}

展开收起

在这个示例中，我们定义了一个包含键值对的哈希表。我们将其序列化为一个字节数组，然后将其反序列化回一个哈希表，并将其与原始哈希表进行比较。

序列化和反序列化一个枚举#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
enum Color {
5
    Red,
6
    Green,
7
    Blue,
8
}
9

10
fn main() {
11
    let color = Color::Green;
12

13
    // Serialize
14
    let encoded: Vec<u8> = serialize(&color).unwrap();
15

16
    // Deserialize
17
    let decoded: Color = deserialize(&encoded[..]).unwrap();
18

19
    assert_eq!(color, decoded);
20
}

展开收起

在这个示例中，我们定义了一个枚举类型Color，它有三个可能的值。我们将其序列化为一个字节数组，然后将其反序列化回一个Color枚举，并将其与原始枚举进行比较。

序列化和反序列化一个字符串#

1
use bincode::{serialize, deserialize};
2

3
fn main() {
4
    let message = "Hello, world!".to_string();
5

6
    // Serialize
7
    let encoded: Vec<u8> = serialize(&message).unwrap();
8

9
    // Deserialize
10
    let decoded: String = deserialize(&encoded[..]).unwrap();
11

12
    assert_eq!(message, decoded);
13
}

在这个示例中，我们定义了一个字符串。我们将其序列化为一个字节数组，然后将其反序列化回一个字符串，并将其与原始字符串进行比较。

压缩和解压缩序列化后的数据#

1
use bincode::{serialize, deserialize, config};
2
use flate2::{Compression, read::DeflateEncoder, write::DeflateDecoder};
3

4
fn main() {
5
    let numbers = vec![1, 2, 3, 4, 5];
6

7
    // Serialize
8
    let encoded: Vec<u8> = serialize(&numbers).unwrap();
9

10
    // Compress
11
    let mut compressed = Vec::new();
12
    let mut encoder = DeflateEncoder::new(&encoded[..], Compression::default());
13
    encoder.read_to_end(&mut compressed).unwrap();
14

15
    // Decompress
16
    let mut decompressed = Vec::new();
17
    let mut decoder = DeflateDecoder::new(&compressed[..]);
18
    decoder.read_to_end(&mut decompressed).unwrap();
19

20
    // Deserialize
21
    let decoded: Vec<i32> = deserialize(&decompressed[..]).unwrap();
22

23
    assert_eq!(numbers, decoded);
24
}

展开收起

在这个示例中，我们定义了一个包含整数的向量。我们将其序列化为一个字节数组，然后将其压缩为另一个字节数组。我们将压缩后的字节数组解压缩为另一个字节数组，然后将其反序列化回一个整数向量，并将其与原始向量进行比较。

使用自定义配置序列化和反序列化#

1
use bincode::{serialize_with, deserialize_from, config};
2
use std::io::{Cursor, Write};
3

4
#[derive(Debug, PartialEq)]
5
struct Person {
6
    name: String,
7
    age: u8,
8
}
9

10
fn main() {
11
    let person = Person {
12
        name: "Alice".to_string(),
13
        age: 25,
14
    };
15

16
    // Serialize
17
    let mut buffer = Cursor::new(Vec::new());
18
    serialize_with(&mut buffer, &person, config().big_endian()).unwrap();
19
    let encoded = buffer.into_inner();
20

21
    // Deserialize
22
    let mut cursor = Cursor::new(encoded);
23
    let decoded: Person = deserialize_from(&mut cursor, config().big_endian()).unwrap();
24

25
    assert_eq!(person, decoded);
26
}

展开收起

在这个示例中，我们定义了一个Person结构体，它有一个name字段和一个age字段。我们将其序列化为一个字节数组，并使用自定义配置将其编码为大端字节序。我们将编码后的字节数组反序列化回Person结构体，并使用相同的自定义配置来解码它。

进阶用法#

自定义序列化和反序列化#

1
use bincode::{serialize, deserialize, Error, ErrorKind};
2
use std::io::{Cursor, Write, Read};
3

4
#[derive(Debug, PartialEq)]
5
struct Person {
6
    name: String,
7
    age: u8,
8
}
9

10
impl Person {
11
    fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error> {
12
        let name_bytes = self.name.as_bytes();
13
        if name_bytes.len() > 255 {
14
            return Err(Error::new(ErrorKind::Custom("name too long".to_string())));
15
        }
16
        writer.write_all(&(name_bytes.len() as u8).to_le_bytes())?;
17
        writer.write_all(name_bytes)?;
18
        writer.write_all(&self.age.to_le_bytes())?;
19
        Ok(())
20
    }
21

22
    fn deserialize<R: Read>(reader: &mut R) -> Result<Self, Error> {
23
        let mut name_len_bytes = [0; 1];
24
        reader.read_exact(&mut name_len_bytes)?;
25
        let name_len = name_len_bytes[0] as usize;
26
        let mut name_bytes = vec![0; name_len];
27
        reader.read_exact(&mut name_bytes)?;
28
        let name = String::from_utf8(name_bytes)?;
29
        let mut age_bytes = [0; 1];
30
        reader.read_exact(&mut age_bytes)?;
31
        let age = age_bytes[0];
32
        Ok(Person { name, age })
33
    }
34
}
35

36
fn main() {
37
    let person = Person {
38
        name: "Alice".to_string(),
39
        age: 25,
40
    };
41

42
    // Serialize
43
    let mut buffer = Cursor::new(Vec::new());
44
    person.serialize(&mut buffer).unwrap();
45
    let encoded = buffer.into_inner();
46

47
    // Deserialize
48
    let mut cursor = Cursor::new(encoded);
49
    let decoded: Person = Person::deserialize(&mut cursor).unwrap();
50

51
    assert_eq!(person, decoded);
52
}

展开收起

在这个示例中，我们定义了一个Person结构体，并实现了自定义的序列化和反序列化方法。在序列化方法中，我们将名称长度编码为一个字节，然后将名称和年龄编码为字节数组。在反序列化方法中，我们首先读取名称长度字节，然后读取名称和年龄字节，并将它们解码为一个Person结构体。

自定义大小端序列化和反序列化#

1
use bincode::{serialize, deserialize, Error, ErrorKind};
2
use std::io::{Cursor, Write, Read};
3

4
#[derive(Debug, PartialEq)]
5
struct Person {
6
    name: String,
7
    age: u8,
8
}
9

10
impl Person {
11
    fn serialize<W: Write>(&self, writer: &mut W, big_endian: bool) -> Result<(), Error> {
12
        let name_bytes = self.name.as_bytes();
13
        if name_bytes.len() > 255 {
14
            return Err(Error::new(ErrorKind::Custom("name too long".to_string())));
15
        }
16
        let mut name_len_bytes = [0; 1];
17
        name_len_bytes[0] = name_bytes.len() as u8;
18
        if big_endian {
19
            writer.write_all(&name_len_bytes[..].reverse())?;
20
        } else {
21
            writer.write_all(&name_len_bytes[..])?;
22
        }
23
        writer.write_all(name_bytes)?;
24
        writer.write_all(&self.age.to_le_bytes())?;
25
        Ok(())
26
    }
27

28
    fn deserialize<R: Read>(reader: &mut R, big_endian: bool) -> Result<Self, Error> {
29
        let mut name_len_bytes = [0; 1];
30
        reader.read_exact(&mut name_len_bytes)?;
31
        let name_len = if big_endian {
32
            u8::from_be_bytes(name_len_bytes)
33
        } else {
34
            u8::from_le_bytes(name_len_bytes)
35
        } as usize;
36
        let mut name_bytes = vec![0; name_len];
37
        reader.read_exact(&mut name_bytes)?;
38
        let name = String::from_utf8(name_bytes)?;
39
        let mut age_bytes = [0; 1];
40
        reader.read_exact(&mut age_bytes)?;
41
        let age = age_bytes[0];
42
        Ok(Person { name, age })
43
    }
44
}
45

46
fn main() {
47
    let person = Person {
48
        name: "Alice".to_string(),
49
        age: 25,
50
    };
51

52
    // Serialize
53
    let mut buffer = Cursor::new(Vec::new());
54
    person.serialize(&mut buffer, true).unwrap();
55
    let encoded = buffer.into_inner();
56

57
    // Deserialize
58
    let mut cursor = Cursor::new(encoded);
59
    let decoded: Person = Person::deserialize(&mut cursor, true).unwrap();
60

61
    assert_eq!(person, decoded);
62
}

展开收起

在这个示例中，我们定义了一个Person结构体，并实现了自定义的大小端序列化和反序列化方法。在序列化方法中，我们将名称长度编码为一个字节，并根据big_endian参数决定字节序。在反序列化方法中，我们首先读取名称长度字节，并根据big_endian参数解码字节序。然后，我们读取名称和年龄字节，并将它们解码为一个Person结构体。

序列化和反序列化一个动态数组#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Person {
5
    name: String,
6
    age: u8,
7
}
8

9
fn main() {
10
    let people = vec![
11
        Person {
12
            name: "Alice".to_string(),
13
            age: 25,
14
        },
15
        Person {
16
            name: "Bob".to_string(),
17
            age: 30,
18
        },
19
        Person {
20
            name: "Charlie".to_string(),
21
            age: 35,
22
        },
23
    ];
24

25
    // Serialize
26
    let encoded: Vec<u8> = serialize(&people).unwrap();
27

28
    // Deserialize
29
    let decoded: Vec<Person> = deserialize(&encoded[..]).unwrap();
30

31
    assert_eq!(people, decoded);
32
}

展开收起

在这个示例中，我们定义了一个包含Person结构体的动态数组。我们将其序列化为一个字节数组，然后将其反序列化回一个Person结构体的动态数组，并将其与原始数组进行比较。

序列化和反序列化一个结构体的子集#

1
use bincode::{serialize, deserialize};
2

3
#[derive(Serialize, Deserialize, Debug, PartialEq)]
4
struct Person {
5
    name: String,
6
    age: u8,
7
    address: String,
8
}
9

10
#[derive(Serialize, Deserialize, Debug, PartialEq)]
11
struct PersonSubset {
12
    name: String,
13
    age: u8,
14
}
15

16
fn main() {
17
    let person = Person {
18
        name: "Alice".to_string(),
19
        age: 25,
20
        address: "123 Main St".to_string(),
21
    };
22

23
    // Serialize subset
24
    let encoded: Vec<u8> = serialize(&PersonSubset {
25
        name: person.name.clone(),
26
        age: person.age,
27
    })
28
    .unwrap();
29

30
    // Deserialize subset
31
    let decoded: PersonSubset = deserialize(&encoded[..]).unwrap();
32

33
    assert_eq!(
34
        decoded,
35
        PersonSubset {
36
            name: "Alice".to_string(),
37
            age: 25
38
        }
39
    );
40

41
    // Deserialize full struct from subset bytes
42
    let decoded_full: Person = deserialize(&encoded[..]).unwrap();
43
    assert_eq!(
44
        decoded_full,
45
        Person {
46
            name: "Alice".to_string(),
47
            age: 25,
48
            address: "".to_string()
49
        }
50
    );
51

52
    // Serialize full struct to subset bytes
53
    let encoded_subset: Vec<u8> = serialize(&PersonSubset {
54
        name: person.name.clone(),
55
        age: person.age,
56
    })
57
    .unwrap();
58
    assert_eq!(encoded, encoded_subset);
59
}

展开收起

在这个示例中，我们定义了一个Person结构体，它有一个name字段、一个age字段和一个address字段。我们将其序列化为一个字节数组，然后将其反序列化回一个PersonSubset结构体的字节数组，该结构体只包含name和age字段。我们还演示了如何从子集字节数组反序列化回完整的结构体，以及如何将完整的结构体序列化为子集字节数组。

使用自定义配置#

在某些情况下，您可能需要使用自定义配置来序列化和反序列化数据。例如，您可能需要使用大端字节序而不是默认的小端字节序。您可以使用bincode::config()函数创建一个默认配置，然后使用bincode::serialize_with()和bincode::deserialize_from()函数序列化和反序列化数据。例如：

1
use bincode::{serialize_with, deserialize_from, config};
2
use std::io::{Cursor, Write};
3

4
let person = Person {
5
    name: "Alice".to_string(),
6
    age: 25,
7
};
8

9
// Serialize with big endian byte order
10
let mut buffer = Cursor::new(Vec::new());
11
serialize_with(&mut buffer, &person, config().big_endian()).unwrap();
12
let encoded = buffer.into_inner();
13

14
// Deserialize with big endian byte order
15
let mut cursor = Cursor::new(encoded);
16
let decoded: Person = deserialize_from(&mut cursor, config().big_endian()).unwrap();

展开收起

优化序列化和反序列化性能#

为了优化序列化和反序列化性能，可以使用bincode::config模块中的DefaultOptions和Options结构体，调整序列化和反序列化的选项。以下是一个优化性能的示例：

1
use bincode::{serialize_with_options, deserialize_with_options, DefaultOptions};
2

3
// 优化性能
4
let mut options = DefaultOptions::new();
5
options.limit = bincode::Bounded(1024); // 限制序列化和反序列化的最大字节数
6
let data = vec![0; 1024 * 1024 * 1024]; // 1GB数据
7

8
// 序列化大数据量
9
let encoded: Vec<u8> = serialize_with_options(&data, options).unwrap();
10

11
// 反序列化大数据量
12
let decoded: Vec<u8> = deserialize_with_options(&encoded[..], options).unwrap();

处理序列化和反序列化错误#

在序列化和反序列化过程中，可能会出现错误。为了处理这些错误，可以使用Result类型和bincode::Error枚举类型。以下是一个处理错误的示例：

1
use bincode::{serialize, deserialize, Error};
2

3
// 处理错误
4
let num = "abc";
5
let encoded: Result<Vec<u8>, Error> = serialize(&num);
6
match encoded {
7
    Ok(v) => println!("Encoded: {:?}", v),
8
    Err(e) => println!("Error: {:?}", e),
9
}
10

11
let encoded = vec![1, 2, 3];
12
let decoded: Result<String, Error> = deserialize(&encoded[..]);
13
match decoded {
14
    Ok(v) => println!("Decoded: {:?}", v),
15
    Err(e) => println!("Error: {:?}", e),
16
}

展开收起

总结#

Bincode 是 Rust 语言中的一个二进制编码库，可以将 Rust 的数据结构序列化为二进制格式，以便于存储和传输。使用 Bincode 可以方便地将数据序列化为二进制格式，也可以反序列化二进制数据为 Rust 数据结构。Bincode 支持大部分 Rust 的数据类型，包括基本类型、结构体、枚举、数组、元组等。在序列化和反序列化过程中，Bincode 会自动进行类型检查和字节对齐，保证数据的正确性和兼容性。同时，Bincode 还支持自定义序列化和反序列化方法，以满足特殊需求。为了优化序列化和反序列化性能，可以使用bincode::config模块中的DefaultOptions和Options结构体，调整序列化和反序列化的选项。在序列化和反序列化过程中，可能会出现错误，可以使用Result类型和bincode::Error枚举类型来处理这些错误。

Rust语言从入门到精通系列 - 主打安全隐私的虚拟文件系统zbox

Sun, 23 Apr 2023 00:00:00 GMT

<<<<<<< Updated upstream zbox 是一个基于 Rust 语言的轻量级分布式存储库，它提供了高效、安全、可靠的数据存储和访问。zbox 的设计目的是提供简单易用的 API，使得开发者能够快速构建分布式存储系统。zbox 采用了 Zero-copy、Copy-on-write、引用计数等技术，使得数据访问更加高效。#

zbox是一个基于Rust语言的轻量级分布式存储库，它提供了高效、安全、可靠的数据存储和访问。zbox的设计目的是提供简单易用的API，使得开发者能够快速构建分布式存储系统。zbox采用了Zero-copy、Copy-on-write、引用计数等技术，使得数据访问更加高效。

Stashed changes

基础用法#

安装#

在使用 zbox 之前，需要先安装 Rust 编程语言。可以通过以下命令安装：

Terminal window

1
curl https://sh.rustup.rs -sSf | sh

安装完成后，需要在终端运行以下命令安装 zbox：

Terminal window

1
cargo install zbox

初始化#

在使用 zbox 之前，需要先初始化 zbox 库。可以通过以下代码实现：

1
use zbox::{init_env, RepoOpener};
2

3
fn main() {
4
    // 初始化zbox库
5
    init_env();
6

7
    // 打开或创建存储库
8
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
9
}

创建文件#

可以通过以下代码创建一个文件：

1
use std::io::Write;
2
use zbox::{init_env, RepoOpener};
3

4
fn main() {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
10

11
    // 创建文件
12
    let mut file = repo.create_file("/my_file.txt").unwrap();
13

14
    // 写入数据
15
    file.write_all(b"Hello, world!").unwrap();
16
}

展开收起

读取文件#

可以通过以下代码读取一个文件：

1
use std::io::Read;
2
use zbox::{init_env, RepoOpener};
3

4
fn main() {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
10

11
    // 打开文件
12
    let mut file = repo.open_file("/my_file.txt").unwrap();
13

14
    // 读取数据
15
    let mut buf = Vec::new();
16
    file.read_to_end(&mut buf).unwrap();
17

18
    println!("{}", String::from_utf8_lossy(&buf));
19
}

展开收起

创建目录#

可以通过以下代码创建一个目录：

1
use zbox::{init_env, RepoOpener};
2

3
fn main() {
4
    // 初始化zbox库
5
    init_env();
6

7
    // 打开或创建存储库
8
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
9

10
    // 创建目录
11
    repo.create_dir("/my_dir").unwrap();
12
}

列出目录#

可以通过以下代码列出一个目录下的所有文件和目录：

1
use zbox::{init_env, RepoOpener};
2

3
fn main() {
4
    // 初始化zbox库
5
    init_env();
6

7
    // 打开或创建存储库
8
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
9

10
    // 列出目录
11
    let entries = repo.read_dir("/").unwrap();
12
    for entry in entries {
13
        println!("{}", entry.path().display());
14
    }
15
}

展开收起

删除文件或目录#

可以通过以下代码删除一个文件或目录：

1
use zbox::{init_env, RepoOpener};
2

3
fn main() {
4
    // 初始化zbox库
5
    init_env();
6

7
    // 打开或创建存储库
8
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
9

10
    // 删除文件
11
    repo.remove_file("/my_file.txt").unwrap();
12

13
    // 删除目录
14
    repo.remove_dir("/my_dir").unwrap();
15
}

展开收起

复制文件或目录#

可以通过以下代码复制一个文件或目录：

1
use zbox::{init_env, RepoOpener};
2

3
fn main() {
4
    // 初始化zbox库
5
    init_env();
6

7
    // 打开或创建存储库
8
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
9

10
    // 复制文件
11
    repo.copy_file("/my_file.txt", "/my_file_copy.txt").unwrap();
12

13
    // 复制目录
14
    repo.copy_dir("/my_dir", "/my_dir_copy").unwrap();
15
}

展开收起

移动文件或目录#

可以通过以下代码移动一个文件或目录：

1
use zbox::{init_env, RepoOpener};
2

3
fn main() {
4
    // 初始化zbox库
5
    init_env();
6

7
    // 打开或创建存储库
8
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
9

10
    // 移动文件
11
    repo.rename("/my_file.txt", "/my_file_new.txt").unwrap();
12

13
    // 移动目录
14
    repo.rename("/my_dir", "/my_dir_new").unwrap();
15
}

展开收起

进阶用法#

文件加密#

可以通过以下代码将一个文件加密：

1
use std::io::Write;
2
use zbox::{init_env, RepoOpener, OpenOptions};
3

4
fn main() {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
10

11
    // 创建加密文件
12
    let mut options = OpenOptions::new();
13
    options.create(true).encrypt(true);
14
    let mut file = repo.open_file_with_options("/my_file.txt", &options).unwrap();
15

16
    // 写入数据
17
    file.write_all(b"Hello, world!").unwrap();
18
}

展开收起

文件版本控制#

可以通过以下代码实现文件版本控制：

1
use std::io::Write;
2
use zbox::{init_env, RepoOpener, OpenOptions};
3

4
fn main() {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
10

11
    // 创建加密文件
12
    let mut options = OpenOptions::new();
13
    options.create(true).version_limit(10);
14
    let mut file = repo.open_file_with_options("/my_file.txt", &options).unwrap();
15

16
    // 写入数据
17
    file.write_all(b"Hello, world!").unwrap();
18

19
    // 写入新版本
20
    file.write_all(b"Hello, Rust!").unwrap();
21
}

展开收起

文件共享#

可以通过以下代码实现文件共享：

1
use std::io::Write;
2
use zbox::{init_env, RepoOpener, OpenOptions};
3

4
fn main() {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
10

11
    // 创建加密文件
12
    let mut options = OpenOptions::new();
13
    options.create(true).share(true);
14
    let mut file = repo.open_file_with_options("/my_file.txt", &options).unwrap();
15

16
    // 写入数据
17
    file.write_all(b"Hello, world!").unwrap();
18
}

展开收起

文件缓存#

可以通过以下代码实现文件缓存：

1
use std::io::Write;
2
use zbox::{init_env, RepoOpener, OpenOptions};
3

4
fn main() {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo").unwrap();
10

11
    // 创建加密文件
12
    let mut options = OpenOptions::new();
13
    options.create(true).cache_size(1024);
14
    let mut file = repo.open_file_with_options("/my_file.txt", &options).unwrap();
15

16
    // 写入数据
17
    file.write_all(b"Hello, world!").unwrap();
18
}

展开收起

最佳实践#

多线程使用#

在多线程环境下使用 zbox，需要使用线程安全的 Repo 对象。可以通过以下代码实现：

1
use std::sync::{Arc, RwLock};
2
use zbox::{init_env, RepoOpener};
3

4
fn main() {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = Arc::new(RwLock::new(RepoOpener::new().create(true).open("zbox://./my_repo").unwrap()));
10

11
    // 多线程使用repo
12
    {
13
        let repo = repo.read().unwrap();
14
        let mut file = repo.create_file("/my_file.txt").unwrap();
15
        file.write_all(b"Hello, world!").unwrap();
16
    }
17

18
    {
19
        let repo = repo.read().unwrap();
20
        let mut file = repo.open_file("/my_file.txt").unwrap();
21
        let mut buf = Vec::new();
22
        file.read_to_end(&mut buf).unwrap();
23
        println!("{}", String::from_utf8_lossy(&buf));
24
    }
25
}

展开收起

错误处理#

在使用 zbox 时，需要注意错误处理。可以通过以下代码实现：

1
use std::io::{Read, Write};
2
use zbox::{Error, init_env, RepoOpener};
3

4
fn main() -> Result<(), Error> {
5
    // 初始化zbox库
6
    init_env();
7

8
    // 打开或创建存储库
9
    let repo = RepoOpener::new().create(true).open("zbox://./my_repo")?;
10

11
    // 创建文件
12
    let mut file = repo.create_file("/my_file.txt")?;
13

14
    // 写入数据
15
    file.write_all(b"Hello, world!")?;
16

17
    // 读取数据
18
    let mut buf = Vec::new();
19
    file.read_to_end(&mut buf)?;
20

21
    println!("{}", String::from_utf8_lossy(&buf));
22

23
    Ok(())
24
}

展开收起

性能优化#

在使用 zbox 时，可以通过以下方法进行性能优化：

使用 Zero-copy 技术，避免不必要的内存拷贝；
使用 Copy-on-write 技术，避免不必要的数据复制；
使用引用计数技术，避免不必要的内存分配和释放；
使用缓存技术，加快数据访问速度。

总结#

本教程介绍了 Rust 语言 zbox 模块的基础用法和进阶用法，并提供了最佳实践。zbox 是一个高效、安全、可靠的分布式存储库，可以帮助开发者快速构建分布式存储系统。在使用 zbox 时，需要注意错误处理和性能优化。

Rust语言从入门到精通系列 - 深入理解image图片处理模块

Sun, 23 Apr 2023 00:00:00 GMT

Rust 是一种内存安全和并发性强的编程语言，它被广泛应用于系统编程、Web 开发、游戏开发等领域。而 image 模块则是 Rust 语言中用于图像处理的库，它提供了丰富的图像处理功能，包括图像读取、写入、缩放、裁剪、旋转等等。

在本教程中，我们将介绍 Rust 语言中的 image 模块，并提供基础用法和进阶用法的示例，帮助读者了解如何使用这个强大的图像处理库。

基础用法#

1. 读取图像#

使用 image 模块可以很方便地读取图像文件。下面是一个简单的示例：

1
use image::GenericImageView;
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    println!("Image dimensions: {:?}", img.dimensions());
6
}

这个示例中，我们使用image::open函数来打开一个名为test.png的图像文件，并使用unwrap方法来处理可能的错误。然后，我们调用dimensions方法来获取图像的尺寸信息。

2. 写入图像#

同样，使用 image 模块也可以很方便地写入图像文件。下面是一个简单的示例：

1
use image::GenericImageView;
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let _ = img.save("output.png");
6
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用save方法将图像写入名为output.png的文件中。

3. 裁剪图像#

使用 image 模块可以很方便地裁剪图像。下面是一个简单的示例：

1
use image::GenericImageView;
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let cropped = img.crop(10, 10, 100, 100);
6
    let _ = cropped.save("output.png");
7
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用crop方法来裁剪图像，该方法接受四个参数：左上角的 x 坐标、y 坐标、裁剪区域的宽度和高度。最后，我们将裁剪后的图像写入名为output.png的文件中。

4. 缩放图像#

使用 image 模块可以很方便地缩放图像。下面是一个简单的示例：

1
use image::GenericImageView;
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let scaled = img.resize(200, 200, image::imageops::FilterType::Lanczos3);
6
    let _ = scaled.save("output.png");
7
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用resize方法来缩放图像，该方法接受三个参数：缩放后的宽度、高度和缩放算法。最后，我们将缩放后的图像写入名为output.png的文件中。

5. 旋转图像#

使用 image 模块可以很方便地旋转图像。下面是一个简单的示例：

1
use image::GenericImageView;
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let rotated = img.rotate90();
6
    let _ = rotated.save("output.png");
7
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用rotate90方法来将图像逆时针旋转 90 度。最后，我们将旋转后的图像写入名为output.png的文件中。

6. 转换图像格式#

使用 image 模块可以很方便地转换图像格式。下面是一个简单的示例：

1
use image::GenericImageView;
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let converted = img.into_rgba();
6
    let _ = converted.save("output.png");
7
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用into_rgba方法将图像转换为 RGBA 格式。最后，我们将转换后的图像写入名为output.png的文件中。

7. 操作像素#

使用 image 模块可以很方便地操作图像像素。下面是一个简单的示例：

1
use image::{GenericImageView, RgbaImage};
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let mut rgba_img = img.to_rgba();
6
    for (_x, _y, pixel) in rgba_img.enumerate_pixels_mut() {
7
        let (r, g, b, a) = pixel.channels();
8
        let gray = (0.3 * r as f32 + 0.59 * g as f32 + 0.11 * b as f32) as u8;
9
        *pixel = image::Rgba([gray, gray, gray, a]);
10
    }
11
    let _ = rgba_img.save("output.png");
12
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用to_rgba方法将图像转换为 RGBA 格式，并使用pixels_mut方法获取图像像素的可变引用。接着，我们遍历每个像素，并将其转换为灰度图像。最后，我们将转换后的图像写入名为output.png的文件中。

8. 绘制图像#

使用 image 模块可以很方便地绘制图像。下面是一个简单的示例：

1
use image::{GenericImageView, RgbaImage, Rgba};
2

3
fn main() {
4
    let mut img = RgbaImage::new(200, 200);
5
    for x in 0..200 {
6
        for y in 0..200 {
7
            let r = (x as f32 / 200.0 * 255.0) as u8;
8
            let g = (y as f32 / 200.0 * 255.0) as u8;
9
            let b = ((x + y) as f32 / 400.0 * 255.0) as u8;
10
            img.put_pixel(x, y, Rgba([r, g, b, 255]));
11
        }
12
    }
13
    let _ = img.save("output.png");
14
}

这个示例中，我们首先创建一个 200x200 的 RGBA 图像。然后，我们遍历每个像素，并计算其颜色值。最后，我们使用put_pixel方法将像素绘制到图像上，并将图像写入名为output.png的文件中。

进阶用法#

1. 模糊图像#

使用 image 模块可以很方便地对图像进行模糊处理。下面是一个简单的示例：

1
use image::{GenericImageView, DynamicImage};
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let blurred = img.blur(5.0);
6
    let _ = blurred.save("output.png");
7
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用blur方法对图像进行模糊处理，该方法接受一个参数，表示模糊半径。最后，我们将模糊后的图像写入名为output.png的文件中。

2. 图像直方图均衡化#

使用 image 模块可以很方便地对图像进行直方图均衡化。下面是一个简单的示例：

1
use image::{GenericImageView, DynamicImage};
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let equalized = img.equalize();
6
    let _ = equalized.save("output.png");
7
}

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用equalize方法对图像进行直方图均衡化。最后，我们将均衡化后的图像写入名为output.png的文件中。

3. 图像二值化#

使用 image 模块可以很方便地对图像进行二值化处理。下面是一个简单的示例：

1
use image::{GenericImageView, DynamicImage, GrayImage};
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let gray = img.to_luma();
6
    let threshold = 128;
7
    let mut binary = GrayImage::new(gray.width(), gray.height());
8
    for (x, y, pixel) in binary.enumerate_pixels_mut() {
9
        let value = gray.get_pixel(x, y)[0];
10
        if value > threshold {
11
            *pixel = image::Luma([255]);
12
        } else {
13
            *pixel = image::Luma([0]);
14
        }
15
    }
16
    let _ = binary.save("output.png");
17
}

展开收起

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用to_luma方法将图像转换为灰度图像。接着，我们指定一个阈值，并遍历每个像素，将其转换为二值图像。最后，我们将二值化后的图像写入名为output.png的文件中。

4. 图像插值#

使用 image 模块可以很方便地对图像进行插值处理。下面是一个简单的示例：

1
use image::{GenericImageView, DynamicImage, RgbaImage, imageops};
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let scaled = imageops::resize(&img, 200, 200, imageops::FilterType::Lanczos3);
6
    let mut interpolated = RgbaImage::new(400, 400);
7
    for x in 0..400 {
8
        for y in 0..400 {
9
            let u = x as f32 / 2.0;
10
            let v = y as f32 / 2.0;
11
            let pixel = scaled.get_pixel(u as u32, v as u32);
12
            interpolated.put_pixel(x, y, *pixel);
13
        }
14
    }
15
    let _ = interpolated.save("output.png");
16
}

展开收起

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用resize方法将图像缩放为 200x200 的大小。接着，我们创建一个 400x400 的 RGBA 图像，并遍历每个像素。对于每个像素，我们使用插值方法从缩放后的图像中获取其颜色值，并将其绘制到新的图像中。最后，我们将插值后的图像写入名为output.png的文件中。

最佳实践#

在使用 image 模块时，我们需要注意以下几点：

需要处理可能的错误，如文件读写错误、图像格式错误等等。
需要注意图像的尺寸和格式，以便正确地使用各种图像处理方法。
需要注意图像的像素类型和通道顺序，以便正确地操作像素。
需要选择合适的图像处理方法和参数，以便达到预期的处理效果。

下面是一个综合示例，演示了如何使用 image 模块对图像进行灰度化、二值化、插值和保存：

1
use image::{GenericImageView, DynamicImage, RgbaImage, GrayImage, imageops};
2

3
fn main() {
4
    let img = image::open("test.png").unwrap();
5
    let gray = img.to_luma();
6
    let threshold = 128;
7
    let mut binary = GrayImage::new(gray.width(), gray.height());
8
    for (x, y, pixel) in binary.enumerate_pixels_mut() {
9
        let value = gray.get_pixel(x, y)[0];
10
        if value > threshold {
11
            *pixel = image::Luma([255]);
12
        } else {
13
            *pixel = image::Luma([0]);
14
        }
15
    }
16
    let scaled = imageops::resize(&img, 200, 200, imageops::FilterType::Lanczos3);
17
    let mut interpolated = RgbaImage::new(400, 400);
18
    for x in 0..400 {
19
        for y in 0..400 {
20
            let u = x as f32 / 2.0;
21
            let v = y as f32 / 2.0;
22
            let pixel = scaled.get_pixel(u as u32, v as u32);
23
            interpolated.put_pixel(x, y, *pixel);
24
        }
25
    }
26
    let _ = interpolated.save("output.png");
27
}

展开收起

这个示例中，我们首先使用image::open函数打开一个名为test.png的图像文件。然后，我们调用to_luma方法将图像转换为灰度图像。接着，我们指定一个阈值，并遍历每个像素，将其转换为二值图像。然后，我们使用resize方法将图像缩放为 200x200 的大小。接着，我们创建一个 400x400 的 RGBA 图像，并遍历每个像素。对于每个像素，我们使用插值方法从缩放后的图像中获取其颜色值，并将其绘制到新的图像中。最后，我们将插值后的图像写入名为output.png的文件中。

总结#

在本教程中，我们介绍了 Rust 语言中的 image 模块，并提供了基础用法和进阶用法的示例。我们还讨论了使用 image 模块的最佳实践。希望本教程能够帮助读者掌握使用这个强大的图像处理库的技巧。

Rust语言从入门到精通系列 - 零基础入门Win32 API开发(上)

Fri, 21 Apr 2023 00:00:00 GMT

Rust 语言是一种快速、安全、并发的系统编程语言。它的设计目标是为了提供更好的内存安全和线程安全，同时保持高性能。而 winapi 模块则是 Rust 语言的一个重要组成部分，它提供了与 Windows 操作系统 API 的交互能力。本教程将介绍 winapi 模块的基础用法和进阶用法，以及最佳实践。

本篇主要介绍 Win32 API 基础用法，进阶相关的内容在 Rust语言从入门到精通系列 - 零基础入门Win32 API开发(下)

基础用法#

Cargo.toml 文件引入依赖。

1
[target.'cfg(windows)'.dependencies]
2
winapi = { version = "0.3.9", features = ["winuser"] }

获取系统错误信息#

1
use winapi::um::errhandlingapi::GetLastError;
2

3
fn main() {
4
    let error_code = unsafe { GetLastError() };
5
    println!("Error code: {}", error_code);
6
}

获取桌面窗口句柄#

1
use winapi::um::winuser::GetDesktopWindow;
2
use winapi::um::winuser::HWND;
3

4
fn main() {
5
    let hwnd: HWND = unsafe { GetDesktopWindow() };
6
    println!("{:?}", hwnd);
7
}

在代码中，使用 GetDesktopWindow 函数获取桌面窗口句柄。使用 unsafe 关键字调用该函数，因为该函数是一个裸指针函数，需要手动管理内存安全。

创建窗口#

1
use std::ptr::null_mut;
2
use winapi::um::winuser::{CreateWindowExW, DefWindowProcW, RegisterClassW, CW_USEDEFAULT, MSG, WM_DESTROY, WNDCLASSW};
3

4
fn main() {
5
    let class_name = "MyWindowClass".to_wide_null();
6
    let window_name = "My Window".to_wide_null();
7
    let h_instance = unsafe { winapi::um::libloaderapi::GetModuleHandleW(null_mut()) };
8
    let wnd_class = WNDCLASSW {
9
        style: 0,
10
        lpfnWndProc: Some(DefWindowProcW),
11
        hInstance: h_instance,
12
        lpszClassName: class_name.as_ptr(),
13
        cbClsExtra: 0,
14
        cbWndExtra: 0,
15
        hIcon: null_mut(),
16
        hCursor: null_mut(),
17
        hbrBackground: null_mut(),
18
        lpszMenuName: null_mut(),
19
    };
20
    let class_atom = unsafe { RegisterClassW(&wnd_class) };
21
    let hwnd = unsafe {
22
        CreateWindowExW(
23
            0,
24
            class_atom as *const _,
25
            window_name.as_ptr(),
26
            0,
27
            CW_USEDEFAULT,
28
            CW_USEDEFAULT,
29
            CW_USEDEFAULT,
30
            CW_USEDEFAULT,
31
            null_mut(),
32
            null_mut(),
33
            h_instance,
34
            null_mut(),
35
        )
36
    };
37
    let mut msg = MSG::default();
38
    loop {
39
        let ret = unsafe { winapi::um::winuser::GetMessageW(&mut msg, null_mut(), 0, 0) };
40
        if ret > 0 {
41
            unsafe {
42
                winapi::um::winuser::TranslateMessage(&msg);
43
                winapi::um::winuser::DispatchMessageW(&msg);
44
            }
45
        } else {
46
            break;
47
        }
48
    }
49
}

展开收起

打开文件对话框#

1
use std::ptr::null_mut;
2
use winapi::um::commdlg::{GetOpenFileNameW, OPENFILENAMEW};
3
use winapi::um::winuser::HWND;
4

5
fn main() {
6
    let mut ofn = OPENFILENAMEW {
7
        lStructSize: std::mem::size_of::<OPENFILENAMEW>() as u32,
8
        hwndOwner: HWND(null_mut()),
9
        lpstrFilter: "Text Files\0*.txt\0All Files\0*.*\0\0".to_wide_null().as_ptr(),
10
        lpstrFile: [0; 260].as_mut_ptr(),
11
        nMaxFile: 260,
12
        Flags: 0,
13
        lpstrDefExt: "txt\0".to_wide_null().as_ptr(),
14
        ..Default::default()
15
    };
16
    let ret = unsafe { GetOpenFileNameW(&mut ofn) };
17
    if ret != 0 {
18
        let file_name = ofn.lpstrFile.to_string_lossy();
19
        println!("Selected file: {}", file_name);
20
    }
21
}

展开收起

读取注册表#

1
use std::ptr::null_mut;
2
use winapi::um::winreg::{RegCloseKey, RegOpenKeyExW, HKEY_LOCAL_MACHINE, KEY_READ, LPDWORD, REG_SZ};
3
use widestring::U16CString;
4

5
fn main() {
6
    let sub_key = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion".to_wide_null();
7
    let mut h_key = null_mut();
8
    let ret = unsafe { RegOpenKeyExW(HKEY_LOCAL_MACHINE, sub_key.as_ptr(), 0, KEY_READ, &mut h_key) };
9
    if ret == 0 {
10
        let mut buffer = [0u16; 1024];
11
        let mut buffer_size = (buffer.len() * 2) as u32;
12
        let mut value_type = REG_SZ;
13
        let ret = unsafe {
14
            winapi::um::winreg::RegQueryValueExW(
15
                h_key,
16
                "ProductName".to_wide_null().as_ptr(),
17
                null_mut(),
18
                &mut value_type,
19
                buffer.as_mut_ptr() as *mut _,
20
                &mut buffer_size,
21
            )
22
        };
23
        if ret == 0 {
24
            let value = U16CString::from_vec_with_nul(&buffer[..(buffer_size as usize)]).unwrap();
25
            println!("Product name: {}", value.to_string_lossy());
26
        }
27
        unsafe { RegCloseKey(h_key) };
28
    }
29
}

展开收起

注册热键#

1
use winapi::um::winuser::{RegisterHotKey, UnregisterHotKey};
2
use winapi::um::winuser::{HWND, WM_HOTKEY};
3

4
fn main() {
5
    let hwnd: HWND = std::ptr::null_mut();
6
    let id: i32 = 1;
7
    let modifiers: u32 = 0x0002; // MOD_CONTROL
8
    let vk: u32 = 0x43; // 'C'
9
    let result: i32 = unsafe { RegisterHotKey(hwnd, id, modifiers, vk) };
10
    if result == 0 {
11
        println!("Failed to register hotkey.");
12
        return;
13
    }
14
    loop {
15
        let mut msg = std::mem::zeroed();
16
        let result = unsafe { winapi::um::winuser::GetMessageW(&mut msg, hwnd, 0, 0) };
17
        if result == -1 {
18
            println!("Failed to get message.");
19
            break;
20
        }
21
        if msg.message == WM_HOTKEY {
22
            println!("Hotkey pressed.");
23
            break;
24
        }
25
        unsafe { winapi::um::winuser::TranslateMessage(&msg) };
26
        unsafe { winapi::um::winuser::DispatchMessageW(&msg) };
27
    }
28
    unsafe { UnregisterHotKey(hwnd, id) };
29
}

展开收起

在代码中，使用 RegisterHotKey 函数注册一个热键，当用户按下 Ctrl+C 时，会收到 WM_HOTKEY 消息。使用 GetMessageW 函数获取消息，使用 TranslateMessage 函数翻译消息，使用 DispatchMessageW 函数分发消息。使用 UnregisterHotKey 函数注销热键。

创建进程#

在 Windows 系统中，可以使用 CreateProcess 函数创建一个进程。使用 winapi 模块可以方便地调用 CreateProcess 函数。

1
use winapi::um::processthreadsapi::CreateProcessA;
2
use winapi::um::winbase::CREATE_NEW_CONSOLE;
3
use winapi::um::winnt::{PROCESS_INFORMATION, STARTUPINFOA};
4
use std::ffi::CString;
5
use std::mem::{size_of, zeroed};
6
use std::ptr::null_mut;
7

8
fn main() {
9
    let command_line = CString::new("notepad.exe").unwrap();
10
    let mut startup_info: STARTUPINFOA = unsafe { zeroed() };
11
    startup_info.cb = size_of::<STARTUPINFOA>() as u32;
12
    let mut process_info: PROCESS_INFORMATION = unsafe { zeroed() };
13
    let result = unsafe {
14
        CreateProcessA(
15
            null_mut(),
16
            command_line.as_ptr() as *mut _,
17
            null_mut(),
18
            null_mut(),
19
            0,
20
            CREATE_NEW_CONSOLE,
21
            null_mut(),
22
            null_mut(),
23
            &mut startup_info,
24
            &mut process_info,
25
        )
26
    };
27
    if result == 0 {
28
        println!("Failed to create process");
29
    } else {
30
        println!("Process created successfully");
31
    }
32
}

展开收起

上述代码中，首先使用 CString 将字符串转换为 C 类型的字符串，然后使用 CreateProcessA 函数创建进程。CreateProcessA 函数的第一个参数是可执行文件的路径，第二个参数是命令行参数，第三个参数是进程的安全属性，第四个参数是主线程的安全属性，第五个参数是是否继承句柄，第六个参数是创建进程的标志，第七个参数是环境变量，第八个参数是当前目录，第九个参数是启动信息，第十个参数是进程信息。在这个示例中，使用了 null_mut()表示不设置进程和主线程的安全属性，使用了 CREATE_NEW_CONSOLE 表示创建一个新的控制台窗口。如果 CreateProcessA 函数返回 0，则说明创建进程失败。否则，创建进程成功。

创建线程#

1
use std::ptr::null_mut;
2
use std::thread;
3
use winapi::um::processthreadsapi::{CreateThread, GetCurrentThreadId, GetExitCodeThread, TerminateThread};
4
use winapi::um::synchapi::WaitForSingleObject;
5
use winapi::um::winbase::{INFINITE, WAIT_OBJECT_0};
6

7
fn thread_proc() -> u32 {
8
    println!("Thread ID: {}", unsafe { GetCurrentThreadId() });
9
    0
10
}
11

12
fn main() {
13
    let handle = unsafe { CreateThread(null_mut(), 0, Some(thread_proc), null_mut(), 0, null_mut()) };
14
    let ret = unsafe { WaitForSingleObject(handle, INFINITE) };
15
    if ret == WAIT_OBJECT_0 {
16
        let mut exit_code = 0;
17
        unsafe { GetExitCodeThread(handle, &mut exit_code) };
18
        println!("Exit code: {}", exit_code);
19
    }
20
    unsafe { TerminateThread(handle, 0) };
21
}

展开收起

创建共享内存#

1
use std::ptr::null_mut;
2
use winapi::um::handleapi::{CloseHandle, INVALID_HANDLE_VALUE};
3
use winapi::um::memoryapi::{MapViewOfFile, UnmapViewOfFile, CreateFileMappingW, FILE_MAP_ALL_ACCESS};
4
use winapi::um::winnt::{HANDLE, PAGE_READWRITE, SECTION_ALL_ACCESS};
5

6
fn main() {
7
    let file_name = "Global\\MySharedMemory".to_wide_null();
8
    let file_size = 4096;
9
    let h_file_mapping = unsafe {
10
        CreateFileMappingW(
11
            INVALID_HANDLE_VALUE,
12
            null_mut(),
13
            PAGE_READWRITE,
14
            0,
15
            file_size,
16
            file_name.as_ptr(),
17
        )
18
    };
19
    let mut p_shared_memory = null_mut();
20
    if !h_file_mapping.is_null() {
21
        p_shared_memory = unsafe {
22
            MapViewOfFile(
23
                h_file_mapping,
24
                FILE_MAP_ALL_ACCESS,
25
                0,
26
                0,
27
                file_size,
28
            )
29
        };
30
    }
31
    if !p_shared_memory.is_null() {
32
        let p_data = p_shared_memory as *mut u8;
33
        for i in 0..file_size {
34
            unsafe { *p_data.offset(i as isize) = i as u8 };
35
        }
36
        unsafe { UnmapViewOfFile(p_shared_memory) };
37
    }
38
    if !h_file_mapping.is_null() {
39
        unsafe { CloseHandle(h_file_mapping) };
40
    }
41
}

展开收起

获取系统时间#

获取系统时间是一个常见的操作，可以用于记录日志或计算时间差等。下面是一个使用 winapi 模块获取系统时间的示例：

1
use winapi::um::sysinfoapi::GetSystemTime;
2
use winapi::um::winbase::SYSTEMTIME;
3

4
fn main() {
5
    unsafe {
6
        let mut st: SYSTEMTIME = std::mem::zeroed();
7
        GetSystemTime(&mut st as *mut SYSTEMTIME);
8
        println!("{}-{}-{} {}:{}:{}", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
9
    }
10
}

在这个示例中，我们使用了 sysinfoapi 模块中的 GetSystemTime 函数来获取系统时间。该函数的参数为一个 SYSTEMTIME 结构体指针，用于存储系统时间。我们使用 std::mem::zeroed()创建了一个空的 SYSTEMTIME 结构体，然后将其地址传递给 GetSystemTime 函数。最后，我们将获取到的系统时间打印出来。

使用 COM 组件#

1
use std::ptr::null_mut;
2
use winapi::um::combaseapi::{CoInitializeEx, CoCreateInstance, CoUninitialize};
3
use winapi::um::objbase::COINIT_APARTMENTTHREADED;
4
use winapi::um::objidl::ISequentialStream;
5
use winapi::um::unknwnbase::IUnknown;
6
use winapi::um::winnt::{HRESULT, S_OK};
7
use winapi::um::winuser::MessageBoxW;
8
use winapi::Interface;
9

10
const CLSID_XMLHTTPREQUEST: winapi::CLSID = winapi::CLSID {
11
    Data1: 0xED8C108E,
12
    Data2: 0x4349,
13
    Data3: 0x11D2,
14
    Data4: [0x91, 0xA4, 0x00, 0xC0, 0x4F, 0x79, 0xF8, 0x06],
15
};
16

17
const IID_IUNKNOWN: winapi::IID = winapi::IID {
18
    Data1: 0x00000000,
19
    Data2: 0x0000,
20
    Data3: 0x0000,
21
    Data4: [0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46],
22
};
23

24
fn main() {
25
    unsafe {
26
        CoInitializeEx(null_mut(), COINIT_APARTMENTTHREADED);
27
        let mut p_xml_http_request: *mut IUnknown = null_mut();
28
        let hr = CoCreateInstance(
29
            &CLSID_XMLHTTPREQUEST,
30
            null_mut(),
31
            winapi::um::combaseapi::CLSCTX_INPROC_SERVER,
32
            &IID_IUNKNOWN,
33
            &mut p_xml_http_request as *mut _ as *mut *mut _,
34
        );
35
        if hr == S_OK {
36
            let mut p_stream: *mut ISequentialStream = null_mut();
37
            let hr = (*p_xml_http_request).QueryInterface(
38
                &ISequentialStream::uuidof(),
39
                &mut p_stream as *mut _ as *mut *mut _,
40
            );
41
            if hr == S_OK {
42
                let message = "Hello, world!".to_wide_null();
43
                let mut bytes_written = 0;
44
                let hr = (*p_stream).Write(
45
                    message.as_ptr() as *const _,
46
                    (message.len() * 2) as u32,
47
                    &mut bytes_written as *mut _,
48
                );
49
                if hr == S_OK {
50
                    MessageBoxW(
51
                        null_mut(),
52
                        "Data written successfully!".to_wide_null().as_ptr(),
53
                        "Success\0".to_wide_null().as_ptr(),
54
                        0,
55
                    );
56
                }
57
            }
58
            (*p_stream).Release();
59
        }
60
        (*p_xml_http_request).Release();
61
        CoUninitialize();
62
    }
63
}

展开收起

结论#

本教程介绍了 winapi 模块的基础用法和进阶用法，并提供了示例代码。在使用 winapi 模块时，需要注意数据类型、结构体、常量和指针类型的正确使用。通过使用 winapi 模块，Rust 程序可以访问 Windows 操作系统的核心功能，实现更加丰富的功能。

Rust语言从入门到精通系列 - 零基础入门Win32 API开发(下)

Fri, 21 Apr 2023 00:00:00 GMT

上一篇 Rust语言从入门到精通系列 - 零基础入门Win32 API开发(上) 介绍了 Win32 API 的一些基础用法，本篇主要介绍一些进阶用法。

进阶用法#

使用 Rust 风格的 COM 组件#

1
use std::ptr::null_mut;
2
use winapi::um::combaseapi::{CoInitializeEx, CoCreateInstance, CoUninitialize};
3
use winapi::um::objbase::COINIT_APARTMENTTHREADED;
4
use winapi::um::winuser::MessageBoxW;
5
use winapi::Interface;
6

7
#[com_interface("87654321-4321-4321-4321-434343434343")]
8
trait IMyInterface {
9
    fn my_method(&self);
10
}
11

12
#[com_class("12345678-1234-1234-1234-123412341234", IMyInterface)]
13
struct MyClass;
14

15
impl IMyInterface for MyClass {
16
    fn my_method(&self) {
17
        MessageBoxW(
18
            null_mut(),
19
            "My method is called!".to_wide_null().as_ptr(),
20
            "Success\0".to_wide_null().as_ptr(),
21
            0,
22
        );
23
    }
24
}
25

26
fn main() {
27
    unsafe {
28
        CoInitializeEx(null_mut(), COINIT_APARTMENTTHREADED);
29
        let mut p_my_interface: *mut IMyInterface = null_mut();
30
        let hr = CoCreateInstance(
31
            &MyClass::uuidof(),
32
            null_mut(),
33
            winapi::um::combaseapi::CLSCTX_INPROC_SERVER,
34
            &IMyInterface::uuidof(),
35
            &mut p_my_interface as *mut _ as *mut *mut _,
36
        );
37
        if hr == winapi::S_OK {
38
            (*p_my_interface).my_method();
39
            (*p_my_interface).release();
40
        }
41
        CoUninitialize();
42
    }
43
}

展开收起

打印屏幕截图#

以下代码使用 winapi 模块的函数和结构体，实现在 Windows 操作系统下截取屏幕并打印。

1
use winapi::um::winuser::{GetDC, GetSystemMetrics, ReleaseDC, CreateCompatibleDC, CreateCompatibleBitmap, SelectObject, BitBlt, DeleteDC, DeleteObject, SM_CXSCREEN, SM_CYSCREEN, SRCCOPY};
2
use winapi::um::wingdi::{BITMAPINFO, BITMAPINFOHEADER, BI_RGB, RGBQUAD, GetDIBits, SetDIBitsToDevice};
3
use winapi::shared::windef::{HDC, HWND, HBITMAP, RECT};
4
use winapi::shared::minwindef::{DWORD, UINT};
5
use std::ptr::null_mut;
6
use std::mem::{size_of, zeroed};
7

8
fn main() {
9
    let mut rect: RECT = unsafe { zeroed() };
10
    unsafe {
11
        let hwnd = GetDesktopWindow();
12
        GetWindowRect(hwnd, &mut rect);
13
        let hdc_screen = GetDC(null_mut());
14
        let hdc = CreateCompatibleDC(hdc_screen);
15
        let hbitmap = CreateCompatibleBitmap(hdc_screen, rect.right, rect.bottom);
16
        let hbitmap_old = SelectObject(hdc, hbitmap as *mut _);
17
        BitBlt(hdc, 0, 0, rect.right, rect.bottom, hdc_screen, 0, 0, SRCCOPY);
18
        SelectObject(hdc, hbitmap_old as *mut _);
19
        DeleteDC(hdc);
20
        ReleaseDC(null_mut(), hdc_screen);
21

22
        let mut bmi: BITMAPINFO = zeroed();
23
        bmi.bmiHeader.biSize = size_of::<BITMAPINFOHEADER>() as DWORD;
24
        bmi.bmiHeader.biWidth = rect.right;
25
        bmi.bmiHeader.biHeight = -rect.bottom;
26
        bmi.bmiHeader.biPlanes = 1;
27
        bmi.bmiHeader.biBitCount = 32;
28
        bmi.bmiHeader.biCompression = BI_RGB;
29
        bmi.bmiHeader.biSizeImage = 0;
30
        bmi.bmiHeader.biXPelsPerMeter = 0;
31
        bmi.bmiHeader.biYPelsPerMeter = 0;
32
        bmi.bmiHeader.biClrUsed = 0;
33
        bmi.bmiHeader.biClrImportant = 0;
34

35
        let mut bits = Vec::with_capacity(rect.right as usize * rect.bottom as usize);
36
        GetDIBits(
37
            hdc_screen,
38
            hbitmap,
39
            0,
40
            rect.bottom as UINT,
41
            bits.as_mut_ptr() as *mut _,
42
            &mut bmi,
43
            DIB_RGB_COLORS,
44
        );
45
        bits.set_len(rect.right as usize * rect.bottom as usize);
46
        SetDIBitsToDevice(
47
            hdc_screen,
48
            0,
49
            0,
50
            rect.right,
51
            rect.bottom,
52
            0,
53
            0,
54
            0,
55
            rect.bottom,
56
            bits.as_ptr() as *mut _,
57
            &bmi,
58
            DIB_RGB_COLORS,
59
        );
60
        DeleteObject(hbitmap as *mut _);
61
    }
62
}

展开收起

上述代码使用了许多 winapi 模块中的函数和结构体，包括 GetDC、GetSystemMetrics、ReleaseDC、CreateCompatibleDC、CreateCompatibleBitmap、SelectObject、BitBlt、DeleteDC、DeleteObject、BITMAPINFO、BITMAPINFOHEADER、BI_RGB、RGBQUAD、GetDIBits、SetDIBitsToDevice、GetDesktopWindow、GetWindowRect、SRCCOPY、DIB_RGB_COLORS 等。

获取硬件信息#

以下代码使用 winapi 模块的函数和结构体，实现在 Windows 操作系统下获取硬件信息。

1
use winapi::um::winbase::{GetSystemFirmwareTable, SYSTEM_FIRMWARE_TABLE_PROVIDER_ACPI, SYSTEM_FIRMWARE_TABLE_ACPI, SYSTEM_FIRMWARE_TABLE_ACTION_READ};
2
use winapi::um::winnt::{HANDLE, PVOID, ULONG};
3
use std::ptr::null_mut;
4
use std::mem::size_of;
5

6
fn main() {
7
    let mut buffer_size: ULONG = 0;
8
    let mut buffer: Vec<u8> = Vec::new();
9
    unsafe {
10
        GetSystemFirmwareTable(
11
            SYSTEM_FIRMWARE_TABLE_PROVIDER_ACPI,
12
            SYSTEM_FIRMWARE_TABLE_ACPI,
13
            null_mut(),
14
            0,
15
        );
16
        buffer_size = GetSystemFirmwareTable(
17
            SYSTEM_FIRMWARE_TABLE_PROVIDER_ACPI,
18
            SYSTEM_FIRMWARE_TABLE_ACPI,
19
            null_mut(),
20
            0,
21
        );
22
        buffer = Vec::with_capacity(buffer_size as usize);
23
        GetSystemFirmwareTable(
24
            SYSTEM_FIRMWARE_TABLE_PROVIDER_ACPI,
25
            SYSTEM_FIRMWARE_TABLE_ACPI,
26
            buffer.as_mut_ptr() as PVOID,
27
            buffer_size,
28
        );
29
        buffer.set_len(buffer_size as usize);
30
        println!("ACPI table size: {}", buffer_size);
31
    }
32
}

展开收起

上述代码使用了 winapi 模块中的函数和结构体，包括 GetSystemFirmwareTable、SYSTEM_FIRMWARE_TABLE_PROVIDER_ACPI、SYSTEM_FIRMWARE_TABLE_ACPI、SYSTEM_FIRMWARE_TABLE_ACTION_READ、HANDLE、PVOID 和 ULONG 等。

获取系统信息#

以下代码使用 winapi 模块的函数和结构体，实现在 Windows 操作系统下获取系统信息。

1
use winapi::um::sysinfoapi::{GetSystemInfo, SYSTEM_INFO};
2
use std::mem::zeroed;
3

4
fn main() {
5
    let mut system_info: SYSTEM_INFO = unsafe { zeroed() };
6
    unsafe {
7
        GetSystemInfo(&mut system_info);
8
        println!("Number of processors: {}", system_info.dwNumberOfProcessors);
9
        println!("Page size: {}", system_info.dwPageSize);
10
        println!("Processor architecture: {}", system_info.wProcessorArchitecture);
11
    }
12
}

上述代码使用了 winapi 模块中的函数和结构体，包括 GetSystemInfo 和 SYSTEM_INFO 等。

获取网络信息#

以下代码使用 winapi 模块的函数和结构体，实现在 Windows 操作系统下获取网络信息。

1
use winapi::um::iphlpapi::{GetAdaptersInfo, PIP_ADAPTER_INFO};
2
use std::ptr::null_mut;
3
use std::mem::size_of;
4

5
fn main() {
6
    let mut adapter_info: PIP_ADAPTER_INFO = null_mut();
7
    let mut buffer_size: u32 = 0;
8
    unsafe {
9
        GetAdaptersInfo(null_mut(), &mut buffer_size);
10
        adapter_info = std::mem::zeroed();
11
        GetAdaptersInfo(adapter_info, &mut buffer_size);
12
        println!("Adapter name: {:?}", std::ffi::CStr::from_ptr((*adapter_info).AdapterName.as_ptr() as *const i8));
13
    }
14
}

上述代码使用了 winapi 模块中的函数和结构体，包括 GetAdaptersInfo 和 PIP_ADAPTER_INFO 等。

使用 Windows API 发送邮件#

发送邮件是一种常见的网络操作，可以用于发送电子邮件、短信等。下面是一个使用 winapi 模块发送邮件的示例：

1
use winapi::um::mapi::{MAPISendMailW, MapiMessage, MapiFileDesc, MapiRecipDesc, MAPI_LOGON_UI, MAPI_DIALOG};
2
use std::os::windows::ffi::OsStrExt;
3
use std::ffi::OsStr;
4
use std::ptr::null_mut;
5
use std::mem::MaybeUninit;
6

7
fn main() {
8
    let mut msg: MapiMessage = MaybeUninit::uninit().assume_init();
9
    msg.lpszSubject = OsStr::new("Test Email").encode_wide().chain(Some(0)).collect::<Vec<_>>().as_ptr();
10
    msg.lpszNoteText = OsStr::new("This is a test email.").encode_wide().chain(Some(0)).collect::<Vec<_>>().as_ptr();
11
    msg.nRecipCount = 1;
12
    let mut recip: MapiRecipDesc = MaybeUninit::uninit().assume_init();
13
    recip.ulRecipClass = 1;
14
    recip.lpszName = OsStr::new("John Smith").encode_wide().chain(Some(0)).collect::<Vec<_>>().as_ptr();
15
    recip.lpszAddress = OsStr::new("john.smith@example.com").encode_wide().chain(Some(0)).collect::<Vec<_>>().as_ptr();
16
    msg.lpRecips = &mut recip as *mut MapiRecipDesc;
17
    msg.nFileCount = 1;
18
    let mut file: MapiFileDesc = MaybeUninit::uninit().assume_init();
19
    file.nPosition = 0xFFFFFFFF;
20
    file.lpszPathName = OsStr::new("test.txt").encode_wide().chain(Some(0)).collect::<Vec<_>>().as_ptr();
21
    file.lpszFileName = OsStr::new("test.txt").encode_wide().chain(Some(0)).collect::<Vec<_>>().as_ptr();
22
    msg.lpFiles = &mut file as *mut MapiFileDesc;
23
    unsafe {
24
        let result = MAPISendMailW(null_mut(), null_mut(), &mut msg as *mut MapiMessage, MAPI_LOGON_UI | MAPI_DIALOG, 0);
25
        if result != 0 {
26
            println!("Error: {}", result);
27
        }
28
    }
29
}

展开收起

在这个示例中，我们使用了 mapi 模块中的 MAPISendMailW 函数发送邮件。该函数的参数包括邮件消息、登录标志和对话框标志等。我们创建了一个 MapiMessage 结构体 msg，并设置了邮件主题、正文和收件人等信息。我们还创建了一个 MapiRecipDesc 结构体 recip，并设置了收件人姓名和地址。最后，我们创建了一个 MapiFileDesc 结构体 file，并设置了附件的路径和文件名。

接着，我们将 msg.lpRecips 和 msg.lpFiles 分别设置为&mut recip 和&mut file，以便将收件人和附件信息添加到邮件消息中。最后，我们使用 MAPISendMailW 函数发送邮件，并使用 println!函数打印出错误信息（如果有）。

Rust语言从入门到精通系列 - 发布你的跨平台二进制文件

Fri, 21 Apr 2023 00:00:00 GMT

Rust 是一种系统级编程语言，具有高效、安全、并发等特点，因此在一些领域得到了广泛的应用。但是，Rust 语言本身并不提供跨平台编译的支持，这对于需要在不同操作系统上运行的项目来说是一个不小的挑战。为了解决这个问题，我们可以使用 Cross 工具，它可以帮助我们轻松地将 Rust 程序编译成各种平台的可执行文件。

在本教程中，我们将使用 Cross 工具来编译一个简单的加、减、乘、除 四则运算的计算器，并将其发布到 Windows、Mac 和 Linux 等平台。

安装 Rust 和 Cargo#

具体的安装步骤本篇文章不再赘述，请参考系列的前面的 Cargo 篇和 Hello World 篇。输入以下命令，确认编译环境是否准备就绪。

Terminal window

1
rustc --version
2
cargo --version

如果输出版本号，则说明环境正常。

安装 Cross#

接下来，我们需要安装 Cross 工具。在终端中输入以下命令进行安装：

1
cargo install cross

安装完成后，同样，在终端使用cross --version命令来验证安装是否成功。

创建项目#

接下来，我们需要创建一个新的 Rust 项目。在终端中进入你想要创建项目的目录，然后运行以下命令：

Terminal window

1
cargo new calculator --bin

这将创建一个名为calculator的新项目，并且告诉 Cargo 这是一个二进制文件（--bin）。在项目目录中，你会看到一个src文件夹和一个Cargo.toml文件。

编写代码#

现在，我们可以开始编写代码了。在src/main.rs文件中，输入以下代码：

1
use std::io::{self, Write};
2

3
fn main() {
4
    let mut input = String::new();
5
    print!("Enter an expression: ");
6
    io::stdout().flush().unwrap();
7
    io::stdin().read_line(&mut input).unwrap();
8
    let tokens: Vec<&str> = input.trim().split(' ').collect();
9
    let num1 = tokens[0].parse::<f64>().unwrap();
10
    let num2 = tokens[2].parse::<f64>().unwrap();
11
    let operator = tokens[1];
12
    match operator {
13
        "+" => println!("{} + {} = {}", num1, num2, num1 + num2),
14
        "-" => println!("{} - {} = {}", num1, num2, num1 - num2),
15
        "*" => println!("{} * {} = {}", num1, num2, num1 * num2),
16
        "/" => println!("{} / {} = {}", num1, num2, num1 / num2),
17
        _ => println!("Invalid operator"),
18
    }
19
}

展开收起

这是一个简单的计算器程序，它可以让用户输入一个操作，然后对两个数字执行该操作。如果操作无效，程序将提示用户重新输入。

构建项目#

现在，我们可以使用 Cargo 来构建我们的项目。在终端中进入项目目录，然后运行以下命令：

Terminal window

1
cargo build --release

这将使用 Rust 编译器将我们的代码编译成一个二进制文件。--release标志将优化代码以提高性能。构建完成后，你将在target/release目录中找到一个名为calculator的二进制文件。

发布二进制文件#

现在，我们可以将二进制文件发布到各种平台上，让用户可以使用我们的计算器程序。在 Rust 中，我们可以使用 Cross 工具来跨平台构建二进制文件。

首先，我们需要安装 Cross。在终端中运行以下命令：

Terminal window

1
cargo install cross

安装完成后，我们可以使用 Cross 来构建二进制文件。运行以下命令：

Terminal window

1
cross build --release --target x86_64-pc-windows-gnu
2
cross build --release --target x86_64-apple-darwin
3
cross build --release --target x86_64-unknown-linux-gnu

这将分别构建 Windows、Mac 和 Linux 上的二进制文件。构建完成后，你将在target/x86_64-pc-windows-gnu/release、target/x86_64-apple-darwin/release和target/x86_64-unknown-linux-gnu/release目录中找到三个二进制文件。

测试二进制文件#

现在，我们可以测试我们的二进制文件了。在 Windows 上，双击calculator.exe文件即可运行程序。在 Mac 和 Linux 上，打开终端并进入二进制文件所在的目录，然后运行以下命令：

Terminal window

1
./calculator

程序将启动并提示用户输入操作。输入操作后，程序将执行该操作并输出结果。

总结#

在本教程中，我们学习了如何使用 Rust 编写一个简单的加减乘除计算器，并将其发布为二进制文件。我们使用 Cargo 来管理依赖和构建项目，使用 Cross 工具来跨平台构建二进制文件。通过这个例子，你可以学习如何使用 Rust 编写实用的命令行工具，并将其发布到各种平台上。

Rust语言从入门到精通系列 - 深入理解进程间共享内存通信

Fri, 21 Apr 2023 00:00:00 GMT

进程间通信（IPC）是操作系统中非常重要的一部分，它使得不同的进程可以在不同的计算机上进行通信。在 Windows 操作系统中，共享内存是一种常见的 IPC 机制，它可以在不同的进程之间共享数据，以便它们可以相互通信。在本教程中，我们将使用 Rust 语言的 WinAPI 模块来实现共享内存，以便两个进程可以进行通信。

共享内存的概念#

共享内存是一种 IPC 机制，它允许不同的进程共享同一块内存区域。这样，一个进程可以将数据写入共享内存区域，而其他进程可以读取这些数据。共享内存通常比其他 IPC 机制（如管道或消息队列）更快，因为它不涉及操作系统内核的介入。

共享内存通常由以下三个部分组成：

内存区域：共享内存的实际数据存储区域。
锁：用于控制对共享内存的访问，以确保同一时间只有一个进程可以访问它。
信号量：用于通知其他进程共享内存中的数据已被修改。

在 Windows 操作系统中，共享内存是由内核对象来管理的。这些内核对象包括共享内存段、互斥体和信号量。

Rust 语言的 WinAPI 模块#

Rust 语言提供了一个 WinAPI 模块，它允许我们在 Rust 中使用 Windows API。这个模块提供了许多函数和类型，可以用于创建 Windows 应用程序和系统级别的程序。

在本教程中，我们将使用 WinAPI 模块中的函数来创建共享内存段、互斥体和信号量。

创建共享内存段#

在 Windows 操作系统中，共享内存段是由内核对象来管理的。我们可以使用 WinAPI 模块中的函数来创建共享内存段。

以下是创建共享内存段的步骤：

使用CreateFileMapping()函数创建一个共享内存段。

1
use winapi::um::memoryapi::CreateFileMappingW;
2

3
let handle = unsafe {
4
    CreateFileMappingW(
5
        INVALID_HANDLE_VALUE,
6
        ptr::null_mut(),
7
        PAGE_READWRITE,
8
        0,
9
        size,
10
        name
11
    )
12
};

在这个函数中，我们传递了以下参数：

INVALID_HANDLE_VALUE：表示使用系统页面文件作为物理存储器。
ptr::null_mut()：表示不使用现有文件作为物理存储器。
PAGE_READWRITE：表示共享内存段可读可写。
0：表示共享内存段的大小。
name：共享内存段的名称。

使用MapViewOfFile()函数将共享内存段映射到进程的地址空间中。

1
use winapi::um::memoryapi::MapViewOfFile;
2

3
let ptr = unsafe {
4
    MapViewOfFile(
5
        handle,
6
        FILE_MAP_ALL_ACCESS,
7
        0,
8
        0,
9
        size
10
    )
11
};

在这个函数中，我们传递了以下参数：

handle：共享内存段的句柄。
FILE_MAP_ALL_ACCESS：表示进程可以读取和写入共享内存段。
0：表示共享内存段的偏移量。
0：表示共享内存段的起始地址。
size：表示共享内存段的大小。

现在，我们已经创建了一个共享内存段，并将其映射到了进程的地址空间中。

创建互斥体#

互斥体是一种同步原语，用于控制对共享资源的访问。在 Windows 操作系统中，互斥体是由内核对象来管理的。我们可以使用 WinAPI 模块中的函数来创建互斥体。

以下是创建互斥体的步骤：

使用CreateMutexW()函数创建一个互斥体。

1
use winapi::um::synchapi::CreateMutexW;
2

3
let handle = unsafe {
4
    CreateMutexW(
5
        ptr::null_mut(),
6
        FALSE,
7
        name
8
    )
9
};

在这个函数中，我们传递了以下参数：

ptr::null_mut()：表示使用默认的安全描述符。
FALSE：表示互斥体未被占用。
name：互斥体的名称。

使用WaitForSingleObject()函数等待互斥体。

1
use winapi::um::synchapi::WaitForSingleObject;
2

3
let result = unsafe {
4
    WaitForSingleObject(
5
        handle,
6
        INFINITE
7
    )
8
};

在这个函数中，我们传递了以下参数：

handle：互斥体的句柄。
INFINITE：表示无限等待互斥体。

现在，我们已经创建了一个互斥体，并等待了它。

创建信号量#

信号量是一种同步原语，用于控制对共享资源的访问。在 Windows 操作系统中，信号量是由内核对象来管理的。我们可以使用 WinAPI 模块中的函数来创建信号量。

以下是创建信号量的步骤：

使用CreateSemaphoreW()函数创建一个信号量。

1
use winapi::um::synchapi::CreateSemaphoreW;
2

3
let handle = unsafe {
4
    CreateSemaphoreW(
5
        ptr::null_mut(),
6
        initial_count,
7
        max_count,
8
        name
9
    )
10
};

在这个函数中，我们传递了以下参数：

ptr::null_mut()：表示使用默认的安全描述符。
initial_count：表示信号量的初始计数。
max_count：表示信号量的最大计数。
name：信号量的名称。

使用WaitForSingleObject()函数等待信号量。

1
use winapi::um::synchapi::WaitForSingleObject;
2

3
let result = unsafe {
4
    WaitForSingleObject(
5
        handle,
6
        INFINITE
7
    )
8
};

在这个函数中，我们传递了以下参数：

handle：信号量的句柄。
INFINITE：表示无限等待信号量。

现在，我们已经创建了一个信号量，并等待了它。

完整示例代码#

下面是一个使用共享内存进行进程间通信的示例代码：

1
use std::ffi::OsStr;
2
use std::os::windows::ffi::OsStrExt;
3
use std::ptr;
4
use winapi::shared::minwindef::{FALSE, TRUE};
5
use winapi::um::handleapi::INVALID_HANDLE_VALUE;
6
use winapi::um::memoryapi::{CreateFileMappingW, MapViewOfFile};
7
use winapi::um::synchapi::{CreateMutexW, CreateSemaphoreW, ReleaseMutex, ReleaseSemaphore, WaitForSingleObject};
8
use winapi::um::winnt::{HANDLE, PAGE_READWRITE};
9

10
fn main() {
11
    let name: Vec<u16> = OsStr::new("MySharedMemory").encode_wide().chain(Some(0).into_iter()).collect();
12
    let size = 1024 * 1024; // 1MB
13

14
    // Create shared memory segment
15
    let handle = unsafe {
16
        CreateFileMappingW(
17
            INVALID_HANDLE_VALUE,
18
            ptr::null_mut(),
19
            PAGE_READWRITE,
20
            0,
21
            size,
22
            name.as_ptr()
23
        )
24
    };
25
    let ptr = unsafe {
26
        MapViewOfFile(
27
            handle,
28
            FILE_MAP_ALL_ACCESS,
29
            0,
30
            0,
31
            size
32
        )
33
    };
34

35
    // Create mutex
36
    let mutex_name: Vec<u16> = OsStr::new("MyMutex").encode_wide().chain(Some(0).into_iter()).collect();
37
    let mutex_handle = unsafe {
38
        CreateMutexW(
39
            ptr::null_mut(),
40
            FALSE,
41
            mutex_name.as_ptr()
42
        )
43
    };
44

45
    // Create semaphore
46
    let semaphore_name: Vec<u16> = OsStr::new("MySemaphore").encode_wide().chain(Some(0).into_iter()).collect();
47
    let semaphore_handle = unsafe {
48
        CreateSemaphoreW(
49
            ptr::null_mut(),
50
            0,
51
            1,
52
            semaphore_name.as_ptr()
53
        )
54
    };
55

56
    // Write data to shared memory
57
    let data = [1, 2, 3, 4, 5];
58
    unsafe {
59
        WaitForSingleObject(mutex_handle, INFINITE);
60
        ptr::copy_nonoverlapping(data.as_ptr() as *const _, ptr as *mut _, data.len());
61
        ReleaseMutex(mutex_handle);
62
        ReleaseSemaphore(semaphore_handle, 1, ptr::null_mut());
63
    }
64

65
    // Read data from shared memory
66
    let mut result = [0; 5];
67
    unsafe {
68
        WaitForSingleObject(semaphore_handle, INFINITE);
69
        ptr::copy_nonoverlapping(ptr as *const _, result.as_mut_ptr() as *mut _, result.len());
70
    }
71

72
    println!("{:?}", result);
73
}

展开收起

在这个示例代码中，我们创建了一个名为”MySharedMemory”的共享内存段，并将其映射到了进程的地址空间中。我们还创建了一个名为”MyMutex”的互斥体和一个名为”MySemaphore”的信号量。

然后，我们将数据写入共享内存段，并使用互斥体来确保同一时间只有一个进程可以访问共享内存段。我们还使用信号量来通知另一个进程共享内存段中的数据已被修改。

最后，我们从共享内存段中读取数据，并使用信号量来等待另一个进程修改共享内存段中的数据。

常见问题及解决方法#

在使用共享内存进行进程间通信时，可能会遇到以下常见问题：

内存泄漏

在使用共享内存时，必须确保在不再需要它时释放共享内存。如果没有正确释放共享内存，可能会导致内存泄漏，这会降低系统的性能并可能导致系统崩溃。使用共享内存时，应该确保在不再需要它时释放共享内存。可以使用UnmapViewOfFile()函数释放共享内存段，并使用CloseHandle()函数释放互斥体和信号量。

竞争条件

在使用共享内存时，可能会发生竞争条件，这是由于多个进程同时访问共享内存而引起的。如果没有正确处理竞争条件，可能会导致数据损坏或其他问题。使用互斥体来控制对共享内存的访问，以确保同一时间只有一个进程可以访问共享内存。可以使用信号量来通知其他进程共享内存中的数据已被修改。

数据同步

在使用共享内存时，必须确保多个进程之间的数据同步。如果没有正确处理数据同步，可能会导致数据损坏或其他问题。使用信号量来通知其他进程共享内存中的数据已被修改。可以使用互斥体来控制对共享内存的访问，以确保同一时间只有一个进程可以访问共享内存。

安全性

在使用共享内存时，必须确保数据的安全性。如果没有正确处理数据的安全性，可能会导致数据泄露或其他安全问题。使用安全描述符来控制对共享内存的访问。可以使用安全描述符来限制哪些进程可以访问共享内存，并限制它们可以执行的操作。

总结#

在本教程中，我们使用 Rust 语言的 WinAPI 模块来实现共享内存，以便两个进程可以进行通信。我们学习了如何创建共享内存段、互斥体和信号量，并提供了示例代码。我们还总结了共享内存的常见问题以及如何避免和解决这些问题。

共享内存是一种非常有用的 IPC 机制，它可以在不同的进程之间共享数据。在使用共享内存时，必须确保正确处理内存泄漏、竞争条件、数据同步和安全性等问题。

Rust语言从入门到精通系列 - 开发你的专属输入法

Fri, 21 Apr 2023 00:00:00 GMT

在本文中，我们将介绍如何使用 Rust 编程语言和 WinAPI 库来获取鼠标光标的位置并监听键盘事件。我们将在 Windows 操作系统上实现这个功能，并且将使用 Rust 的 winapi 模块来访问 Windows API。

我们将首先介绍如何获取鼠标光标的位置，然后我们将介绍如何监听键盘事件。最后，我们将把这些知识结合起来，实现在光标位置接收用户输入的功能。

获取鼠标光标位置#

要获取鼠标光标的位置，需要使用 Windows API 函数 GetCursorPos。该函数返回一个 POINT 结构体，其中包含鼠标光标的 x 和 y 坐标。以下是获取鼠标光标位置的示例代码：

1
use winapi::um::winuser::GetCursorPos;
2
use winapi::shared::windef::POINT;
3

4
fn main() {
5
    let mut point = POINT { x: 0, y: 0 };
6
    unsafe {
7
        GetCursorPos(&mut point);
8
    }
9
    println!("x: {}, y: {}", point.x, point.y);
10
}

在上面的代码中，我们首先导入了 winapi 模块中的 GetCursorPos 函数和 POINT 结构体。然后，我们创建了一个 POINT 结构体实例，并将其传递给 GetCursorPos 函数。最后，我们打印出鼠标光标的 x 和 y 坐标。

监听键盘事件#

在 Rust 语言中，可以使用 winapi 模块中的 SetWindowsHookEx 函数来监听键盘事件。该函数的定义如下：

1
pub fn SetWindowsHookExW(
2
    idHook: c_int,
3
    lpfn: Option<unsafe extern "system" fn(c_int, WPARAM, LPARAM) -> LRESULT>,
4
    hmod: HINSTANCE,
5
    dwThreadId: DWORD,
6
) -> HHOOK;

该函数的参数 idHook 表示要监听的事件类型，可以使用 WH_KEYBOARD_LL 常量来表示监听键盘事件。lpfn 是一个回调函数，用于处理键盘事件。hmod 表示当前模块的句柄，可以使用 GetModuleHandleW 函数获取。dwThreadId 表示要监听的线程 ID，可以使用 0 表示监听所有线程。

在回调函数中，可以使用 GetAsyncKeyState 函数获取键盘状态。该函数的定义如下：

1
pub fn GetAsyncKeyState(vKey: c_int) -> SHORT;

该函数的参数 vKey 表示要查询的键盘键码，返回值为 SHORT 类型，表示键盘状态。如果返回值的最高位为 1，表示键盘按键处于按下状态，否则表示键盘按键处于弹起状态。

钩子函数是一个回调函数，用于处理截获的事件。在 Rust 中，我们可以使用 extern “system” 语法来定义钩子函数。这个语法用于指定函数的调用约定，以便它可以与 Windows API 进行交互。我们将在下面的代码中看到它的用法。使用 winapi::um::winuser 模块中的 SetWindowsHookEx 函数来调用 Windows API。代码如下：

1
use winapi::um::winuser::{SetWindowsHookExW, UnhookWindowsHookEx, CallNextHookEx};
2
use winapi::shared::windef::HHOOK;
3
use winapi::shared::minwindef::{LPARAM, WPARAM, LRESULT, DWORD};
4

5
unsafe extern "system" fn keyboard_proc(nCode: i32, wParam: WPARAM, lParam: LPARAM) -> LRESULT {
6
    if nCode >= 0 {
7
        println!("Key pressed: {}", wParam);
8
    }
9
    CallNextHookEx(0 as HHOOK, nCode, wParam, lParam)
10
}
11

12
fn main() {
13
    unsafe {
14
        let hook = SetWindowsHookExW(
15
            winapi::um::winuser::WH_KEYBOARD_LL,
16
            Some(keyboard_proc),
17
            std::ptr::null_mut(),
18
            0
19
        );
20
        loop {
21
            let msg = winapi::um::winuser::GetMessageW(std::ptr::null_mut(), 0, 0, 0);
22
            if msg == 0 {
23
                break;
24
            } else {
25
                winapi::um::winuser::TranslateMessage(&msg);
26
                winapi::um::winuser::DispatchMessageW(&msg);
27
            }
28
        }
29
        UnhookWindowsHookEx(hook);
30
    }
31
}

展开收起

在上面的代码中，我们首先定义了一个钩子函数 keyboard_proc。它接受三个参数：nCode、wParam 和 lParam。nCode 是一个钩子代码，用于指示事件类型。如果 nCode 大于等于 0，则表示该事件是一个键盘输入事件。wParam 是一个 WPARAM 类型的参数，用于指示按下或释放的键的虚拟键码。lParam 是一个 LPARAM 类型的参数，用于指示键盘状态和扫描码。

在钩子函数中，我们首先检查 nCode 是否大于等于 0。如果是，我们打印出按下的键的虚拟键码。然后我们调用 CallNextHookEx 函数，将事件传递给下一个钩子或目标窗口过程。

在 main 函数中，我们首先调用 SetWindowsHookExW 函数，将钩子函数注册到 WH_KEYBOARD_LL 钩子类型上。然后我们进入一个无限循环，等待消息。在每次循环中，我们调用 GetMessageW 函数来获取消息。如果 GetMessageW 函数返回 0，则表示程序应该退出。否则，我们调用 TranslateMessage 函数和 DispatchMessageW 函数，以便将消息传递给窗口过程。最后，我们调用 UnhookWindowsHookEx 函数，将钩子函数从 WH_KEYBOARD_LL 钩子类型上注销。

在光标位置接收用户输入#

现在我们已经知道如何获取鼠标光标的位置和监听键盘事件。我们可以将这些知识结合起来，实现在光标位置接收用户输入的功能。具体来说，我们将在光标位置创建一个文本框，并在用户输入时将其添加到文本框中。

在 Windows 操作系统中，我们可以使用 CreateWindowEx 函数来创建一个窗口。这个函数的原型如下：

1
HWND CreateWindowExW(
2
  DWORD     dwExStyle,
3
  LPCWSTR   lpClassName,
4
  LPCWSTR   lpWindowName,
5
  DWORD     dwStyle,
6
  int       x,
7
  int       y,
8
  int       nWidth,
9
  int       nHeight,
10
  HWND      hWndParent,
11
  HMENU     hMenu,
12
  HINSTANCE hInstance,
13
  LPVOID    lpParam
14
);

在 Rust 中，我们可以使用 winapi::um::winuser 模块中的 CreateWindowEx 函数来调用 Windows API。

然后我们可以使用以下代码来创建一个文本框：

1
use winapi::um::winuser::{CreateWindowExW, DefWindowProcW, RegisterClassW, WS_EX_CLIENTEDGE, WS_CHILD, WS_VISIBLE, WM_SIZE, WM_DESTROY, WM_SETFOCUS, WM_CHAR, HWND, HMENU, HINSTANCE, WNDCLASSW, MSG};
2
use winapi::shared::windef::{HWND__, RECT};
3
use winapi::shared::minwindef::{UINT, WPARAM, LPARAM, LRESULT, DWORD};
4
use winapi::um::libloaderapi::GetModuleHandleW;
5
use std::ffi::OsStr;
6
use std::iter::once;
7
use std::os::windows::ffi::OsStrExt;
8

9
unsafe extern "system" fn wnd_proc(hwnd: HWND, msg: UINT, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
10
    match msg {
11
        WM_SIZE => {
12
            let mut rect: RECT = std::mem::zeroed();
13
            winapi::um::winuser::GetClientRect(hwnd, &mut rect);
14
            let edit_hwnd = winapi::um::winuser::GetDlgItem(hwnd, 100);
15
            winapi::um::winuser::SetWindowPos(edit_hwnd, std::ptr::null_mut(), rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, 0);
16
        },
17
        WM_DESTROY => {
18
            winapi::um::winuser::PostQuitMessage(0);
19
        },
20
        WM_SETFOCUS => {
21
            let edit_hwnd = winapi::um::winuser::GetDlgItem(hwnd, 100);
22
            winapi::um::winuser::SetFocus(edit_hwnd);
23
        },
24
        WM_CHAR => {
25
            let edit_hwnd = winapi::um::winuser::GetDlgItem(hwnd, 100);
26
            let mut text: [u16; 2] = [0; 2];
27
            let len = winapi::um::winuser::GetWindowTextW(edit_hwnd, text.as_mut_ptr(), 2);
28
            if len == 0 {
29
                winapi::um::winuser::SetWindowTextW(edit_hwnd, &wparam as *const _ as *const u16);
30
            } else {
31
                let mut buffer: Vec<u16> = Vec::with_capacity(len as usize + 1);
32
                buffer.set_len(len as usize);
33
                winapi::um::winuser::GetWindowTextW(edit_hwnd, buffer.as_mut_ptr(), len + 1);
34
                buffer.push(wparam as u16);
35
                winapi::um::winuser::SetWindowTextW(edit_hwnd, buffer.as_ptr());
36
            }
37
        },
38
        _ => return DefWindowProcW(hwnd, msg, wparam, lparam),
39
    }
40
    0
41
}
42

43
fn main() {
44
    unsafe {
45
        let hinstance = GetModuleHandleW(std::ptr::null());
46
        let class_name: Vec<u16> = OsStr::new("my_window_class").encode_wide().chain(once(0)).collect();
47
        let wndclass = WNDCLASSW {
48
            style: 0,
49
            lpfnWndProc: Some(wnd_proc),
50
            hInstance: hinstance,
51
            lpszClassName: class_name.as_ptr(),
52
            cbClsExtra: 0,
53
            cbWndExtra: 0,
54
            hIcon: std::ptr::null_mut(),
55
            hCursor: std::ptr::null_mut(),
56
            hbrBackground: winapi::um::winuser::COLOR_WINDOW as HINSTANCE,
57
            lpszMenuName: std::ptr::null_mut(),
58
        };
59
        RegisterClassW(&wndclass);
60
        let hwnd = CreateWindowExW(
61
            WS_EX_CLIENTEDGE,
62
            class_name.as_ptr(),
63
            OsStr::new("My Window").encode_wide().chain(once(0)).collect().as_ptr(),
64
            WS_CHILD | WS_VISIBLE,
65
            0,
66
            0,
67
            0,
68
            0,
69
            std::ptr::null_mut(),
70
            std::ptr::null_mut(),
71
            hinstance,
72
            std::ptr::null_mut(),
73
        );
74
        let edit_hwnd = CreateWindowExW(
75
            0,
76
            OsStr::new("EDIT").encode_wide().chain(once(0)).collect().as_ptr(),
77
            std::ptr::null_mut(),
78
            WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL | 0x800,
79
            0,
80
            0,
81
            0,
82
            0,
83
            hwnd,
84
            100 as HMENU,
85
            hinstance,
86
            std::ptr::null_mut(),
87
        );
88
        loop {
89
            let mut msg: MSG = std::mem::zeroed();
90
            if winapi::um::winuser::GetMessageW(&mut msg, std::ptr::null_mut(), 0, 0) > 0 {
91
                winapi::um::winuser::TranslateMessage(&msg);
92
                winapi::um::winuser::DispatchMessageW(&msg);
93
            } else {
94
                break;
95
            }
96
        }
97
    }
98
}

展开收起

在上面的代码中，我们首先定义了一个窗口过程 wnd_proc。它接受四个参数：hwnd、msg、wparam 和 lparam。hwnd 是窗口句柄，msg 是消息类型，wparam 和 lparam 是消息参数。在窗口过程中，我们处理了四个消息：WM_SIZE、WM_DESTROY、WM_SETFOCUS 和 WM_CHAR。

在 WM_SIZE 消息中，我们获取客户区的大小，并将文本框的大小设置为与客户区相同。在 WM_DESTROY 消息中，我们调用 PostQuitMessage 函数，以便在窗口关闭时退出程序。在 WM_SETFOCUS 消息中，我们获取文本框的句柄，并将焦点设置为文本框。在 WM_CHAR 消息中，我们获取文本框的句柄，并将用户输入添加到文本框中。

在 main 函数中，我们首先获取模块句柄。然后我们定义一个 WNDCLASSW 结构体，并将其注册到系统中。这个结构体包含了窗口过程和窗口类名。然后我们调用 CreateWindowExW 函数，创建一个窗口。在这个窗口中，我们创建了一个文本框，并将其添加到窗口中。最后，我们进入一个无限循环，等待消息。在每次循环中，我们调用 GetMessageW 函数来获取消息。如果 GetMessageW 函数返回 0，则表示程序应该退出。否则，我们调用 TranslateMessage 函数和 DispatchMessageW 函数，以便将消息传递给窗口过程。

总结#

在本文中，我们介绍了如何使用 Rust 编程语言和 WinAPI 库来获取鼠标光标的位置并监听键盘事件。我们首先介绍了如何获取鼠标光标的位置，然后我们介绍了如何监听键盘事件。最后，我们将这些知识结合起来，实现了在光标位置接收用户输入的功能。

这个功能可以用于许多应用程序，例如屏幕取词工具、虚拟键盘等。我们希望这篇文章能够帮助你了解如何在 Rust 中使用 WinAPI 库来实现这些功能。

Rust语言从入门到精通系列 - Prometheus实战教程

Thu, 13 Apr 2023 00:00:00 GMT

Prometheus是一种开源的监控系统，它由SoundCloud开发并在2012年发布。它旨在收集和记录大量时间序列数据，并提供强大的查询语言和图形化界面。Prometheus使用HTTP协议进行通信，可以与多种编程语言集成，包括Rust语言。

Rust是一种系统级编程语言，具有高性能和内存安全性。由于Rust语言的高性能和安全性，越来越多的开发人员开始使用Rust语言来构建高性能的应用程序。由于Prometheus是一种高性能的监控系统，因此使用Rust语言与Prometheus集成是一种非常好的选择。

在本教程中，我们将介绍如何使用Rust语言与Prometheus集成。我们将提供基础用法和进阶用法示例，以及最佳实践。

基础用法#

安装Prometheus Rust客户端#

在使用Rust语言与Prometheus集成之前，您需要安装Prometheus Rust客户端。您可以使用以下命令在Rust项目中添加Prometheus Rust客户端依赖项：

1
[dependencies]
2
prometheus = "0.9.0"

创建Counter#

Counter是一种Prometheus指标类型，用于记录事件发生的次数。以下是如何在Rust中创建Counter的示例：

1
use prometheus::{Counter, CounterVec, Opts, Registry};
2

3
let opts = Opts::new("my_counter", "My counter help").namespace("my_namespace");
4
let counter = Counter::with_opts(opts).unwrap();
5

6
counter.inc();

创建Gauge#

Gauge是一种Prometheus指标类型，用于记录当前值。以下是如何在Rust中创建Gauge的示例：

1
use prometheus::{Gauge, Opts, Registry};
2

3
let opts = Opts::new("my_gauge", "My gauge help").namespace("my_namespace");
4
let gauge = Gauge::with_opts(opts).unwrap();
5

6
gauge.set(10.0);

创建Histogram#

Histogram是一种Prometheus指标类型，用于记录事件发生的次数，并将事件分成桶。以下是如何在Rust中创建Histogram的示例：

1
use prometheus::{Histogram, HistogramOpts, HistogramVec, Opts, Registry};
2

3
let opts = HistogramOpts::new("my_histogram", "My histogram help").namespace("my_namespace");
4
let histogram = Histogram::with_opts(opts).unwrap();
5

6
histogram.observe(10.0);

创建Summary#

Summary是一种Prometheus指标类型，用于记录事件发生的次数，并计算事件的总和和平均值。以下是如何在Rust中创建Summary的示例：

1
use prometheus::{Opts, Registry, Summary, SummaryOpts};
2

3
let opts = SummaryOpts::new("my_summary", "My summary help").namespace("my_namespace");
4
let summary = Summary::with_opts(opts).unwrap();
5

6
summary.observe(10.0);

注册指标#

在创建指标之后，您需要将指标注册到Prometheus客户端中。以下是如何在Rust中注册指标的示例：

1
use prometheus::{register, Counter, Opts, Registry};
2

3
let opts = Opts::new("my_counter", "My counter help").namespace("my_namespace");
4
let counter = Counter::with_opts(opts).unwrap();
5

6
register(Box::new(counter.clone())).unwrap();
7

8
counter.inc();

导出指标#

在注册指标之后，您需要将指标导出到Prometheus客户端中。以下是如何在Rust中导出指标的示例：

1
use prometheus::{Encoder, TextEncoder};
2

3
let encoder = TextEncoder::new();
4
let metric_families = prometheus::gather();
5

6
let mut buffer = vec![];
7
encoder.encode(&metric_families, &mut buffer).unwrap();
8

9
let output = String::from_utf8(buffer).unwrap();
10
println!("{}", output);

进阶用法#

自定义Collector#

除了使用Prometheus Rust客户端提供的指标类型之外，您还可以创建自己的指标类型并将其注册到Prometheus客户端中。以下是如何在Rust中创建自定义Collector的示例：

1
use prometheus::{Collector, Counter, CounterVec, Desc, Metric, Opts, Registry};
2

3
struct MyCollector {
4
    counter: Counter,
5
}
6

7
impl MyCollector {
8
    fn new() -> MyCollector {
9
        let opts = Opts::new("my_counter", "My counter help").namespace("my_namespace");
10
        let counter = Counter::with_opts(opts).unwrap();
11

12
        MyCollector { counter }
13
    }
14
}
15

16
impl Collector for MyCollector {
17
    fn desc(&self) -> Vec<&Desc> {
18
        vec![self.counter.desc()]
19
    }
20

21
    fn collect(&self) -> Vec<Metric> {
22
        vec![self.counter.collect()[0].clone()]
23
    }
24
}
25

26
let my_collector = MyCollector::new();
27
let registry = Registry::new();
28
registry.register(Box::new(my_collector)).unwrap();

展开收起

自定义Exporter#

除了使用Prometheus Rust客户端提供的导出器之外，您还可以创建自己的导出器并将其注册到Prometheus客户端中。以下是如何在Rust中创建自定义Exporter的示例：

1
use prometheus::{Encoder, TextEncoder};
2

3
struct MyExporter {}
4

5
impl MyExporter {
6
    fn new() -> MyExporter {
7
        MyExporter {}
8
    }
9

10
    fn export(&self) -> String {
11
        let encoder = TextEncoder::new();
12
        let metric_families = prometheus::gather();
13

14
        let mut buffer = vec![];
15
        encoder.encode(&metric_families, &mut buffer).unwrap();
16

17
        String::from_utf8(buffer).unwrap()
18
    }
19
}
20

21
let my_exporter = MyExporter::new();
22
let output = my_exporter.export();
23
println!("{}", output);

展开收起

使用标准命名空间#

Prometheus使用标准命名空间来标识指标的来源。建议使用标准命名空间来标识您的指标。

1
use prometheus::{Counter, Opts, Registry};
2

3
let opts = Opts::new("my_counter", "My counter help").namespace("my_namespace");
4
let counter = Counter::with_opts(opts).unwrap();

避免指标名称冲突#

当使用多个Prometheus客户端时，可能会出现指标名称冲突的情况。为了避免这种情况，请使用唯一的指标名称。

1
use prometheus::{Counter, Opts, Registry};
2

3
let opts = Opts::new("my_counter", "My counter help").namespace("my_namespace");
4
let counter = Counter::with_opts(opts).unwrap();
5

6
register(Box::new(counter.clone())).unwrap();
7

8
let opts = Opts::new("my_counter", "My counter help").namespace("my_namespace_2");
9
let counter_2 = Counter::with_opts(opts).unwrap();
10

11
register(Box::new(counter_2.clone())).unwrap();

使用标签#

Prometheus使用标签来标识指标的维度。建议使用标签来标识您的指标。

1
use prometheus::{Counter, CounterVec, Opts, Registry};
2

3
let opts = Opts::new("my_counter", "My counter help").namespace("my_namespace");
4
let counter = CounterVec::new(opts, &["label_name"]).unwrap();
5

6
counter.with_label_values(&["label_value"]).inc();

使用Histogram#

当您需要记录事件分布时，请使用Histogram指标类型。

1
use prometheus::{Histogram, HistogramOpts, Opts, Registry};
2

3
let opts = HistogramOpts::new("my_histogram", "My histogram help").namespace("my_namespace");
4
let histogram = Histogram::with_opts(opts).unwrap();
5

6
histogram.observe(10.0);

使用Summary#

当您需要记录事件分布时，请使用Summary指标类型。

1
use prometheus::{Opts, Registry, Summary, SummaryOpts};
2

3
let opts = SummaryOpts::new("my_summary", "My summary help").namespace("my_namespace");
4
let summary = Summary::with_opts(opts).unwrap();
5

6
summary.observe(10.0);

总结#

在本教程中，我们介绍了如何使用Rust语言与Prometheus集成。我们提供了基础用法和进阶用法示例，以及最佳实践。希望这个教程对您有所帮助！

Rust语言从入门到精通系列 - 零基础lru缓存模块实战

Thu, 13 Apr 2023 00:00:00 GMT

LRU（Least Recently Used）是一种缓存替换算法，它的核心思想是当缓存满时，替换最近最少使用的数据。在实际应用中，LRU算法被广泛应用于缓存、页面置换等领域。Rust语言提供了一个lru模块，可以方便地实现LRU缓存。

基础用法#

Cargo.toml引入lru模块

1
lru = "0.10.0"

创建一个LRU缓存#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    cache.put("key2", "value2");
8
    assert_eq!(cache.get(&"key1"), Some(&"value1"));
9
    assert_eq!(cache.get(&"key2"), Some(&"value2"));
10
}

在这个示例中，我们创建了一个容量为2的LRU缓存，并添加了两个键值对。put方法可以添加键值对，get方法可以获取键对应的值。

获取不存在的键#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    assert_eq!(cache.get(&"key2"), None);
8
}

在这个示例中，我们尝试获取一个不存在的键，返回值为None。

更新缓存#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    cache.put("key2", "value2");
8
    cache.put("key1", "new_value");
9
    assert_eq!(cache.get(&"key1"), Some(&"new_value"));
10
}

在这个示例中，我们先添加了key1和key2两个键值对，然后更新了key1对应的值。

删除键值对#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    cache.put("key2", "value2");
8
    cache.pop(&"key1");
9
    assert_eq!(cache.get(&"key1"), None);
10
}

在这个示例中，我们先添加了key1和key2两个键值对，然后删除了key1对应的键值对。

获取缓存容量#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    assert_eq!(cache.capacity(), 2);
7
}

在这个示例中，我们获取了LRU缓存的容量。

获取缓存大小#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    assert_eq!(cache.len(), 1);
8
}

在这个示例中，我们获取了LRU缓存的大小。

清空缓存#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    cache.clear();
8
    assert_eq!(cache.len(), 0);
9
}

在这个示例中，我们清空了LRU缓存。

遍历缓存#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    cache.put("key2", "value2");
8
    for (key, value) in cache.iter() {
9
        println!("{}: {}", key, value);
10
    }
11
}

在这个示例中，我们遍历了LRU缓存中的所有键值对。

进阶用法#

自定义缓存替换策略#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn main() {
5
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
6
    cache.put("key1", "value1");
7
    cache.put("key2", "value2");
8
    cache.put("key3", "value3");
9
    assert_eq!(cache.get(&"key1"), None);
10
}

在这个示例中，我们使用了DefaultCachePolicy自定义了LRU缓存的替换策略，将缓存容量设置为2。当缓存满时，会替换最近最少使用的数据。在这个示例中，我们添加了三个键值对，当缓存满时，key1对应的键值对被替换。

自定义缓存等效性判断#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
#[derive(PartialEq, Eq, Hash)]
5
struct CustomKey {
6
    key1: String,
7
    key2: String,
8
}
9

10
fn main() {
11
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
12
    let key1 = CustomKey {
13
        key1: "123".to_string(),
14
        key2: "456".to_string(),
15
    };
16
    cache.put(key1.clone(), "value1");
17
    assert_eq!(cache.get(&key1), Some(&"value1"));
18
}

展开收起

在这个示例中，我们自定义了一个CustomKey结构体，并实现了PartialEq、Eq和Hash三个trait。然后我们使用CustomKey作为LRU缓存的键，实现了自定义的缓存等效性判断。

自定义缓存值类型#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
struct CustomValue {
5
    value1: String,
6
    value2: String,
7
}
8

9
fn main() {
10
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
11
    let value1 = CustomValue {
12
        value1: "123".to_string(),
13
        value2: "456".to_string(),
14
    };
15
    cache.put("key1", value1.clone());
16
    assert_eq!(cache.get(&"key1"), Some(&value1));
17
}

展开收起

在这个示例中，我们自定义了一个CustomValue结构体，并使用它作为LRU缓存的值类型。

使用LRU缓存实现Fibonacci数列#

1
use lru::LruCache;
2
use std::num::NonZeroUsize;
3

4
fn fibonacci(n: u32, cache: &mut LruCache<u32, u32>) -> u32 {
5
    if let Some(&result) = cache.get(&n) {
6
        return result;
7
    }
8
    let result = if n == 0 || n == 1 {
9
        n
10
    } else {
11
        fibonacci(n - 1, cache) + fibonacci(n - 2, cache)
12
    };
13
    cache.put(n, result);
14
    result
15
}
16

17
fn main() {
18
    let mut cache = LruCache::new(NonZeroUsize::new(10).unwrap());
19
    for i in 0..20 {
20
        println!("fibonacci({}) = {}", i, fibonacci(i, &mut cache));
21
    }
22
}

展开收起

在这个示例中，我们使用LRU缓存实现了Fibonacci数列的计算。在计算Fibonacci数列时，我们使用LRU缓存缓存已经计算过的结果，避免重复计算。

最佳实践#

避免频繁的缓存替换

当LRU缓存满时，会替换最近最少使用的数据。如果缓存替换过于频繁，会导致缓存的效率降低。因此，在使用LRU缓存时，应该根据实际情况合理设置缓存容量，避免频繁的缓存替换。

合理选择缓存键和值类型

LRU缓存的键和值类型可以是任意类型，但是为了提高缓存的效率，应该选择合适的类型。在选择缓存键和值类型时，应该考虑类型的大小、等效性判断等因素。

使用LRU缓存优化计算密集型任务

LRU缓存可以缓存计算结果，避免重复计算，因此可以用于优化计算密集型任务。在使用LRU缓存优化计算密集型任务时，应该根据实际情况合理设置缓存容量，避免频繁的缓存替换。

总结#

LRU缓存是一种常用的缓存替换算法，在实际应用中被广泛使用。Rust语言提供了一个lru模块，可以方便地实现LRU缓存。在使用LRU缓存时，应该根据实际情况合理设置缓存容量，选择合适的缓存键和值类型，避免频繁的缓存替换，以提高缓存的效率。

Rust语言从入门到精通系列 - PostgreSQL实战教程

Thu, 13 Apr 2023 00:00:00 GMT

PostgreSQL是一种开放源代码的对象-关系数据库管理系统(ORDBMS)，它强调在复杂应用程序中保持数据完整性和完整性。它可以在多个平台上运行，包括Linux，Unix，Windows和Mac OS X。同时，它支持许多流行的编程语言，如C，C++，Java，Python，Ruby和Rust。

Rust是一种新兴的系统级编程语言。它的设计目标是提供更好的内存安全，同时保持高效性和可靠性。Rust与PostgreSQL的结合，是一个强大的数据处理工具，它可以帮助开发人员开发高性能的应用程序，同时提供数据存储方案。

本教程将介绍如何使用Rust语言进行PostgreSQL开发。我们将深入了解PostgreSQL在Rust中的集成，并提供基础和进阶的示例。

基础用法#

创建一个数据库，以便我们在接下来的教程中使用它。可以使用以下命令创建一个名为“mydb”的数据库：

1
CREATE DATABASE mydb;

连接数据库#

在Rust中连接到PostgreSQL数据库的基本语法如下：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5
    // ...
6
    Ok(())
7
}

其中，“username”和“password”是数据库登录凭据，“localhost”是数据库服务器地址，“mydb”是要连接的数据库名称。

插入数据#

我们可以使用以下语法将数据插入PostgreSQL数据库中：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5

6
    let query = client.query("INSERT INTO users (name, email) VALUES ($1, $2)", &[&"John", &"john@example.com"],)?;
7
    println!("{:?}", query);
8
    Ok(())
9
}

这将向名为“users”的表中插入一行数据，包括两个字段：“name”和“email”。

查询数据#

我们可以使用以下语法查询数据：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5

6
    let rows = client.query("SELECT * FROM users", &[])?;
7
    for row in &rows {
8
        let name: String = row.get(0);
9
        let email: String = row.get(1);
10
        println!("{} {}", name, email);
11
    }
12
    Ok(())
13
}

这将从名为“users”的表中检索所有行，并显示每一行数据的“name”和“email”字段。

更新数据#

我们可以使用以下语法更新数据：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5

6
    let query = client.query("UPDATE users SET email = $1 WHERE name = $2", &[&"john@newemail.com", &"John"],)?;
7
    println!("{:?}", query);
8
    Ok(())
9
}

这将更新名为“users”的表中，名为“John”的行的“email”字段。

删除数据#

我们可以使用以下语法删除数据：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5

6
    let query = client.query("DELETE FROM users WHERE name = $1", &[&"John"],)?;
7
    println!("{:?}", query);
8
    Ok(())
9
}

这将删除名为“users”的表中名为“John”的行。

执行事务#

我们可以使用以下语法执行事务：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5
    let mut transaction = client.transaction()?;
6

7
    let query1 = transaction.query("INSERT INTO users (name, email) VALUES ($1, $2)", &[&"John", &"john@example.com"],)?;
8
    let query2 = transaction.query("INSERT INTO users (name, email) VALUES ($1, $2)", &[&"Jane", &"jane@example.com"],)?;
9
    println!("query1: {:?}", query1);
10
    println!("query2: {:?}", query2);
11

12
    transaction.commit()?;
13
    Ok(())
14
}

这将在名为“users”的表中插入两行数据，它们都包含字段：“name”和“email”。如果两个查询都正常完成，则它将提交事务。

执行复杂查询#

我们可以使用以下语法执行复杂查询：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5

6
    let rows = client.query(
7
        "SELECT u.name, u.email, p.title FROM users u INNER JOIN posts p ON u.id = p.user_id WHERE u.name = $1",
8
        &[&"John"],
9
    )?;
10
    for row in &rows {
11
        let name: String = row.get(0);
12
        let email: String = row.get(1);
13
        let title: String = row.get(2);
14
        println!("{} {} {}", name, email, title);
15
    }
16
    Ok(())
17
}

展开收起

这将从“users”表和“posts”表中检索数据，包括符合条件的“name”、“email”和“title”。

使用连接池#

连接池可以提高数据库连接的使用效率。我们可以使用以下语法设置连接池：

1
use postgres::{Client, NoTls};
2
use r2d2::Pool;
3
use r2d2_postgres::PostgresConnectionManager;
4

5
fn main() -> Result<(), Box<dyn Error>> {
6
    let manager = PostgresConnectionManager::new("postgresql://username:password@localhost/mydb", NoTls);
7
    let pool = Pool::builder().build(manager)?;
8

9
    let conn = pool.get()?;
10
    let rows = conn.query("SELECT * FROM users", &[])?;
11
    for row in &rows {
12
        let name: String = row.get(0);
13
        let email: String = row.get(1);
14
        println!("{} {}", name, email);
15
    }
16
    Ok(())
17
}

展开收起

在这个例子中，我们创建一个连接池，并使用它从数据库中检索数据。

进阶用法#

使用参数化查询语句#

参数化查询语句可以有效地防止SQL注入攻击。我们可以使用以下语法执行参数化查询：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5

6
    let rows = client.query("SELECT * FROM users WHERE age > $1 AND age < $2", &[&18, &30])?;
7
    for row in &rows {
8
        let name: String = row.get(0);
9
        let email: String = row.get(1);
10
        let age: String = row.get(2);
11
        println!("{} {} {}", name, email, age);
12
    }
13
    Ok(())
14
}

在这个例子中，我们使用了两个参数化查询参数：“1”和“1”和“1”和“2”，并将它们分别赋值为18和30。这将检索年龄在18到30之间的所有用户。

使用批量插入#

我们可以使用以下语法批量插入数据：

1
use postgres::{Client, NoTls};
2

3
fn main() -> Result<(), Box<dyn Error>> {
4
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
5

6
    let rows = vec![
7
        ("john","john@example.com", 25),
8
        ("jane", "jane@example.com", 30),
9
        ("jack", "jack@example.com", 35),
10
    ];
11

12
    let stmt = client.prepare("INSERT INTO users (name, email, age) VALUES ($1, $2, $3)")?;
13
    for row in &rows {
14
        client.execute(&stmt, &[&row.0, &row.1, &row.2])?;
15
    }
16
    Ok(())
17
}

展开收起

这将向名为“users”的表中插入三行数据，每行包括三个字段：“name”、“email”和“age”。

使用JSON类型#

PostgreSQL支持JSON和JSONB类型。我们可以使用以下语法将数据插入JSONB字段中：

1
use postgres::{Client, NoTls};
2
use serde::{Deserialize, Serialize};
3

4
#[derive(Debug, Serialize, Deserialize)]
5
struct User {
6
    name: String,
7
    email: String,
8
    age: i32,
9
}
10

11
fn main() -> Result<(), Box<dyn Error>> {
12
    let mut client = Client::connect("postgresql://username:password@localhost/mydb", NoTls)?;
13

14
    let user = User {
15
        name: "john".to_string(),
16
        email: "john@example.com".to_string(),
17
        age: 25,
18
    };
19
    let user_json = serde_json::to_string(&user).unwrap();
20

21
    client.execute(
22
        "INSERT INTO users (name, email, data) VALUES ($1, $2, $3)",
23
        &[&user.name, &user.email, &json::json!(&user_json)],
24
    )?;
25
    Ok(())
26
}

展开收起

在这个例子中，我们将用户对象编码为JSON字符串，然后使用JSONB类型将其插入到名为“users”的表中的“data”字段中。

使用异步PostgreSQL客户端#

异步PostgreSQL客户端可以提高数据库操作的效率和性能。我们可以使用以下语法执行异步查询：

1
use futures::TryStreamExt;
2
use tokio_postgres::{NoTls, Row};
3

4
#[tokio::main]
5
async fn main() -> Result<(), Box<dyn std::error::Error>> {
6
    let (client, connection) =
7
        tokio_postgres::connect("host=localhost user=username password=password dbname=mydb", NoTls)
8
            .await?;
9
    tokio::spawn(async move {
10
        if let Err(e) = connection.await {
11
            eprintln!("connection error: {}", e);
12
        }
13
    });
14

15
    let rows = client
16
        .query("SELECT * FROM users WHERE age > $1 AND age < $2", &[&18, &30])
17
        .await?;
18
    for row in rows.iter() {
19
        let name: String = row.try_get(0)?;
20
        let email: String = row.try_get(1)?;
21
        let age: i32 = row.try_get(2)?;
22
        println!("{} {} {}", name, email, age);
23
    }
24
    Ok(())
25
}

展开收起

在这个例子中，我们使用异步PostgreSQL客户端查询年龄在18到30之间的所有用户，并使用Tokio运行时实现异步操作。

使用异步连接池#

我们可以使用以下语法设置异步连接池：

1
use tokio_postgres::{Config, NoTls};
2
use bb8_postgres::{bb8::Pool, PostgresConnectionManager};
3

4
#[tokio::main]
5
async fn main() -> Result<(), Box<dyn std::error::Error>> {
6
    let mut config = Config::new();
7
    config.host("localhost");
8
    config.user("username");
9
    config.password("password");
10
    config.dbname("mydb");
11
    let manager = PostgresConnectionManager::new(config, NoTls);
12
    let pool = Pool::builder().max_size(15).build(manager).await?;
13

14
    let conn = pool.get().await?;
15
    let rows = conn
16
        .query("SELECT * FROM users WHERE age > $1 AND age < $2", &[&18, &30])
17
        .await?;
18
    for row in rows.iter() {
19
        let name: String = row.try_get(0)?;
20
        let email: String = row.try_get(1)?;
21
        let age: i32 = row.try_get(2)?;
22
        println!("{} {} {}", name, email, age);
23
    }
24
    Ok(())
25
}

展开收起

在这个例子中，我们使用异步连接池从名为“users”的表中检索年龄在18到30之间的所有用户。

使用ORM#

ORM可以简化数据访问和管理。我们可以使用以下语法使用Diesel ORM查询数据：

1
use diesel::{prelude::*, pg::PgConnection, result::Error};
2

3
#[derive(Queryable)]
4
struct User {
5
    pub id: i32,
6
    pub name: String,
7
    pub email: String,
8
    pub age: i32,
9
}
10

11
fn main() -> Result<(), Error> {
12
    let url = "postgresql://username:password@localhost/mydb";
13
    let connection = PgConnection::establish(&url).unwrap();
14

15
    let results = users
16
        .filter(age.gt(18).and(age.lt(30)))
17
        .load::<User>(&connection)
18
        .unwrap();
19
    for user in results {
20
        println!("{} {} {}", user.name, user.email, user.age);
21
    }
22
    Ok(())
23
}

展开收起

在这个例子中，我们使用Diesel ORM查询名为“users”的表中年龄在18到30之间的所有用户。ORM将自动生成与查询相关的代码。

最佳实践#

以下是在Rust中使用PostgreSQL数据库的一些最佳实践：

使用参数化查询语句防止SQL注入攻击。
使用连接池提高数据库连接的使用效率。
使用异步PostgreSQL客户端提高数据库访问的效率和性能。
使用ORM简化数据访问和管理。
将JSON数据存储为JSONB类型。

结论#

PostgreSQL是一种强大的关系型数据库管理系统，可以与Rust编程语言无缝集成。在本教程中，我们介绍了如何在Rust中使用PostgreSQL并提供了基础和进阶的示例，同时讨论了一些最佳实践。使用Rust和PostgreSQL的组合，您可以开发高性能、可靠和安全的应用程序。

Rust语言从入门到精通系列 - InfluxDB 1.x实战教程

Thu, 13 Apr 2023 00:00:00 GMT

Rust 是一种系统级编程语言，具有高性能和内存安全性。InfluxDB 是一个开源的时间序列数据库，用于存储、查询和可视化大规模数据集。Rust 语言可以与 InfluxDB 集成，提供高效的数据处理和存储能力。

本教程将介绍 Rust 语言如何与 InfluxDB 集成，包括基础用法和进阶用法和完整的示例代码。

基础用法#

安装 InfluxDB Rust 客户端#

首先，我们需要安装 InfluxDB Rust 客户端。可以在 Cargo.toml 文件中添加以下依赖项：

1
[dependencies]
2
influxdb = "0.14.0"

连接到 InfluxDB#

我们需要创建一个 InfluxDB 连接。可以使用以下代码创建一个连接：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5
}

这将创建一个名为“my_database”的数据库连接。

插入数据#

可以使用以下代码将数据插入到 InfluxDB 中：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::write_query("my_measurement")
7
        .add_field("value", 42)
8
        .build();
9

10
    let _ = client.query(&query);
11
}

这将在名为“my_measurement”的测量中插入一个名为“value”的字段，该字段的值为 42。

查询数据#

可以使用以下代码从 InfluxDB 中查询数据：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_read_query("SELECT * FROM my_measurement");
7

8
    let result = client.query(&query);
9

10
    for row in result.unwrap().rows {
11
        println!("{:?}", row);
12
    }
13
}

这将从名为“my_measurement”的测量中查询所有字段，并打印结果。

删除数据#

可以使用以下代码从 InfluxDB 中删除数据：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_query("DELETE FROM my_measurement WHERE time > now() - 1h");
7

8
    let _ = client.query(&query);
9
}

这将从名为“my_measurement”的测量中删除 1 小时前的所有数据。

创建数据库#

可以使用以下代码创建一个新的 InfluxDB 数据库：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_query("CREATE DATABASE my_new_database");
7

8
    let _ = client.query(&query);
9
}

这将创建一个名为“my_new_database”的新数据库。

删除数据库#

可以使用以下代码删除一个 InfluxDB 数据库：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_query("DROP DATABASE my_database");
7

8
    let _ = client.query(&query);
9
}

这将删除名为“my_database”的数据库。

创建测量#

可以使用以下代码创建一个新的 InfluxDB 测量：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_query("CREATE MEASUREMENT my_new_measurement");
7

8
    let _ = client.query(&query);
9
}

这将创建一个名为“my_new_measurement”的新测量。

删除测量#

可以使用以下代码删除一个 InfluxDB 测量：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_query("DROP MEASUREMENT my_measurement");
7

8
    let _ = client.query(&query);
9
}

这将删除名为“my_measurement”的测量。

进阶用法#

批量插入数据#

如果需要插入大量数据，可以使用以下代码批量插入数据：

1
use influxdb::{Client, Query, Timestamp};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let mut batch = Vec::new();
7

8
    for i in 0..1000 {
9
        let point = Point::new("my_measurement")
10
            .add_field("value", i)
11
            .add_timestamp(Timestamp::Hours(i))
12
            .to_owned();
13

14
        batch.push(point);
15
    }
16

17
    let query = Query::write_query(&batch).build();
18

19
    let _ = client.query(&query);
20
}

展开收起

这将在名为“my_measurement”的测量中插入 1000 个数据点。

使用标签#

可以使用标签来组织数据。以下代码演示如何在插入数据时使用标签：

1
use influxdb::{Client, Point, Query, Timestamp};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let point = Point::new("my_measurement")
7
        .add_field("value", 42)
8
        .add_tag("region", "us-west")
9
        .add_tag("host", "server1")
10
        .add_timestamp(Timestamp::Now)
11
        .to_owned();
12

13
    let query = Query::write_query(&[point]).build();
14

15
    let _ = client.query(&query);
16
}

展开收起

这将在名为“my_measurement”的测量中插入一个名为“value”的字段，以及两个标签“region”和“host”。

使用时间戳#

可以使用不同的时间戳格式来插入数据。以下代码演示如何在插入数据时使用 Unix 时间戳：

1
use influxdb::{Client, Point, Query, Timestamp};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let point = Point::new("my_measurement")
7
        .add_field("value", 42)
8
        .add_timestamp(Timestamp::Seconds(1234567890))
9
        .to_owned();
10

11
    let query = Query::write_query(&[point]).build();
12

13
    let _ = client.query(&query);
14
}

这将在名为“my_measurement”的测量中插入一个名为“value”的字段，并使用 Unix 时间戳 1234567890。

使用持续时间#

可以使用持续时间来查询数据。以下代码演示如何查询最近 1 小时的数据：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_read_query("SELECT * FROM my_measurement WHERE time > now() - 1h");
7

8
    let result = client.query(&query);
9

10
    for row in result.unwrap().rows {
11
        println!("{:?}", row);
12
    }
13
}

这将从名为“my_measurement”的测量中查询最近 1 小时的所有数据。

使用聚合函数#

可以使用聚合函数来查询数据。以下代码演示如何查询最近 1 小时的平均值：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_read_query("SELECT MEAN(value) FROM my_measurement WHERE time > now() - 1h");
7

8
    let result = client.query(&query);
9

10
    for row in result.unwrap().rows {
11
        println!("{:?}", row);
12
    }
13
}

这将从名为“my_measurement”的测量中查询最近 1 小时的平均值。

使用限制#

可以使用限制来查询数据。以下代码演示如何查询最近 10 条数据：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_read_query("SELECT * FROM my_measurement LIMIT 10");
7

8
    let result = client.query(&query);
9

10
    for row in result.unwrap().rows {
11
        println!("{:?}", row);
12
    }
13
}

这将从名为“my_measurement”的测量中查询最近 10 条数据。

使用排序#

可以使用排序来查询数据。以下代码演示如何查询最近 1 小时的数据，并按时间戳排序：

1
use influxdb::{Client, Query};
2

3
fn main() {
4
    let client = Client::new("http://localhost:8086", "my_database");
5

6
    let query = Query::raw_read_query("SELECT * FROM my_measurement WHERE time > now() - 1h ORDER BY time");
7

8
    let result = client.query(&query);
9

10
    for row in result.unwrap().rows {
11
        println!("{:?}", row);
12
    }
13
}

这将从名为“my_measurement”的测量中查询最近 1 小时的所有数据，并按时间戳排序。

最佳实践#

使用连接池#

为了提高性能，建议使用连接池来管理 InfluxDB 连接。以下代码演示如何使用连接池：

1
use influxdb::{Client, Query, Timestamp};
2
use r2d2::{Pool, PooledConnection};
3
use r2d2_influxdb::{ConnectionManager, Error};
4

5
fn main() -> Result<(), Error> {
6
    let manager = ConnectionManager::new("http://localhost:8086", "my_database");
7
    let pool = Pool::builder().max_size(10).build(manager)?;
8
    let client = Client::new_with_pool(pool);
9

10
    let point = Point::new("my_measurement")
11
        .add_field("value", 42)
12
        .add_timestamp(Timestamp::Now)
13
        .to_owned();
14

15
    let query = Query::write_query(&[point]).build();
16

17
    let conn: PooledConnection<ConnectionManager> = client.get_conn()?;
18
    conn.query(&query)?;
19

20
    Ok(())
21
}

展开收起

这将创建一个连接池，最大连接数为 10，并使用连接池来管理 InfluxDB 连接。

使用线程池#

为了提高并发性能，建议使用线程池来处理数据插入和查询。以下代码演示如何使用线程池：

1
use influxdb::{Client, Point, Query, Timestamp};
2
use std::sync::Arc;
3
use rayon::prelude::*;
4

5
fn main() {
6
    let client = Arc::new(Client::new("http://localhost:8086", "my_database"));
7

8
    let points: Vec<Point> = (0..1000)
9
        .into_par_iter()
10
        .map(|i| {
11
            Point::new("my_measurement")
12
                .add_field("value", i)
13
                .add_timestamp(Timestamp::Hours(i))
14
                .to_owned()
15
        })
16
        .collect();
17

18
    points.into_par_iter().for_each(|point| {
19
        let query = Query::write_query(&[point]).build();
20
        let _ = client.query(&query);
21
    });
22
}

展开收起

这将创建一个线程池，并使用线程池来处理 1000 个数据点的插入。

使用缓存#

为了提高查询性能，建议使用缓存来缓存查询结果。以下代码演示如何使用缓存：

1
use influxdb::{Client, Query};
2
use lru_cache::LruCache;
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my_database");
6
    let mut cache = LruCache::new(100);
7

8
    let query = Query::raw_read_query("SELECT * FROM my_measurement WHERE time > now() - 1h");
9

10
    let result = if let Some(result) = cache.get(&query.to_string()) {
11
        result
12
    } else {
13
        let result = client.query(&query).unwrap();
14
        cache.put(query.to_string(), result.clone());
15
        &result
16
    };
17

18
    for row in result.rows {
19
        println!("{:?}", row);
20
    }
21
}

展开收起

这将创建一个 LRU 缓存，最大容量为 100，并使用缓存来缓存查询结果。

结论#

本教程介绍了如何在 Rust 语言中使用 InfluxDB，包括基础用法和进阶用法以及最佳实践和示例代码。希望这个教程对您有所帮助，让您更好地使用 Rust 语言和 InfluxDB。

Rust语言从入门到精通系列 - InfluxDB 2.x实战教程

Thu, 13 Apr 2023 00:00:00 GMT

Rust 是一种系统编程语言，它具有高性能、内存安全和并发性等特点。InfluxDB 是一个开源的时序数据库，它专门用于存储和查询时间序列数据。InfluxDB 2.x 是 InfluxDB 的新版本，它提供了更好的性能和更好的用户体验。Rust 语言提供了 InfluxDB 2.x 的官方客户端库，可以方便地在 Rust 项目中使用 InfluxDB 2.x。

本教程将介绍如何在 Rust 项目中使用 InfluxDB 2.x，包括基础用法和进阶用法。我们将提供示例代码，帮助读者更好地理解和使用 InfluxDB 2.x。

InfluxDB 2.x 版本重写了查询系统, 引入了全新的 Flux 语言查询。相比于 SQL，个人感觉是一种退步。详细的 Flux 语法参考官方文档。

基础用法#

创建数据库#

在使用 InfluxDB 2.x 之前，需要先创建一个数据库。可以使用 InfluxDB 2.x 的 Web 界面或命令行工具来创建数据库。在本教程中，我们将使用命令行工具来创建数据库。

1
use influxdb2::Client;
2
use influxdb2::models::CreateDatabaseRequest;
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let db_name = "my-db";
7
    let request = CreateDatabaseRequest::new(db_name);
8
    client.create_database(request).unwrap();
9
}

写入数据#

写入数据是 InfluxDB 2.x 的主要功能之一。可以使用 InfluxDB 2.x 的客户端库来写入数据。在写入数据之前，需要先创建一个 Bucket。

1
use influxdb2::Client;
2
use influxdb2::models::{CreateBucketRequest, WritePrecision, Point, FieldValue};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let bucket_name = "my-bucket";
7
    let org_id = "my-org";
8
    let request = CreateBucketRequest::new(bucket_name, org_id);
9
    client.create_bucket(request).unwrap();
10

11
    let point = Point::new("my-measurement")
12
        .add_field("my-field", FieldValue::Integer(1))
13
        .add_tag("my-tag", "my-value")
14
        .timestamp(1626464400000, WritePrecision::Ms);
15
    let points = vec![point];
16
    client.write_points(bucket_name, points).unwrap();
17
}

展开收起

查询数据#

查询数据是 InfluxDB 2.x 的另一个主要功能。可以使用 InfluxDB 2.x 的客户端库来查询数据。在查询数据之前，需要先创建一个查询语句。

1
use influxdb2::Client;
2
use influxdb2::models::{QueryRequest, Query, QueryType};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let query = Query::new("SELECT * FROM my-measurement");
7
    let request = QueryRequest::new(query, QueryType::Flux);
8
    let result = client.query(request).unwrap();
9
    println!("{:?}", result);
10
}

删除数据#

删除数据是 InfluxDB 2.x 的另一个功能。可以使用 InfluxDB 2.x 的客户端库来删除数据。在删除数据之前，需要先创建一个删除语句。

1
use influxdb2::Client;
2
use influxdb2::models::{DeleteRequest, Predicate};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let predicate = Predicate::new("my-tag", "my-value");
7
    let request = DeleteRequest::new("my-measurement", predicate);
8
    client.delete(request).unwrap();
9
}

创建用户#

在使用 InfluxDB 2.x 之前，需要先创建一个用户。可以使用 InfluxDB 2.x 的 Web 界面或命令行工具来创建用户。在本教程中，我们将使用命令行工具来创建用户。

1
use influxdb2::Client;
2
use influxdb2::models::{CreateUserRequest, UserPermission};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let username = "my-user";
7
    let password = "my-password";
8
    let request = CreateUserRequest::new(username, password);
9
    client.create_user(request).unwrap();
10

11
    let permission = UserPermission::new("my-bucket", "read");
12
    client.add_permission(username, permission).unwrap();
13
}

创建授权令牌#

在使用 InfluxDB 2.x 之前，需要先创建一个授权令牌。可以使用 InfluxDB 2.x 的 Web 界面或命令行工具来创建授权令牌。在本教程中，我们将使用命令行工具来创建授权令牌。

1
use influxdb2::Client;
2
use influxdb2::models::{CreateTokenRequest, Permission};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let request = CreateTokenRequest::new(vec![Permission::new("my-bucket", "read")]);
7
    let result = client.create_token(request).unwrap();
8
    println!("{:?}", result);
9
}

创建任务#

在 InfluxDB 2.x 中，任务是一种自动化的操作。可以使用 InfluxDB 2.x 的 Web 界面或命令行工具来创建任务。在本教程中，我们将使用命令行工具来创建任务。

1
use influxdb2::Client;
2
use influxdb2::models::{CreateTaskRequest, Cron};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let query = "SELECT * FROM my-measurement";
7
    let cron = Cron::new("0 * * * * * *");
8
    let request = CreateTaskRequest::new("my-task", query, cron);
9
    client.create_task(request).unwrap();
10
}

进阶用法#

使用 Flux 查询语言#

Flux 是 InfluxDB 2.x 的查询语言，它提供了更强大的查询功能。可以使用 InfluxDB 2.x 的客户端库来查询 Flux 语句。

1
use influxdb2::Client;
2
use influxdb2::models::{QueryRequest, Query, QueryType};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let query = Query::new("from(bucket:\"my-bucket\") |> range(start: -1h) |> filter(fn: (r) => r._measurement == \"my-measurement\") |> limit(n: 10)");
7
    let request = QueryRequest::new(query, QueryType::Flux);
8
    let result = client.query(request).unwrap();
9
    println!("{:?}", result);
10
}

使用 Task API 创建任务#

可以使用 Task API 来创建任务，这样可以更方便地管理任务。可以使用 InfluxDB 2.x 的客户端库来创建任务。

1
use influxdb2::Client;
2
use influxdb2::models::{CreateTaskRequest, Cron, TaskStatus};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let query = "SELECT * FROM my-measurement";
7
    let cron = Cron::new("0 * * * * * *");
8
    let request = CreateTaskRequest::new("my-task", query, cron);
9
    client.create_task(request).unwrap();
10

11
    let status = TaskStatus::Inactive;
12
    client.update_task_status("my-task", status).unwrap();
13
}

使用 Write API 批量写入数据#

可以使用 Write API 来批量写入数据，这样可以提高写入数据的效率。可以使用 InfluxDB 2.x 的客户端库来批量写入数据。

1
use influxdb2::Client;
2
use influxdb2::models::{WriteRequest, WritePrecision, Point, FieldValue};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let bucket_name = "my-bucket";
7
    let point1 = Point::new("my-measurement")
8
        .add_field("my-field", FieldValue::Integer(1))
9
        .add_tag("my-tag", "my-value")
10
        .timestamp(1626464400000, WritePrecision::Ms);
11
    let point2 = Point::new("my-measurement")
12
        .add_field("my-field", FieldValue::Integer(2))
13
        .add_tag("my-tag", "my-value")
14
        .timestamp(1626464401000, WritePrecision::Ms);
15
    let points = vec![point1, point2];
16
    let request = WriteRequest::new(points);
17
    client.write(request).unwrap();
18
}

展开收起

使用 Query API 查询数据#

可以使用 Query API 来查询数据，这样可以更方便地查询数据。可以使用 InfluxDB 2.x 的客户端库来查询数据。

1
use influxdb2::Client;
2
use influxdb2::models::{QueryRequest, Query, QueryType};
3

4
fn main() {
5
    let client = Client::new("http://localhost:8086", "my-token");
6
    let query = Query::new("from(bucket:\"my-bucket\") |> range(start: -1h) |> filter(fn: (r) => r._measurement == \"my-measurement\") |> limit(n: 10)");
7
    let request = QueryRequest::new(query, QueryType::Flux);
8
    let result = client.query(request).unwrap();
9
    println!("{:?}", result);
10
}

最佳实践#

使用环境变量存储认证信息#

在实际应用中，通常不会将认证信息硬编码到代码中。可以使用环境变量来存储认证信息，这样可以更安全地管理认证信息。

1
use influxdb2::Client;
2
use influxdb2::models::CreateDatabaseRequest;
3
use std::env;
4

5
fn main() {
6
    let url = env::var("INFLUXDB_URL").unwrap();
7
    let token = env::var("INFLUXDB_TOKEN").unwrap();
8
    let client = Client::new(&url, &token);
9

10
    let db_name = "my-db";
11
    let request = CreateDatabaseRequest::new(db_name);
12
    client.create_database(request).unwrap();
13
}

使用 Rust 的异步编程模型#

在实际应用中，通常需要处理大量的数据。可以使用 Rust 的异步编程模型来提高数据处理的效率。

1
use influxdb2::Client;
2
use influxdb2::models::{WriteRequest, WritePrecision, Point, FieldValue};
3
use futures::executor::block_on;
4

5
async fn write_data(client: &Client) {
6
    let bucket_name = "my-bucket";
7
    let point1 = Point::new("my-measurement")
8
        .add_field("my-field", FieldValue::Integer(1))
9
        .add_tag("my-tag", "my-value")
10
        .timestamp(1626464400000, WritePrecision::Ms);
11
    let point2 = Point::new("my-measurement")
12
        .add_field("my-field", FieldValue::Integer(2))
13
        .add_tag("my-tag", "my-value")
14
        .timestamp(1626464401000, WritePrecision::Ms);
15
    let points = vec![point1, point2];
16
    let request = WriteRequest::new(points);
17
    client.write(request).await.unwrap();
18
}
19

20
fn main() {
21
    let url = "http://localhost:8086";
22
    let token = "my-token";
23
    let client = Client::new(url, token);
24

25
    let future = write_data(&client);
26
    block_on(future);
27
}

展开收起

使用连接池提高效率#

在实际应用中，通常需要处理大量的请求。可以使用连接池来提高请求处理的效率。

1
use influxdb2::Client;
2
use influxdb2::models::CreateDatabaseRequest;
3
use r2d2::Pool;
4
use r2d2_influxdb2::InfluxDB2ConnectionManager;
5

6
fn main() {
7
    let url = "http://localhost:8086";
8
    let token = "my-token";
9
    let manager = InfluxDB2ConnectionManager::new(url, token);
10
    let pool = Pool::builder().max_size(10).build(manager).unwrap();
11
    let client = Client::new(pool);
12

13
    let db_name = "my-db";
14
    let request = CreateDatabaseRequest::new(db_name);
15
    client.create_database(request).unwrap();
16
}

展开收起

结论#

本教程介绍了如何在 Rust 项目中使用 InfluxDB 2.x，包括基础用法和进阶用法。我们提供了示例代码，帮助读者更好地理解和使用 InfluxDB 2.x。最后，我们提供了一些最佳实践，帮助读者更好地使用 InfluxDB 2.x。

Rust语言从入门到精通系列 - Amazon DynamoDB实战教程

Thu, 13 Apr 2023 00:00:00 GMT

Rust语言从入门到精通系列 - Memcached实战教程

Thu, 13 Apr 2023 00:00:00 GMT

Memcached 是一种高性能、分布式的内存对象缓存系统，可用于加速动态 Web 应用程序。Rust 是一种系统级编程语言，具有内存安全、高性能和并发性等特点。Rust 语言的 Memcached 库提供了 Memcached 协议的实现，使得开发者可以在 Rust 中使用 Memcached。

基础用法#

创建连接#

使用 Rust 语言 Memcached 需要先创建一个连接。可以使用memcached::Client结构体来创建一个连接：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
}

存储数据#

使用Client::set方法可以将数据存储到 Memcached 中：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
    client.set("key", "value", 3600).unwrap();
6
}

获取数据#

使用Client::get方法可以从 Memcached 中获取数据：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
    let value: Option<String> = client.get("key").unwrap();
6
    println!("{:?}", value);
7
}

删除数据#

使用Client::delete方法可以从 Memcached 中删除数据：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
    client.delete("key").unwrap();
6
}

替换数据#

使用Client::replace方法可以替换 Memcached 中的数据：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
    client.set("key", "value", 3600).unwrap();
6
    client.replace("key", "new value", 3600).unwrap();
7
}

添加数据#

使用Client::add方法可以向 Memcached 中添加数据：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
    client.add("key", "value", 3600).unwrap();
6
}

自增和自减#

使用Client::increment方法可以将 Memcached 中的值自增：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
    client.set("counter", "1", 3600).unwrap();
6
    let new_value: Option<u64> = client.increment("counter", 1).unwrap();
7
    println!("{:?}", new_value);
8
}

使用Client::decrement方法可以将 Memcached 中的值自减：

1
use memcached::Client;
2

3
fn main() {
4
    let client = Client::connect("localhost:11211").unwrap();
5
    client.set("counter", "1", 3600).unwrap();
6
    let new_value: Option<u64> = client.decrement("counter", 1).unwrap();
7
    println!("{:?}", new_value);
8
}

进阶用法#

自定义序列化和反序列化#

默认情况下，Rust 语言 Memcached 使用 JSON 格式进行序列化和反序列化。但是，开发者可以自定义序列化和反序列化方法。例如，可以使用 bincode 库进行序列化和反序列化：

1
use memcached::{Client, ProtoType};
2
use bincode::{serialize, deserialize};
3

4
#[derive(Serialize, Deserialize, Debug)]
5
struct User {
6
    name: String,
7
    age: u8,
8
}
9

10
fn main() {
11
    let client = Client::connect("localhost:11211").unwrap();
12
    client.set_serializer(ProtoType::Bincode, |val| serialize(val).unwrap());
13
    client.set_deserializer(ProtoType::Bincode, |bytes| deserialize(bytes).unwrap());
14
    let user = User { name: "Alice".to_string(), age: 20 };
15
    client.set("user", &user, 3600).unwrap();
16
    let user: Option<User> = client.get("user").unwrap();
17
    println!("{:?}", user);
18
}

展开收起

自定义连接池#

默认情况下，Rust 语言 Memcached 使用单个连接。但是，开发者可以自定义连接池。例如，可以使用 r2d2 库进行连接池管理：

1
use memcached::{Client, Connection};
2
use r2d2::{Pool, PooledConnection};
3
use r2d2_memcached::{MemcachedConnectionManager, MemcachedConnection};
4

5
fn main() {
6
    let manager = MemcachedConnectionManager::new("localhost:11211");
7
    let pool = Pool::builder().max_size(10).build(manager).unwrap();
8
    let client = Client::with_connection(|| {
9
        let conn: PooledConnection<MemcachedConnectionManager> = pool.get().unwrap();
10
        Connection::new(conn)
11
    });
12
    client.set("key", "value", 3600).unwrap();
13
}

自定义哈希算法#

默认情况下，Rust 语言 Memcached 使用一致性哈希算法进行数据分片。但是，开发者可以自定义哈希算法。例如，可以使用 crc32 库进行哈希计算：

1
use memcached::{Client, ProtoType, HashType};
2
use crc::{crc32, Hasher32};
3

4
fn crc32_hash(key: &[u8]) -> u32 {
5
    let mut hasher = crc32::Digest::new(crc32::IEEE);
6
    hasher.write(key);
7
    hasher.sum32()
8
}
9

10
fn main() {
11
    let client = Client::connect("localhost:11211").unwrap();
12
    client.set_hash_fn(HashType::Custom(crc32_hash));
13
    client.set_serializer(ProtoType::Raw, |val| val.to_vec());
14
    client.set_deserializer(ProtoType::Raw, |bytes| bytes);
15
    client.set(b"key", b"value", 3600).unwrap();
16
    let value: Option<Vec<u8>> = client.get(b"key").unwrap();
17
    println!("{:?}", value);
18
}

展开收起

自定义协议#

默认情况下，Rust 语言 Memcached 使用 Memcached 协议进行通信。但是，开发者可以自定义协议。例如，可以使用 HTTP 协议进行通信：

1
use memcached::{Client, Connection, ProtoType};
2
use reqwest::blocking::Client as HttpClient;
3

4
struct HttpConnection {
5
    client: HttpClient,
6
}
7

8
impl Connection for HttpConnection {
9
    fn send(&mut self, request: &[u8]) -> Vec<u8> {
10
        let url = "http://localhost:8080/memcached".to_string();
11
        let response = self.client.post(&url).body(request.to_vec()).send().unwrap();
12
        response.bytes().unwrap().to_vec()
13
    }
14
}
15

16
fn main() {
17
    let client = Client::with_connection(|| HttpConnection {
18
        client: HttpClient::new(),
19
    });
20
    client.set_serializer(ProtoType::Raw, |val| val.to_vec());
21
    client.set_deserializer(ProtoType::Raw, |bytes| bytes);
22
    client.set(b"key", b"value", 3600).unwrap();
23
    let value: Option<Vec<u8>> = client.get(b"key").unwrap();
24
    println!("{:?}", value);
25
}

展开收起

最佳实践#

使用连接池

在高并发场景下，使用连接池可以提高性能和稳定性。可以使用 r2d2 库进行连接池管理。

使用自定义哈希算法

在分布式场景下，使用自定义哈希算法可以提高数据分片的灵活性和可控性。

使用自定义协议

在特殊场景下，可以使用自定义协议进行通信，以满足特定的需求。

使用异步 IO

在高并发场景下，使用异步 IO 可以提高性能和吞吐量。可以使用 tokio 库进行异步 IO 编程。

总结#

Rust 语言 Memcached 提供了 Memcached 协议的实现，可以方便地在 Rust 中使用 Memcached。本教程介绍了 Rust 语言 Memcached 的基础用法和进阶用法，并提供了最佳实践。开发者可以根据自己的需求选择合适的用法。

Rust语言从入门到精通系列 - Http客户端reqwest模块实战

Thu, 13 Apr 2023 00:00:00 GMT

Reqwest 是一个 Rust 语言的 HTTP 客户端库，它提供了简单易用的 API，可以发送 HTTP 请求并处理响应。Reqwest 支持同步和异步操作，可以用于编写 Web 服务，爬虫，测试等应用。

基础用法#

发送 GET 请求#

1
use reqwest::blocking::Client;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let client = Client::new();
5
    let response = client.get("https://httpbin.org/get").send()?;
6
    println!("{}", response.text()?);
7
    Ok(())
8
}

这个例子中，我们使用 blocking 模块中的 Client 创建了一个 HTTP 客户端，然后使用 get 方法发送了一个 GET 请求，请求了 httpbin.org 的/get 接口，并使用 text 方法获取响应内容。

发送 POST 请求#

1
use reqwest::blocking::Client;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let client = Client::new();
5
    let response = client.post("https://httpbin.org/post")
6
        .body("hello world")
7
        .send()?;
8
    println!("{}", response.text()?);
9
    Ok(())
10
}

这个例子中，我们使用 post 方法发送了一个 POST 请求，请求了 httpbin.org 的/post 接口，并使用 body 方法设置请求体。

发送 JSON 请求#

1
use reqwest::blocking::Client;
2
use serde_json::json;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::new();
6
    let data = json!({
7
        "name": "Alice",
8
        "age": 20
9
    });
10
    let response = client.post("https://httpbin.org/post")
11
        .json(&data)
12
        .send()?;
13
    println!("{}", response.text()?);
14
    Ok(())
15
}

展开收起

这个例子中，我们使用 json!宏创建了一个 JSON 对象，然后使用 json 方法设置请求体，发送了一个 POST 请求。

发送表单请求#

1
use reqwest::blocking::Client;
2
use std::collections::HashMap;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::new();
6
    let mut data = HashMap::new();
7
    data.insert("name", "Alice");
8
    data.insert("age", "20");
9
    let response = client.post("https://httpbin.org/post")
10
        .form(&data)
11
        .send()?;
12
    println!("{}", response.text()?);
13
    Ok(())
14
}

这个例子中，我们使用 HashMap 创建了一个表单数据，然后使用 form 方法设置请求体，发送了一个 POST 请求。

发送带有 Header 的请求#

1
use reqwest::blocking::Client;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let client = Client::new();
5
    let response = client.get("https://httpbin.org/get")
6
        .header("X-My-Header", "hello")
7
        .send()?;
8
    println!("{}", response.text()?);
9
    Ok(())
10
}

这个例子中，我们使用 header 方法设置了一个自定义的 Header，发送了一个 GET 请求。

发送带有 Cookie 的请求#

1
use reqwest::blocking::Client;
2
use reqwest::header::COOKIE;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::new();
6
    let response = client.get("https://httpbin.org/get")
7
        .header(COOKIE, "name=value")
8
        .send()?;
9
    println!("{}", response.text()?);
10
    Ok(())
11
}

这个例子中，我们使用 header 方法设置 Cookie 请求头（reqwest::cookie::Cookie::new() 在新版中不可用，推荐直接通过 Header 设置 Cookie）。

发送带有代理的请求#

1
use reqwest::blocking::Client;
2
use reqwest::Proxy;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::builder()
6
        .proxy(Proxy::http("http://localhost:8080")?)
7
        .build()?;
8
    let response = client.get("https://httpbin.org/get").send()?;
9
    println!("{}", response.text()?);
10
    Ok(())
11
}

这个例子中，我们使用 builder 方法创建了一个 HTTP 客户端，使用 proxy 方法设置了一个代理服务器，发送了一个 GET 请求。

下载文件#

1
use reqwest::blocking::Client;
2
use std::fs::File;
3
use std::io::copy;
4

5
fn main() -> Result<(), Box<dyn std::error::Error>> {
6
    let client = Client::new();
7
    let mut response = client.get("https://httpbin.org/image/png").send()?;
8
    let mut file = File::create("image.png")?;
9
    copy(&mut response, &mut file)?;
10
    Ok(())
11
}

这个例子中，我们发送了一个 GET 请求，下载了一个 PNG 图片，并保存到本地文件。

进阶用法#

异步操作#

1
use reqwest::Client;
2

3
#[tokio::main]
4
async fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::new();
6
    let response = client.get("https://httpbin.org/get").send().await?;
7
    println!("{}", response.text().await?);
8
    Ok(())
9
}

这个例子中，我们使用 async/await 语法，在异步上下文中发送了一个 GET 请求。

自定义 SSL 证书#

1
use reqwest::blocking::Client;
2
use std::path::Path;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::builder()
6
        .add_root_certificate(reqwest::Certificate::from_pem(
7
            &std::fs::read(Path::new("cert.pem"))?,
8
        ))
9
        .build()?;
10
    let response = client.get("https://httpbin.org/get").send()?;
11
    println!("{}", response.text()?);
12
    Ok(())
13
}

这个例子中，我们使用 builder 方法创建了一个 HTTP 客户端，并使用 add_root_certificate 方法设置了一个自定义的 SSL 证书，发送了一个 GET 请求。

自定义连接池#

1
use reqwest::blocking::Client;
2
use std::time::Duration;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::builder()
6
        .pool_idle_timeout(Duration::from_secs(30))
7
        .build()?;
8
    let response = client.get("https://httpbin.org/get").send()?;
9
    println!("{}", response.text()?);
10
    Ok(())
11
}

这个例子中，我们使用 builder 方法创建了一个 HTTP 客户端，并使用 pool_idle_timeout 方法设置了连接池的空闲超时时间，发送了一个 GET 请求。

自定义重试策略#

1
use reqwest::blocking::Client;
2
use std::time::Duration;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    // reqwest 不内置 retry 方法，需手动实现或使用 reqwest-retry crate
6
    let client = Client::builder()
7
        .pool_idle_timeout(Duration::from_secs(30))
8
        .build()?;
9
    let mut attempts = 0;
10
    let response = loop {
11
        attempts += 1;
12
        match client.get("https://httpbin.org/get").send() {
13
            Ok(resp) => break resp,
14
            Err(e) if attempts < 3 => {
15
                eprintln!("Attempt {} failed: {}, retrying...", attempts, e);
16
                std::thread::sleep(Duration::from_secs(attempts * 2));
17
            }
18
            Err(e) => return Err(e.into()),
19
        }
20
    };
21
    println!("{}", response.text()?);
22
    Ok(())
23
}

展开收起

这个例子中，我们手动实现了重试策略，最多重试 3 次。Client::builder().retry() 方法不存在于 reqwest，推荐使用 reqwest-retry crate 或手动实现重试逻辑。

最佳实践#

使用连接池#

在高并发场景下，使用连接池可以提高 HTTP 客户端的性能和稳定性。可以使用 builder 方法设置连接池的大小和空闲超时时间。

1
use reqwest::blocking::Client;
2
use std::time::Duration;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::builder()
6
        .pool_idle_timeout(Duration::from_secs(30))
7
        .pool_max_idle_per_host(10)
8
        .build()?;
9
    let response = client.get("https://httpbin.org/get").send()?;
10
    println!("{}", response.text()?);
11
    Ok(())
12
}

处理错误#

在发送 HTTP 请求时，可能会出现各种错误，如网络错误，服务器错误等。可以使用 Result 类型来处理错误，或者使用?运算符简化代码。

1
use reqwest::blocking::Client;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let client = Client::new();
5
    let response = client.get("https://httpbin.org/get").send()?;
6
    if response.status().is_success() {
7
        println!("{}", response.text()?);
8
    } else {
9
        println!("Error: {}", response.status());
10
    }
11
    Ok(())
12
}

使用代理#

在访问某些网站时，可能需要使用代理服务器。可以使用 builder 方法设置代理服务器的地址和端口。

1
use reqwest::blocking::Client;
2
use reqwest::Proxy;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::builder()
6
        .proxy(Proxy::http("http://localhost:8080")?)
7
        .build()?;
8
    let response = client.get("https://httpbin.org/get").send()?;
9
    println!("{}", response.text()?);
10
    Ok(())
11
}

使用 JSON#

在发送 HTTP 请求时，经常需要使用 JSON 格式的请求体。可以使用 serde_json 库来创建 JSON 对象，并使用 json 方法设置请求体。

1
use reqwest::blocking::Client;
2
use serde_json::json;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::new();
6
    let data = json!({
7
        "name": "Alice",
8
        "age": 20
9
    });
10
    let response = client.post("https://httpbin.org/post")
11
        .json(&data)
12
        .send()?;
13
    println!("{}", response.text()?);
14
    Ok(())
15
}

展开收起

使用表单#

在发送 HTTP 请求时，经常需要使用表单格式的请求体。可以使用 HashMap 来创建表单数据，并使用 form 方法设置请求体。

1
use reqwest::blocking::Client;
2
use std::collections::HashMap;
3

4
fn main() -> Result<(), Box<dyn std::error::Error>> {
5
    let client = Client::new();
6
    let mut data = HashMap::new();
7
    data.insert("name", "Alice");
8
    data.insert("age", "20");
9
    let response = client.post("https://httpbin.org/post")
10
        .form(&data)
11
        .send()?;
12
    println!("{}", response.text()?);
13
    Ok(())
14
}

结论#

在本教程中，我们介绍了 Rust 语言的 HTTP 客户端库 Reqwest 的基础用法和进阶用法，并提供了最佳实践和示例代码。使用 Reqwest 可以轻松地发送 HTTP 请求，并处理响应，满足各种应用场景的需求。

Rust语言从入门到精通系列 - Rust GUI实践之Rust-Qt模块

Thu, 13 Apr 2023 00:00:00 GMT

Rust-Qt 是 Rust 语言的一个 Qt 绑定库，它允许 Rust 开发者使用 Qt 框架来创建跨平台的图形界面应用程序。Qt 是一个跨平台的应用程序框架，它提供了一系列的工具和库，可以帮助开发者创建高质量的应用程序，包括图形界面、网络、数据库等方面。

Rust-Qt 的优势在于 Rust 语言的安全性和高性能，以及 Qt 框架的强大功能和跨平台性。使用 Rust-Qt 可以让开发者更加轻松地创建跨平台的图形界面应用程序。

基础用法#

创建一个简单的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4

5
fn main() {
6
    let mut app = Application::new();
7
    let mut window = Window::new();
8
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
9
    window.resize_2a(400, 300);
10
    window.show();
11
    app.exec();
12
}

这个示例演示了如何使用 Rust-Qt 创建一个简单的窗口，并设置窗口的标题和大小。

创建一个带有按钮的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::push_button::PushButton;
5

6
fn main() {
7
    let mut app = Application::new();
8
    let mut window = Window::new();
9
    let mut button = PushButton::new(&qt_core::string::String::from("Click me!"));
10
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
11
    window.resize_2a(400, 300);
12
    button.move_2a(50, 50);
13
    button.set_parent(&mut window);
14
    window.show();
15
    app.exec();
16
}

展开收起

这个示例演示了如何在窗口中添加一个按钮，并设置按钮的文本和位置。

创建一个带有标签的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::push_button::PushButton;
5
use qt_widgets::label::Label;
6

7
fn main() {
8
    let mut app = Application::new();
9
    let mut window = Window::new();
10
    let mut button = PushButton::new(&qt_core::string::String::from("Click me!"));
11
    let mut label = Label::new(&qt_core::string::String::from("Hello, Rust-Qt!"));
12
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
13
    window.resize_2a(400, 300);
14
    button.move_2a(50, 50);
15
    label.move_2a(50, 100);
16
    button.set_parent(&mut window);
17
    label.set_parent(&mut window);
18
    window.show();
19
    app.exec();
20
}

展开收起

这个示例演示了如何在窗口中添加一个标签，并设置标签的文本和位置。

创建一个带有文本框的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::push_button::PushButton;
5
use qt_widgets::line_edit::LineEdit;
6

7
fn main() {
8
    let mut app = Application::new();
9
    let mut window = Window::new();
10
    let mut button = PushButton::new(&qt_core::string::String::from("Click me!"));
11
    let mut line_edit = LineEdit::new();
12
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
13
    window.resize_2a(400, 300);
14
    button.move_2a(50, 50);
15
    line_edit.move_2a(50, 100);
16
    button.set_parent(&mut window);
17
    line_edit.set_parent(&mut window);
18
    window.show();
19
    app.exec();
20
}

展开收起

这个示例演示了如何在窗口中添加一个文本框，并设置文本框的位置。

创建一个带有菜单的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::menu::Menu;
5
use qt_widgets::menu_bar::MenuBar;
6
use qt_widgets::action::Action;
7

8
fn main() {
9
    let mut app = Application::new();
10
    let mut window = Window::new();
11
    let mut menu_bar = MenuBar::new(&mut window);
12
    let mut file_menu = Menu::new(&qt_core::string::String::from("File"), &mut menu_bar);
13
    let mut exit_action = Action::new(&qt_core::string::String::from("Exit"), &mut window);
14
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
15
    window.resize_2a(400, 300);
16
    file_menu.add_action(&mut exit_action);
17
    menu_bar.add_menu(&mut file_menu);
18
    window.show();
19
    app.exec();
20
}

展开收起

这个示例演示了如何在窗口中添加一个菜单，并设置菜单的选项。

创建一个带有复选框的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::check_box::CheckBox;
5

6
fn main() {
7
    let mut app = Application::new();
8
    let mut window = Window::new();
9
    let mut check_box = CheckBox::new();
10
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
11
    window.resize_2a(400, 300);
12
    check_box.move_2a(50, 50);
13
    check_box.set_text(&qt_core::string::String::from("Check me!"));
14
    check_box.set_parent(&mut window);
15
    window.show();
16
    app.exec();
17
}

展开收起

这个示例演示了如何在窗口中添加一个复选框，并设置复选框的文本和位置。

创建一个带有单选框的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::radio_button::RadioButton;
5

6
fn main() {
7
    let mut app = Application::new();
8
    let mut window = Window::new();
9
    let mut radio_button = RadioButton::new();
10
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
11
    window.resize_2a(400, 300);
12
    radio_button.move_2a(50, 50);
13
    radio_button.set_text(&qt_core::string::String::from("Select me!"));
14
    radio_button.set_parent(&mut window);
15
    window.show();
16
    app.exec();
17
}

展开收起

这个示例演示了如何在窗口中添加一个单选框，并设置单选框的文本和位置。

创建一个带有滑块的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::slider::Slider;
5

6
fn main() {
7
    let mut app = Application::new();
8
    let mut window = Window::new();
9
    let mut slider = Slider::new();
10
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
11
    window.resize_2a(400, 300);
12
    slider.move_2a(50, 50);
13
    slider.set_parent(&mut window);
14
    window.show();
15
    app.exec();
16
}

展开收起

这个示例演示了如何在窗口中添加一个滑块，并设置滑块的位置。

进阶用法#

创建一个带有表格的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::table_widget::TableWidget;
5

6
fn main() {
7
    let mut app = Application::new();
8
    let mut window = Window::new();
9
    let mut table_widget = TableWidget::new_2a(4, 2, &mut window);
10
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
11
    window.resize_2a(400, 300);
12
    table_widget.move_2a(50, 50);
13
    table_widget.set_item(0, 0, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("Name")));
14
    table_widget.set_item(0, 1, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("Age")));
15
    table_widget.set_item(1, 0, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("Tom")));
16
    table_widget.set_item(1, 1, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("20")));
17
    table_widget.set_item(2, 0, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("Jerry")));
18
    table_widget.set_item(2, 1, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("30")));
19
    table_widget.set_item(3, 0, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("Bob")));
20
    table_widget.set_item(3, 1, &qt_widgets::table_widget_item::TableWidgetItem::new(&qt_core::string::String::from("25")));
21
    table_widget.set_parent(&mut window);
22
    window.show();
23
    app.exec();
24
}

展开收起

这个示例演示了如何在窗口中添加一个表格，并设置表格的内容。

创建一个带有进度条的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::progress_bar::ProgressBar;
5
use std::thread;
6
use std::time::Duration;
7

8
fn main() {
9
    let mut app = Application::new();
10
    let mut window = Window::new();
11
    let mut progress_bar = ProgressBar::new();
12
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
13
    window.resize_2a(400, 300);
14
    progress_bar.move_2a(50, 50);
15
    progress_bar.set_range(0, 100);
16
    progress_bar.set_value(0);
17
    progress_bar.set_parent(&mut window);
18
    window.show();
19
    thread::spawn(move || {
20
        for i in 0..=100 {
21
            progress_bar.set_value(i);
22
            thread::sleep(Duration::from_millis(50));
23
        }
24
    });
25
    app.exec();
26
}

展开收起

这个示例演示了如何在窗口中添加一个进度条，并设置进度条的范围和初始值。

创建一个带有标签页的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::tab_widget::TabWidget;
5
use qt_widgets::widget::WidgetTrait;
6

7
fn main() {
8
    let mut app = Application::new();
9
    let mut window = Window::new();
10
    let mut tab_widget = TabWidget::new(&mut window);
11
    let mut tab1 = Widget::new().into_raw();
12
    let mut tab2 = Widget::new().into_raw();
13
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
14
    window.resize_2a(400, 300);
15
    tab_widget.move_2a(50, 50);
16
    tab_widget.set_parent(&mut window);
17
    tab_widget.add_tab_2a(tab1, &qt_core::string::String::from("Tab 1"));
18
    tab_widget.add_tab_2a(tab2, &qt_core::string::String::from("Tab 2"));
19
    window.show();
20
    app.exec();
21
}

展开收起

这个示例演示了如何在窗口中添加一个标签页，并设置标签页的选项。

创建一个带有滚动条的窗口#

1
use qt_widgets::application::Application;
2
use qt_widgets::widget::Widget;
3
use qt_widgets::window::Window;
4
use qt_widgets::scroll_area::ScrollArea;
5
use qt_widgets::label::Label;
6
use qt_gui::pixmap::Pixmap;
7
use qt_gui::image::Image;
8

9
fn main() {
10
    let mut app = Application::new();
11
    let mut window = Window::new();
12
    let mut scroll_area = ScrollArea::new(&mut window);
13
    let mut label = Label::new(&mut scroll_area);
14
    let mut pixmap = Pixmap::new();
15
    let mut image = Image::new();
16
    window.set_title(&qt_core::string::String::from("Hello, Rust-Qt!"));
17
    window.resize_2a(400, 300);
18
    pixmap.load_2a(&qt_core::string::String::from("image.jpg"), &qt_core::string::String::from("JPG"));
19
    image.set_pixmap(&pixmap);
20
    label.set_pixmap(&pixmap);
21
    scroll_area.set_widget(&mut label);
22
    scroll_area.move_2a(50, 50);
23
    scroll_area.set_widget(&mut label);
24
    scroll_area.set_widget_resizable(true);
25
    scroll_area.set_widget(&mut label);
26
    window.show();
27
    app.exec();
28
}

展开收起

这个示例演示了如何在窗口中添加一个滚动条，并设置滚动条的内容。

最佳实践#

尽可能使用 Rust-Qt 提供的 Rust 风格的 API，而不是直接使用 Qt 的 C++ 风格的 API。
在创建窗口之前，先创建应用程序对象 Application。
使用 set_parent 方法将控件添加到父控件中。
在创建菜单和工具栏时，使用 Action 类来创建菜单项和工具栏项。
在使用 Qt 的图形界面设计器时，将生成的代码放在单独的模块中，以便进行修改和维护。

结论#

Rust-Qt 是一个强大的 Rust 语言的 Qt 绑定库，它允许开发者使用 Rust 语言来创建跨平台的图形界面应用程序。本教程提供了 Rust-Qt 的基础用法和进阶用法的示例，以及最佳实践建议，帮助开发者更加轻松地使用 Rust-Qt 创建高质量的应用程序。

Rust语言从入门到精通系列 - Rust GUI实践之Tarui模块

Thu, 13 Apr 2023 00:00:00 GMT

Tauri 是一个用于构建跨平台本地应用程序的工具包，它使用 Rust 语言作为主要开发语言，可以在 Windows，MacOS 和 Linux 等平台上运行。Tauri 基于 Web 技术栈，可以使用 HTML，CSS 和 JavaScript 构建应用程序的用户界面，同时使用 Rust 语言编写应用程序的后端逻辑。Tauri 可以使用 Electron 的 API，但是相比于 Electron，Tauri 具有更小的二进制文件大小和更快的启动速度。

基础用法#

要使用 Tauri，您需要将其添加为项目的依赖项。在 Cargo.toml 文件中添加以下行：

1
[dependencies]
2
tauri = "1.2.4"

创建一个窗口#

要创建一个窗口，请使用以下代码：

1
fn main() {
2
    tauri::Builder::default()
3
        .invoke_handler(tauri::generate_handler![handle])
4
        .run(tauri::generate_context!())
5
        .expect("error while running tauri application");
6
}
7

8
#[tauri::command]
9
fn handle() -> Result<String, String> {
10
    Ok(String::from("Hello, world!"))
11
}

这将创建一个简单的窗口，并在窗口中显示“Hello, world!”。

与前端交互#

要与前端交互，请使用以下代码：

1
#[tauri::command]
2
fn handle(message: String) -> Result<String, String> {
3
    println!("Received message: {}", message);
4
    Ok(String::from("Success"))
5
}

这将在后端处理程序中接收来自前端的消息，并在控制台中打印该消息。

使用 Tauri API#

要使用 Tauri API，请使用以下代码：

1
tauri::api::dialog::info("Hello, world!", "This is an info message");

这将在应用程序中显示一个信息框，其中包含“Hello, world!”和“This is an info message”。

添加菜单#

要向您的 Tauri 应用程序添加菜单，您可以使用tauri::menu::CustomMenuItem结构体。以下是一个示例：

1
use tauri::menu::{CustomMenuItem, Menu, MenuItem};
2

3
fn main() {
4
    let menu = Menu::new()
5
        .add_item(MenuItem::About("My App".to_string()))
6
        .add_submenu("File", Menu::new()
7
            .add_item(CustomMenuItem::new("Open", "CmdOrCtrl+O"))
8
            .add_item(CustomMenuItem::new("Save", "CmdOrCtrl+S"))
9
            .add_item(MenuItem::Separator)
10
            .add_item(CustomMenuItem::new("Quit", "CmdOrCtrl+Q")));
11
}

在这个示例中，我们创建了一个名为“File”的子菜单，并向其添加了三个自定义菜单项和一个分隔符。

添加事件#

要向您的 Tauri 应用程序添加事件，您可以使用tauri::event::listen函数。以下是一个示例：

1
use tauri::event::{Event, Listener};
2
use std::sync::Arc;
3

4
fn main() {
5
    let listener = Arc::new(Listener::new("my-event", move |event| {
6
        println!("Received event: {:?}", event);
7
    }));
8
    tauri::event::listen(listener);
9
}

在这个示例中，我们创建了一个名为“my-event”的事件监听器，并在事件触发时打印出事件的内容。

使用 Tauri 文件系统 API#

要使用 Tauri 文件系统 API，请使用以下代码：

1
let file_contents = tauri::api::fs::read_to_string("my_file.txt").unwrap();
2
println!("File contents: {}", file_contents);

这将读取名为“my_file.txt”的文件，并将其内容打印到控制台上。

使用 Tauri 打开外部链接#

要在应用程序中打开外部链接，请使用以下代码：

1
tauri::api::command::spawn("open https://www.baidu.com");

这将在默认浏览器中打开 Baidu 网站。

使用 Tauri 通知#

要在应用程序中显示通知，请使用以下代码：

1
tauri::api::notification::Notification::new()
2
    .title("My Notification")
3
    .body("This is a notification")
4
    .show();

这将在应用程序中显示一个名为“My Notification”的通知，并在通知中显示文本“This is a notification”。

使用 Tauri 加密 API#

要使用 Tauri 加密 API，请使用以下代码：

1
let encrypted_data = tauri::api::encryption::encrypt("my secret data", "my secret key").unwrap();
2
println!("Encrypted data: {}", encrypted_data);

这将使用名为“my secret key”的密钥加密名为“my secret data”的数据，并将加密后的数据打印到控制台上。

使用 Tauri 数据库 API#

要使用 Tauri 数据库 API，请使用以下代码：

1
let db = tauri::api::database::Database::open("my_database.db").unwrap();
2
db.execute("CREATE TABLE IF NOT EXISTS my_table (id INTEGER PRIMARY KEY, name TEXT)").unwrap();

这将创建一个名为“my_database.db”的 SQLite 数据库，并在其中创建一个名为“my_table”的表。

使用 SQLite#

在 Tauri 中，您可以使用 SQLite 数据库来存储和管理数据。以下是一个示例：

1
use rusqlite::{params, Connection, Result};
2

3
fn main() -> Result<()> {
4
    let conn = Connection::open_in_memory()?;
5
    conn.execute(
6
        "CREATE TABLE users (
7
                  id              INTEGER PRIMARY KEY,
8
                  name            TEXT NOT NULL,
9
                  email           TEXT NOT NULL
10
                  )",
11
        [],
12
    )?;
13
    conn.execute(
14
        "INSERT INTO users (name, email) VALUES (?1, ?2)",
15
        params!["Alice", "alice@example.com"],
16
    )?;
17
    Ok(())
18
}

展开收起

在这个示例中，我们创建了一个名为“users”的表，并向其中插入了一条数据。

使用 WebSocket#

在 Tauri 中，您可以使用 WebSocket 来实现实时通信。以下是一个示例：

1
use std::thread;
2
use ws::{listen, CloseCode, Handler, Handshake, Message, Result};
3

4
struct WebSocketHandler;
5

6
impl Handler for WebSocketHandler {
7
    fn on_open(&mut self, _: Handshake) -> Result<()> {
8
        println!("WebSocket connection opened");
9
        Ok(())
10
    }
11

12
    fn on_message(&mut self, message: Message) -> Result<()> {
13
        println!("Received message: {}", message);
14
        Ok(())
15
    }
16

17
    fn on_close(&mut self, code: CloseCode, reason: &str) {
18
        println!("WebSocket connection closed with code {:?} and reason '{}'", code, reason);
19
    }
20
}
21

22
fn main() {
23
    thread::spawn(|| {
24
        listen("127.0.0.1:3012", |out| {
25
            WebSocketHandler { out }
26
        }).unwrap();
27
    });
28
}

展开收起

在这个示例中，我们创建了一个 WebSocket 服务器，并在收到消息时打印出它。我们还在新线程中启动了服务器，以便我们可以继续运行我们的 Tauri 应用程序。

使用 WebAssembly#

在 Tauri 中，您可以使用 WebAssembly 来提高性能和速度。以下是一个示例：

1
use wasm_bindgen::prelude::*;
2

3
#[wasm_bindgen]
4
pub fn fibonacci(n: i32) -> i32 {
5
    if n <= 1 {
6
        n
7
    } else {
8
        fibonacci(n - 1) + fibonacci(n - 2)
9
    }
10
}

在这个示例中，我们使用 WebAssembly 实现了一个计算斐波那契数列的函数。我们可以将这个函数导出到 JavaScript 中，然后在 Tauri 应用程序中使用它。

使用 OpenGL#

在 Tauri 中，您可以使用 OpenGL 来创建高性能的图形和渲染效果。以下是一个示例：

1
use glutin_window::GlutinWindow as Window;
2
use graphics::{clear, rectangle, Transformed};
3
use opengl_graphics::{GlGraphics, OpenGL};
4
use piston::event_loop::{EventLoop, EventSettings, Events};
5
use piston::input::{RenderEvent, UpdateEvent};
6

7
fn main() {
8
    let opengl = OpenGL::V3_2;
9
    let mut window: Window = Window::new(
10
        opengl,
11
        piston_window::WindowSettings::new("My App", [800, 600])
12
            .exit_on_esc(true),
13
    );
14
    let mut gl = GlGraphics::new(opengl);
15
    let mut events = Events::new(EventSettings::new());
16
    while let Some(e) = events.next(&mut window) {
17
        if let Some(args) = e.render_args() {
18
            gl.draw(args.viewport(), |c, gl| {
19
                clear([0.0, 0.0, 0.0, 1.0], gl);
20
                rectangle(
21
                    [1.0, 0.0, 0.0, 1.0],
22
                    [0.0, 0.0, 50.0, 50.0],
23
                    c.transform,
24
                    gl,
25
                );
26
            });
27
        }
28
    }
29
}

展开收起

在这个示例中，我们使用 OpenGL 创建了一个简单的红色矩形，并在窗口中渲染它。

最佳实践#

以下是一些使用 Tauri 的最佳实践：

将应用程序拆分为前端和后端代码，以便更好地组织代码并使其更易于维护。
使用 Tauri API 来处理应用程序的核心功能，例如文件系统访问，加密，通知等。
使用 Tauri 打包器将应用程序打包为可执行文件，并将其部署到目标平台。
使用 Tauri 的菜单和通知 API 来提高应用程序的用户体验。
使用 Tauri 的加密 API 来保护敏感数据，例如用户凭据和配置文件。
使用 Tauri 的数据库 API 来存储和检索数据，例如用户配置和应用程序状态。

结论#

Tauri 是一个功能强大的工具包，可以帮助您构建跨平台本地应用程序。它使用 Rust 语言作为主要开发语言，并提供了丰富的 API 和工具来帮助您构建高质量的应用程序。无论您是新手还是经验丰富的开发人员，Tauri 都可以为您提供所需的工具和支持，帮助您构建出色的应用程序。

Rust语言从入门到精通系列 - 实战Chrome浏览器SQLite数据库

Thu, 13 Apr 2023 00:00:00 GMT

Rust 是一种高性能、可靠性强的系统编程语言，它的出现为开发者提供了一种新的选择。Rust 的安全性和性能优势使得它成为了许多项目的首选语言，包括 Web 浏览器的开发。Chrome 浏览器是一款广受欢迎的浏览器，它使用 SQLite 数据库来存储浏览器的历史记录、书签、密码等数据。在本教程中，我们将介绍如何使用 Rust 语言操作 Chrome 浏览器的 SQLite 数据库。

基础用法#

在开始之前，我们需要安装 Rust 和 Chrome 浏览器。我们将使用 rusqlite 库来操作 SQLite 数据库。首先，我们需要在项目的 Cargo.toml 文件中添加 rusqlite 依赖：

1
[dependencies]
2
rusqlite = "0.29.0"

接下来，我们将演示如何使用 Rust 语言连接 Chrome 浏览器的 SQLite 数据库，并执行基本的查询和更新操作。

连接数据库#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    Ok(())
7
}

我们使用Connection::open方法打开 Chrome 浏览器的 SQLite 数据库，该方法返回一个Connection对象，我们可以使用该对象执行后续的查询和更新操作。

查询数据#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut stmt = conn.prepare("SELECT * FROM bookmarks")?;
7
    let rows = stmt.query_map([], |row| {
8
        Ok((row.get(0)?, row.get(1)?))
9
    })?;
10

11
    for row in rows {
12
        let (id, url): (i64, String) = row?;
13
        println!("{}: {}", id, url);
14
    }
15

16
    Ok(())
17
}

展开收起

我们使用conn.prepare方法准备一个查询语句，并使用stmt.query_map方法执行查询，并将结果映射为元组类型(i64, String)。在循环中，我们遍历查询结果，并打印每个书签的 ID 和 URL。

插入数据#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut stmt = conn.prepare("INSERT INTO bookmarks (url, title) VALUES (?, ?)")?;
7
    stmt.execute(&["https://www.rust-lang.org", "Rust Programming Language"])?;
8
    Ok(())
9
}

我们使用conn.prepare方法准备一个插入语句，并使用stmt.execute方法执行插入操作。在这个例子中，我们插入了一个名为“Rust Programming Language”的书签。

更新数据#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut stmt = conn.prepare("UPDATE bookmarks SET title = ? WHERE url = ?")?;
7
    stmt.execute(&["Rust", "https://www.rust-lang.org"])?;
8
    Ok(())
9
}

我们使用conn.prepare方法准备一个更新语句，并使用stmt.execute方法执行更新操作。在这个例子中，我们将名为“Rust Programming Language”的书签的标题更新为“Rust”。

删除数据#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut stmt = conn.prepare("DELETE FROM bookmarks WHERE url = ?")?;
7
    stmt.execute(&["https://www.rust-lang.org"])?;
8
    Ok(())
9
}

我们使用conn.prepare方法准备一个删除语句，并使用stmt.execute方法执行删除操作。在这个例子中，我们删除了名为“Rust Programming Language”的书签。

事务#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut tx = conn.transaction()?;
7
    tx.execute("INSERT INTO bookmarks (url, title) VALUES (?, ?)", &["https://www.rust-lang.org", "Rust Programming Language"])?;
8
    tx.execute("UPDATE bookmarks SET title = ? WHERE url = ?", &["Rust", "https://www.rust-lang.org"])?;
9
    tx.execute("DELETE FROM bookmarks WHERE url = ?", &["https://www.rust-lang.org"])?;
10
    tx.commit()?;
11
    Ok(())
12
}

我们使用conn.transaction方法创建一个事务，并在事务中执行多个查询操作。在这个例子中，我们插入了一个名为“Rust Programming Language”的书签，然后将其标题更新为“Rust”，最后删除该书签。在事务中执行这些操作可以确保它们要么全部执行成功，要么全部失败，从而保证数据的完整性。

批量插入#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut stmt = conn.prepare("INSERT INTO bookmarks (url, title) VALUES (?, ?)")?;
7
    let data = [("https://www.rust-lang.org", "Rust Programming Language"), ("https://www.python.org", "Python Programming Language")];
8
    let mut tx = conn.transaction()?;
9
    for (url, title) in data.iter() {
10
        stmt.execute(&[url, title])?;
11
    }
12
    tx.commit()?;
13
    Ok(())
14
}

我们使用conn.prepare方法准备一个插入语句，并使用stmt.execute方法在事务中插入多个书签。在这个例子中，我们插入了两个书签，一个是 Rust Programming Language，另一个是 Python Programming Language。

批量更新#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut stmt = conn.prepare("UPDATE bookmarks SET title = ? WHERE url = ?")?;
7
    let data = [("Rust", "https://www.rust-lang.org"), ("Python", "https://www.python.org")];
8
    let mut tx = conn.transaction()?;
9
    for (title, url) in data.iter() {
10
        stmt.execute(&[title, url])?;
11
    }
12
    tx.commit()?;
13
    Ok(())
14
}

我们使用conn.prepare方法准备一个更新语句，并使用stmt.execute方法在事务中更新多个书签的标题。在这个例子中，我们将 Rust Programming Language 的标题更新为 Rust，将 Python Programming Language 的标题更新为 Python。

进阶用法#

在本节中，我们将介绍一些高级用法，包括使用预编译语句、使用自定义函数、使用自定义类型等。

预编译语句#

1
use rusqlite::{Connection, Result};
2

3
fn main() -> Result<()> {
4
    let path = "/path/to/chrome/database";
5
    let conn = Connection::open(path)?;
6
    let mut stmt = conn.prepare_cached("SELECT * FROM bookmarks WHERE url = ?")?;
7
    let rows = stmt.query_map(&["https://www.rust-lang.org"], |row| {
8
        Ok((row.get(0)?, row.get(1)?))
9
    })?;
10

11
    for row in rows {
12
        let (id, title): (i64, String) = row?;
13
        println!("{}: {}", id, title);
14
    }
15
    Ok(())
16
}

展开收起

我们使用conn.prepare_cached方法准备一个预编译语句，并使用stmt.query_map方法执行查询。在这个例子中，我们查询了 URL 为https://www.rust-lang.org的书签，并打印其ID和标题。

使用异步 IO#

在处理大量数据时，使用异步 IO 可以提高程序的并发性能。例如，以下代码使用 tokio 库实现异步 IO 查询 Chrome 浏览器的所有书签：

1
use rusqlite::{Connection, Result};
2
use tokio::runtime::Runtime;
3

4
fn main() -> Result<()> {
5
    let path = "/path/to/chrome/database";
6
    let conn = Connection::open(path)?;
7

8
    let mut rt = Runtime::new()?;
9
    rt.block_on(async {
10
        let mut stmt = conn.prepare("SELECT * FROM bookmarks")?;
11
        let rows = stmt.query([])?;
12

13
        while let Some(row) = rows.next().await {
14
            let title: String = row?.get(1)?;
15
            let url: String = row?.get(2)?;
16
            println!("{} - {}", title, url);
17
        }
18
        Ok(())
19
    })
20
}

展开收起

在以上代码中，我们使用 tokio 库创建一个异步运行时，并在异步任务中执行查询操作。

使用连接池#

在多线程环境下，使用连接池可以避免竞争条件和锁竞争。例如，以下代码使用 r2d2 和 rusqlite 库实现连接池查询 Chrome 浏览器的所有书签：

1
use rusqlite::{Connection, Result};
2
use r2d2::Pool;
3
use r2d2_sqlite::SqliteConnectionManager;
4

5
fn main() -> Result<()> {
6
    let path = "/path/to/chrome/database";
7
    let manager = SqliteConnectionManager::file(path);
8
    let pool = Pool::builder().build(manager)?;
9

10
    let conn = pool.get()?;
11
    let mut stmt = conn.prepare("SELECT * FROM bookmarks")?;
12
    let rows = stmt.query([])?;
13

14
    for row in rows {
15
        let title: String = row.get(1)?;
16
        let url: String = row.get(2)?;
17
        println!("{} - {}", title, url);
18
    }
19
    Ok(())
20
}

展开收起

在以上代码中，我们使用 r2d2 和 rusqlite 库创建一个连接池，并在连接池中获取数据库连接。

最佳实践#

在使用 Rust 语言操作 Chrome 浏览器的 SQLite 数据库时，我们应该遵循以下最佳实践：

使用预编译语句和事务等技术来提高性能和保证数据一致性。
在多线程环境下，使用连接池来避免竞争条件和锁竞争。
在处理大量数据时，使用异步 IO 来提高程序的并发性能。
对于 Chrome 浏览器的 SQLite 数据库文件路径，应该使用环境变量或配置文件来管理，避免硬编码。

Rust语言从入门到精通系列 - 数据库连接池r2d2模块

Thu, 13 Apr 2023 00:00:00 GMT

r2d2 是 Rust 语言的一个连接池模块，可以用于管理和复用数据库连接。它可以与多种数据库进行交互，包括 MySQL、PostgreSQL、SQLite 等等。使用 r2d2 可以提高数据库操作的效率，避免频繁地创建和销毁连接，从而提高程序的性能。

基础用法#

安装#

在使用 r2d2 之前，需要先在项目中添加 r2d2 的依赖。可以通过 Cargo.toml 文件来添加依赖：

1
[dependencies]
2
r2d2 = "0.8.10"
3
r2d2_mysql = "23.0.0"
4
mysql_async = "0.32.0"

创建连接池#

在使用 r2d2 之前，需要先创建一个连接池。连接池的大小可以根据实际情况进行调整。下面是一个创建 MySQL 连接池的示例：

1
use r2d2::{Pool, PooledConnection};
2
use r2d2_mysql::mysql::PoolOptions;
3

4
fn main() {
5
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
6
    let pool = Pool::builder().build(manager).unwrap();
7
}

获取连接#

在创建连接池之后，可以通过连接池来获取数据库连接。获取连接时，需要使用get()方法。如果连接池中没有可用的连接，get()方法会阻塞等待，直到有可用的连接为止。下面是一个获取 MySQL 连接的示例：

1
fn main() {
2
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
3
    let pool = Pool::builder().build(manager).unwrap();
4
    let conn = pool.get().unwrap();
5
}

使用连接#

获取到连接之后，就可以使用连接来进行数据库操作了。下面是一个查询 MySQL 数据库中的数据的示例：

1
fn main() {
2
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
3
    let pool = Pool::builder().build(manager).unwrap();
4
    let conn = pool.get().unwrap();
5

6
    let mut stmt = conn.prepare("SELECT * FROM table").unwrap();
7
    let rows = stmt.query_map([], |row| {
8
        // 处理查询结果
9
    }).unwrap();
10
}

释放连接#

使用完连接之后，需要将连接返回给连接池，以便其他程序可以复用该连接。可以通过drop()方法来释放连接。下面是一个释放 MySQL 连接的示例：

1
fn main() {
2
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
3
    let pool = Pool::builder().build(manager).unwrap();
4
    let conn = pool.get().unwrap();
5

6
    // 使用连接进行数据库操作
7

8
    drop(conn);
9
}

自定义连接池#

r2d2 提供了一些默认的连接池实现，但是也可以通过实现r2d2::ManageConnection和r2d2::Pool来自定义连接池。下面是一个自定义 MySQL 连接池的示例：

1
use r2d2::{Pool, PooledConnection, ManageConnection};
2
use r2d2_mysql::mysql::{Opts, OptsBuilder, Pool as MysqlPool, PooledConn};
3

4
struct MyMysqlConnectionManager {
5
    pool: MysqlPool,
6
}
7

8
impl MyMysqlConnectionManager {
9
    fn new(db_url: &str) -> MyMysqlConnectionManager {
10
        let opts = Opts::from_url(db_url).unwrap();
11
        let builder = OptsBuilder::from_opts(opts);
12
        let pool = MysqlPool::new(builder).unwrap();
13
        MyMysqlConnectionManager { pool }
14
    }
15
}
16

17
impl ManageConnection for MyMysqlConnectionManager {
18
    type Connection = PooledConn;
19
    type Error = r2d2_mysql::mysql::Error;
20

21
    fn connect(&self) -> Result<Self::Connection, Self::Error> {
22
        self.pool.get_conn()
23
    }
24

25
    fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
26
        conn.ping()
27
    }
28

29
    fn has_broken(&self, conn: &mut Self::Connection) -> bool {
30
        conn.ping().is_err()
31
    }
32
}
33

34
fn main() {
35
    let manager = MyMysqlConnectionManager::new("mysql://user:password@localhost:3306/database");
36
    let pool = Pool::builder().build(manager).unwrap();
37
    let conn = pool.get().unwrap();
38
}

展开收起

自定义连接池配置#

可以通过Pool::builder()方法来创建连接池配置。连接池的配置可以包括最小连接数、最大连接数、连接超时时间等等。下面是一个自定义 MySQL 连接池配置的示例：

1
use std::time::Duration;
2

3
fn main() {
4
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
5
    let pool = Pool::builder()
6
        .min_idle(Some(5))
7
        .max_size(20)
8
        .connection_timeout(Duration::from_secs(30))
9
        .build(manager)
10
        .unwrap();
11
}

连接池监控#

r2d2 提供了一些方法来监控连接池的状态。可以通过Pool::state()方法来获取连接池的状态，包括已经创建的连接数、正在使用的连接数、空闲的连接数等等。下面是一个获取 MySQL 连接池状态的示例：

1
fn main() {
2
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
3
    let pool = Pool::builder().build(manager).unwrap();
4

5
    let state = pool.state();
6
    println!("created connections: {}", state.created_connections);
7
    println!("idle connections: {}", state.idle_connections);
8
    println!("in use connections: {}", state.in_use_connections);
9
}

自定义连接池事件处理器#

r2d2 提供了一些事件处理器，可以在连接池中的连接被创建、被借用、被归还、被销毁时触发事件。可以通过实现r2d2::HandleEvent来自定义事件处理器。下面是一个自定义 MySQL 连接池事件处理器的示例：

1
use r2d2::{Pool, PooledConnection, ManageConnection, HandleEvent};
2
use r2d2_mysql::mysql::PoolOptions;
3

4
struct MyEventHandler;
5

6
impl HandleEvent for MyEventHandler {
7
    fn on_acquire(&self, conn: &mut PooledConnection<'_, MysqlConnectionManager>) -> Result<(), r2d2::Error> {
8
        println!("connection acquired");
9
        Ok(())
10
    }
11

12
    fn on_release(&self, conn: &mut PooledConnection<'_, MysqlConnectionManager>) -> Result<(), r2d2::Error> {
13
        println!("connection released");
14
        Ok(())
15
    }
16

17
    fn on_check_out(&self, conn: &mut PooledConnection<'_, MysqlConnectionManager>) -> Result<(), r2d2::Error> {
18
        println!("connection checked out");
19
        Ok(())
20
    }
21

22
    fn on_check_in(&self, conn: &mut PooledConnection<'_, MysqlConnectionManager>) -> Result<(), r2d2::Error> {
23
        println!("connection checked in");
24
        Ok(())
25
    }
26
}
27

28
fn main() {
29
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
30
    let pool = Pool::builder()
31
        .event_handler(Box::new(MyEventHandler))
32
        .build(manager)
33
        .unwrap();
34
}

展开收起

自定义连接池超时处理器#

r2d2 提供了一个默认的连接池超时处理器，当连接池中没有可用的连接时，会等待一定的时间，如果仍然没有可用的连接，则会返回错误。可以通过实现r2d2::HandleError来自定义连接池超时处理器。下面是一个自定义 MySQL 连接池超时处理器的示例：

1
use std::time::Duration;
2
use r2d2::{Pool, PooledConnection, ManageConnection, HandleError};
3
use r2d2_mysql::mysql::PoolOptions;
4

5
struct MyErrorHandler;
6

7
impl HandleError<r2d2_mysql::mysql::Error> for MyErrorHandler {
8
    fn handle_error(&self, error: r2d2_mysql::mysql::Error) -> r2d2::Action {
9
        match error {
10
            r2d2_mysql::mysql::Error::Timeout => r2d2::Action::Retry(Duration::from_secs(5)),
11
            _ => r2d2::Action::Fail,
12
        }
13
    }
14
}
15

16
fn main() {
17
    let manager = r2d2_mysql::MysqlConnectionManager::new("mysql://user:password@localhost:3306/database").unwrap();
18
    let pool = Pool::builder()
19
        .connection_timeout(Duration::from_secs(30))
20
        .error_handler(Box::new(MyErrorHandler))
21
        .build(manager)
22
        .unwrap();
23
}

展开收起

自定义连接池初始化器#

r2d2 提供了一个默认的连接池初始化器，当连接池中没有可用的连接时，会自动创建新的连接。可以通过实现r2d2::Initializer来自定义连接池初始化器。下面是一个自定义 MySQL 连接池初始化器的示例：

1
use r2d2::{Pool, PooledConnection, ManageConnection, Initializer};
2
use r2d2_mysql::mysql::{Opts, OptsBuilder, Pool as MysqlPool, PooledConn};
3

4
struct MyMysqlConnectionManager {
5
    pool: MysqlPool,
6
}
7

8
impl MyMysqlConnectionManager {
9
    fn new(db_url: &str) -> MyMysqlConnectionManager {
10
        let opts = Opts::from_url(db_url).unwrap();
11
        let builder = OptsBuilder::from_opts(opts);
12
        let pool = MysqlPool::new(builder).unwrap();
13
        MyMysqlConnectionManager { pool }
14
    }
15
}
16

17
impl ManageConnection for MyMysqlConnectionManager {
18
    type Connection = PooledConn;
19
    type Error = r2d2_mysql::mysql::Error;
20

21
    fn connect(&self) -> Result<Self::Connection, Self::Error> {
22
        self.pool.get_conn()
23
    }
24

25
    fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
26
        conn.ping()
27
    }
28

29
    fn has_broken(&self, conn: &mut Self::Connection) -> bool {
30
        conn.ping().is_err()
31
    }
32
}
33

34
struct MyInitializer;
35

36
impl Initializer<MyMysqlConnectionManager> for MyInitializer {
37
    type Error = r2d2_mysql::mysql::Error;
38

39
    fn initialize(&self, conn: &mut PooledConnection<'_, MyMysqlConnectionManager>) -> Result<(), Self::Error> {
40
        // 初始化连接
41
        Ok(())
42
    }
43
}
44

45
fn main() {
46
    let manager = MyMysqlConnectionManager::new("mysql://user:password@localhost:3306/database");
47
    let pool = Pool::builder()
48
        .initializer(Box::new(MyInitializer))
49
        .build(manager)
50
        .unwrap();
51
    let conn = pool.get().unwrap();
52
}

展开收起

自定义连接池回收器#

r2d2 提供了一个默认的连接池回收器，当连接池中的连接空闲时间超过一定的时间时，会自动关闭连接。可以通过实现r2d2::ConnectionManager来自定义连接池回收器。下面是一个自定义 MySQL 连接池回收器的示例：

1
use std::time::Duration;
2
use r2d2::{Pool, PooledConnection, ManageConnection, ConnectionManager};
3
use r2d2_mysql::mysql::{Opts, OptsBuilder, Pool as MysqlPool, PooledConn};
4

5
struct MyMysqlConnectionManager {
6
    pool: MysqlPool,
7
}
8

9
impl MyMysqlConnectionManager {
10
    fn new(db_url: &str) -> MyMysqlConnectionManager {
11
        let opts = Opts::from_url(db_url).unwrap();
12
        let builder = OptsBuilder::from_opts(opts);
13
        let pool = MysqlPool::new(builder).unwrap();
14
        MyMysqlConnectionManager { pool }
15
    }
16
}
17

18
impl ManageConnection for MyMysqlConnectionManager {
19
    type Connection = PooledConn;
20
    type Error = r2d2_mysql::mysql::Error;
21

22
    fn connect(&self) -> Result<Self::Connection, Self::Error> {
23
        self.pool.get_conn()
24
    }
25

26
    fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
27
        conn.ping()
28
    }
29

30
    fn has_broken(&self, conn: &mut Self::Connection) -> bool {
31
        conn.ping().is_err()
32
    }
33
}
34

35
struct MyConnectionManager;
36

37
impl ConnectionManager<MyMysqlConnectionManager> for MyConnectionManager {
38
    fn recycle_check(&self, conn: &mut PooledConnection<'_, MyMysqlConnectionManager>) -> Result<(), r2d2::Error> {
39
        // 回收连接
40
        Ok(())
41
    }
42
}
43

44
fn main() {
45
    let manager = MyMysqlConnectionManager::new("mysql://user:password@localhost:3306/database");
46
    let pool = Pool::builder()
47
        .connection_customizer(Box::new(MyConnectionManager))
48
        .build(manager)
49
        .unwrap();
50
    let conn = pool.get().unwrap();
51
}

展开收起

自定义连接池失效检测操作#

r2d2 模块支持自定义连接池失效检测操作，例如在连接池中的连接失效时需要执行的操作。以下是自定义连接池失效检测操作的示例代码：

1
use r2d2::Pool;
2
use r2d2_mysql::mysql::OptsBuilder;
3
use r2d2_mysql::mysql::PoolOptions;
4

5
fn main() {
6
    let mut builder = OptsBuilder::new();
7
    builder.ip_or_hostname(Some("localhost"))
8
           .user(Some("root"))
9
           .pass(Some("password"))
10
           .db_name(Some("test"));
11
    let opts = builder.into();
12
    let pool = Pool::builder()
13
        .test_on_acquire(true)
14
        .test_on_check_out(true)
15
        .max_lifetime(Duration::from_secs(60))
16
        .build(PoolOptions::new(), opts)
17
        .unwrap();
18
}

展开收起

在以上示例代码中，我们使用了 test_on_acquire 和 test_on_check_out 方法来设置连接池失效检测操作。在 test_on_acquire 和 test_on_check_out 方法中，我们可以执行任意的操作，例如检查连接是否失效等。

最佳实践#

在使用 r2d2 模块时，我们需要遵循以下最佳实践：

将连接池作为全局对象，并在程序启动时初始化连接池。
在使用连接池获取连接时，需要使用连接池的 get 方法，并在使用完连接后及时释放连接。
在使用连接池执行 SQL 语句时，需要使用事务来保证数据的一致性。
在自定义连接池配置时，需要根据实际需求进行灵活配置，例如连接池的大小、超时时间、初始化操作等。
在多线程环境下使用连接池时，需要使用 Arc来共享连接池对象，并保证连接池的线程安全性。

总结#

r2d2 是一个 Rust 语言的连接池模块，可以用于管理和重用数据库连接，避免了频繁地创建和销毁连接的开销，提高了数据库操作的效率和性能。在使用 r2d2 时，需要进行错误处理；可以根据具体需求进行自定义连接池的实现，以满足项目的需求。

Rust语言从入门到精通系列 - Sync和Send特征

Mon, 10 Apr 2023 00:00:00 GMT

Rust语言是一门安全且并发的系统级语言，其提供了许多可以保证线程安全的特性，如Sync和Send。在Rust语言中，Sync和Send是两个用于线程安全编程的Trait，它们可以指导编译器对代码进行静态分析，确保你的代码是线程安全的。

Sync和Send的定义如下：

Send：可以安全发送到别的线程。
Sync：可以安全在多个线程中分享访问。

在Rust语言中，任何实现了Send或Sync Trait的类型都是线程安全的。

基础用法#

基本类型和Send和Sync Trait#

基本类型是指那些常常用于数据存储和算术操作的类型。这些类型都实现了Sync和Send Trait。

1
fn main() {
2
    let a: u32 = 1;
3
    let b: f32 = 3.14;
4
    let c: &str = "Hello";
5

6
    assert_eq!(std::mem::size_of::<u32>(), 4);
7
    assert_eq!(std::mem::size_of::<f32>(), 4);
8
    assert_eq!(std::mem::size_of::<&str>(), 16);
9
}

智能指针和Send Trait#

智能指针，如Box、Rc、Arc等，是非常常见的类型。在多线程环境下，使用Box可以轻松地将一些变量从一个线程传递到另一个线程。

1
use std::thread;
2

3
fn main() {
4
    let hello = Box::new("Hello, Rust!");
5
    let child = thread::spawn(move || println!("{}", hello));
6
    child.join().unwrap();
7
}

Rc和Send Trait#

Rc是Rust语言中常见的智能指针类型之一，可以让多个变量共享同一个值。在多线程环境下使用Rc的过程中需要注意一些问题。

1
use std::sync::Arc;
2
use std::thread;
3

4
fn main() {
5
    let rc_hello = Arc::new("Hello, Rust!");
6
    let child1 = thread::spawn(move || println!("{}", rc_hello));
7
    let child2 = thread::spawn(move || println!("{}", rc_hello));
8
    child1.join().unwrap();
9
    child2.join().unwrap();
10
}

Mutex和Send Trait#

Mutex是Rust语言中实现同步操作的一种机制。它允许程序在共享资源上进行安全的并发访问。

1
use std::sync::{Mutex, Arc};
2
use std::thread;
3

4
fn main() {
5
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
6
    let mut handles = vec![];
7

8
    for i in 0..2 {
9
        let data = data.clone();
10
        let handle = thread::spawn(move || {
11
            let mut data = data.lock().unwrap();
12
            data.push(i);
13
        });
14

15
        handles.push(handle);
16
    }
17

18
    for handle in handles {
19
        handle.join().unwrap();
20
    }
21

22
    println!("{:?}", data);
23
}

展开收起

Arc和Send Trait#

Arc是Rust语言中实现多线程共享的另一种机制。它可以让多个线程在同一时刻共享同一个变量。

1
use std::sync::{Arc, Mutex};
2
use std::thread;
3

4
fn main() {
5
    let counter = Arc::new(Mutex::new(0));
6
    let mut handles = vec![];
7

8
    for i in 0..10 {
9
        let counter = counter.clone();
10
        let handle = thread::spawn(move || {
11
            let mut counter = counter.lock().unwrap();
12
            *counter += 1;
13
        });
14
        handles.push(handle);
15
    }
16

17
    for handle in handles {
18
        handle.join().unwrap();
19
    }
20

21
    println!("{}", *counter.lock().unwrap());
22
}

展开收起

RwLock和Send Trait#

RwLock是Rust语言中实现共享可变状态的一种机制。它允许某个线程对共享变量进行读取访问，同时也允许有限的写访问，从而提高程序的并发性能。

1
use std::sync::{Arc, RwLock};
2
use std::thread;
3

4
fn main() {
5
  let data = Arc::new(RwLock::new(0));
6

7
  // reader
8
  for i in 0..3 {
9
      let data = data.clone();
10
      thread::spawn(move || {
11
          let data = data.read().unwrap();
12
          println!("{}: read: {}", i, *data);
13
      });
14
  }
15

16
  // writer
17
  thread::spawn(move || {
18
      let mut data = data.write().unwrap();
19
      *data = 1;
20
      println!("write: {}", *data);
21
  });
22

23
  thread::sleep_ms(1000);
24
}

展开收起

Atomic Types和Send Trait#

Rust语言中提供了一些原子类型，如AtomicU8、AtomicU16、AtomicU32，它们提供了原子更新和访问的能力。这意味着无论有多少个线程对这些变量进行操作，它们都可以保证线程安全。

1
use std::sync::atomic::{AtomicUsize, Ordering};
2
use std::sync::Arc;
3
use std::thread;
4

5
fn main() {
6
    let counter = Arc::new(AtomicUsize::new(0));
7
    let mut handles = vec![];
8

9
    for i in 0..10 {
10
        let counter = Arc::clone(&counter);
11
        let handle = thread::spawn(move || {
12
            counter.fetch_add(1, Ordering::Relaxed);
13
        });
14
        handles.push(handle);
15
    }
16

17
    for handle in handles {
18
        handle.join().unwrap();
19
    }
20

21
    println!("{}", counter.load(Ordering::Relaxed));
22
}

展开收起

线程同步#

Rust语言中提供了一些机制用于实现线程同步，如Condvar、Once、Barrier、Latch等。

1
use std::sync::{Arc, Barrier};
2
use std::thread;
3

4
fn main() {
5
    let barrier = Arc::new(Barrier::new(3));
6
    let mut handles = vec![];
7

8
    for _ in 0..3 {
9
        let barrier = barrier.clone();
10
        let handle = thread::spawn(move || {
11
            println!("Before wait: {:?}", std::thread::current().id());
12
            barrier.wait();
13
            println!("After wait: {:?}", std::thread::current().id());
14
        });
15

16
        handles.push(handle);
17
    }
18

19
    for handle in handles {
20
        handle.join().unwrap();
21
    }
22
}

展开收起

进阶用法#

使用MutexGuard#

在Rust语言中MutexGuard是实现Mutex同步机制的一个关键类型之一。它可以确保在使用Mutex时不会发生死锁或数据竞争等情况。

1
use std::sync::{Mutex, Arc};
2
use std::thread;
3

4
fn main() {
5
    let data = Arc::new(Mutex::new(0));
6
    let mut handles = vec![];
7

8
    for i in 0..10 {
9
        let data = data.clone();
10
        let handle = thread::spawn(move || {
11
            let mut data = data.lock().unwrap();
12
            *data += 1;
13
            println!("Thread {} incremented data to {}", i, *data);
14
        });
15

16
        handles.push(handle);
17
    }
18

19
    for handle in handles {
20
        handle.join().unwrap();
21
    }
22

23
    println!("{:?}", data);
24
}

展开收起

使用Sync和Send ‘static Bounds#

在Rust语言中使用Sync和Send时，需要确保它们实现了’static约束。这可以确保它们具有一些关键的属性，如生命周期。

1
use std::sync::{Arc, Mutex};
2
use std::thread;
3

4
fn main() {
5
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
6
    let hello = Arc::new("Hello, Rust!".to_string());
7

8
    let child = thread::spawn(move || {
9
        let data = &*(data.lock().unwrap());
10
        let hello = &*hello;
11
        println!("{:?}, {:?}", data, hello);
12
    });
13

14
    child.join().unwrap();
15
}

展开收起

使用Panic安全地终止线程#

在Rust语言中，线程遇到panic时，会正常终止程序。可以在panic发生后清理它们的资源。

1
use std::thread;
2

3
fn main() {
4
    let handle = thread::spawn(|| {
5
        panic!("Hello, Rust!");
6
    });
7

8
    let result = handle.join();
9
    println!("{:?}", result);
10
}

使用独立线程并发执行计算#

在Rust语言中使用线程可以在较短的时间内执行复杂的计算。这对于需要在短时间内执行大量计算的应用程序非常有# Rust语言Sync和Send教程

简介#

Sync和Send的定义如下：

Send：可以安全发送到别的线程。
Sync：可以安全在多个线程中分享访问。

在Rust语言中，任何实现了Send或Sync Trait的类型都是线程安全的。

基础用法#

基本类型和Send和Sync Trait#

基本类型是指那些常常用于数据存储和算术操作的类型。这些类型都实现了Sync和Send Trait。

1
fn main() {
2
    let a: u32 = 1;
3
    let b: f32 = 3.14;
4
    let c: &str = "Hello";
5

6
    assert_eq!(std::mem::size_of::<u32>(), 4);
7
    assert_eq!(std::mem::size_of::<f32>(), 4);
8
    assert_eq!(std::mem::size_of::<&str>(), 16);
9
}

智能指针和Send Trait#

智能指针，如Box、Rc、Arc等，是非常常见的类型。在多线程环境下，使用Box可以轻松地将一些变量从一个线程传递到另一个线程。

1
use std::thread;
2

3
fn main() {
4
    let hello = Box::new("Hello, Rust!");
5
    let child = thread::spawn(move || println!("{}", hello));
6
    child.join().unwrap();
7
}

Rc和Send Trait#

Rc是Rust语言中常见的智能指针类型之一，可以让多个变量共享同一个值。在多线程环境下使用Rc的过程中需要注意一些问题。

1
use std::sync::Arc;
2
use std::thread;
3

4
fn main() {
5
    let rc_hello = Arc::new("Hello, Rust!");
6
    let child1 = thread::spawn(move || println!("{}", rc_hello));
7
    let child2 = thread::spawn(move || println!("{}", rc_hello));
8
    child1.join().unwrap();
9
    child2.join().unwrap();
10
}

Mutex和Send Trait#

Mutex是Rust语言中实现同步操作的一种机制。它允许程序在共享资源上进行安全的并发访问。

1
use std::sync::{Mutex, Arc};
2
use std::thread;
3

4
fn main() {
5
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
6
    let mut handles = vec![];
7

8
    for i in 0..2 {
9
        let data = data.clone();
10
        let handle = thread::spawn(move || {
11
            let mut data = data.lock().unwrap();
12
            data.push(i);
13
        });
14

15
        handles.push(handle);
16
    }
17

18
    for handle in handles {
19
        handle.join().unwrap();
20
    }
21

22
    println!("{:?}", data);
23
}

展开收起

Arc和Send Trait#

Arc是Rust语言中实现多线程共享的另一种机制。它可以让多个线程在同一时刻共享同一个变量。

1
use std::sync::{Arc, Mutex};
2
use std::thread;
3

4
fn main() {
5
    let counter = Arc::new(Mutex::new(0));
6
    let mut handles = vec![];
7

8
    for i in 0..10 {
9
        let counter = counter.clone();
10
        let handle = thread::spawn(move || {
11
            let mut counter = counter.lock().unwrap();
12
            *counter += 1;
13
        });
14
        handles.push(handle);
15
    }
16

17
    for handle in handles {
18
        handle.join().unwrap();
19
    }
20

21
    println!("{}", *counter.lock().unwrap());
22
}

展开收起

RwLock和Send Trait#

RwLock是Rust语言中实现共享可变状态的一种机制。它允许某个线程对共享变量进行读取访问，同时也允许有限的写访问，从而提高程序的并发性能。

1
use std::sync::{Arc, RwLock};
2
use std::thread;
3

4
fn main() {
5
  let data = Arc::new(RwLock::new(0));
6

7
  // reader
8
  for i in 0..3 {
9
      let data = data.clone();
10
      thread::spawn(move || {
11
          let data = data.read().unwrap();
12
          println!("{}: read: {}", i, *data);
13
      });
14
  }
15

16
  // writer
17
  thread::spawn(move || {
18
      let mut data = data.write().unwrap();
19
      *data = 1;
20
      println!("write: {}", *data);
21
  });
22

23
  thread::sleep_ms(1000);
24
}

展开收起

Atomic Types和Send Trait#

1
use std::sync::atomic::{AtomicUsize, Ordering};
2
use std::sync::Arc;
3
use std::thread;
4

5
fn main() {
6
    let counter = Arc::new(AtomicUsize::new(0));
7
    let mut handles = vec![];
8

9
    for i in 0..10 {
10
        let counter = Arc::clone(&counter);
11
        let handle = thread::spawn(move || {
12
            counter.fetch_add(1, Ordering::Relaxed);
13
        });
14
        handles.push(handle);
15
    }
16

17
    for handle in handles {
18
        handle.join().unwrap();
19
    }
20

21
    println!("{}", counter.load(Ordering::Relaxed));
22
}

展开收起

线程同步#

Rust语言中提供了一些机制用于实现线程同步，如Condvar、Once、Barrier、Latch等。

1
use std::sync::{Arc, Barrier};
2
use std::thread;
3

4
fn main() {
5
    let barrier = Arc::new(Barrier::new(3));
6
    let mut handles = vec![];
7

8
    for _ in 0..3 {
9
        let barrier = barrier.clone();
10
        let handle = thread::spawn(move || {
11
            println!("Before wait: {:?}", std::thread::current().id());
12
            barrier.wait();
13
            println!("After wait: {:?}", std::thread::current().id());
14
        });
15

16
        handles.push(handle);
17
    }
18

19
    for handle in handles {
20
        handle.join().unwrap();
21
    }
22
}

展开收起

进阶用法#

使用MutexGuard#

在Rust语言中MutexGuard是实现Mutex同步机制的一个关键类型之一。它可以确保在使用Mutex时不会发生死锁或数据竞争等情况。

1
use std::sync::{Mutex, Arc};
2
use std::thread;
3

4
fn main() {
5
    let data = Arc::new(Mutex::new(0));
6
    let mut handles = vec![];
7

8
    for i in 0..10 {
9
        let data = data.clone();
10
        let handle = thread::spawn(move || {
11
            let mut data = data.lock().unwrap();
12
            *data += 1;
13
            println!("Thread {} incremented data to {}", i, *data);
14
        });
15

16
        handles.push(handle);
17
    }
18

19
    for handle in handles {
20
        handle.join().unwrap();
21
    }
22

23
    println!("{:?}", data);
24
}

展开收起

使用Sync和Send ‘static Bounds#

在Rust语言中使用Sync和Send时，需要确保它们实现了’static约束。这可以确保它们具有一些关键的属性，如生命周期。

1
use std::sync::{Arc, Mutex};
2
use std::thread;
3

4
fn main() {
5
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
6
    let hello = Arc::new("Hello, Rust!".to_string());
7

8
    let child = thread::spawn(move || {
9
        let data = &*(data.lock().unwrap());
10
        let hello = &*hello;
11
        println!("{:?}, {:?}", data, hello);
12
    });
13

14
    child.join().unwrap();
15
}

展开收起

使用Panic安全地终止线程#

在Rust语言中，线程遇到panic时，会正常终止程序。可以在panic发生后清理它们的资源。

1
use std::thread;
2

3
fn main() {
4
    let handle = thread::spawn(|| {
5
        panic!("Hello, Rust!");
6
    });
7

8
    let result = handle.join();
9
    println!("{:?}", result);
10
}

使用独立线程并发执行计算#

在Rust语言中使用线程可以在较短的时间内执行复杂的计算。这对于需要在短时间内执行大量计算的应用程序非常有

Rust语言从入门到精通系列 - Hash特征

Mon, 10 Apr 2023 00:00:00 GMT

Rust语言是一种系统级编程语言，具有高性能、安全、并发等特点，是近年来备受关注的新兴编程语言。在Rust语言中，Hash是一种常用的数据结构，用于存储键值对。Rust语言提供了一系列的Hash特征，包括Hash trait、HashMap、HashSet等，本教程将详细介绍Rust语言Hash特征的基础用法和进阶用法。

基础用法#

使用Hash trait#

在Rust语言中，Hash trait是一种通用的哈希算法，用于将任意类型的数据转换为固定长度的哈希值。下面是一个简单的示例，演示如何使用Hash trait计算一个字符串的哈希值：

1
use std::hash::{Hash, Hasher};
2

3
fn main() {
4
    let mut hasher = std::collections::hash_map::DefaultHasher::new();
5
    "hello world".hash(&mut hasher);
6
    let hash_value = hasher.finish();
7
    println!("hash value: {}", hash_value);
8
}

在上面的示例中，我们首先创建了一个DefaultHasher对象，并将字符串”hello world”传递给它的hash方法。hash方法将会调用字符串的hash方法，计算出字符串的哈希值。最后，我们使用finish方法获取哈希值。

使用HashMap#

HashMap是Rust语言中的一个哈希表实现，用于存储键值对。下面是一个简单的示例，演示如何使用HashMap存储一组字符串的长度：

1
use std::collections::HashMap;
2

3
fn main() {
4
    let mut map = HashMap::new();
5
    map.insert("hello", 5);
6
    map.insert("world", 5);
7
    map.insert("rust", 4);
8
    println!("{:?}", map);
9
}

在上面的示例中，我们首先创建了一个HashMap对象，并使用insert方法插入了三个键值对。最后，我们使用println打印出了HashMap对象。

使用HashSet#

HashSet是Rust语言中的一个哈希集合实现，用于存储不重复的元素。下面是一个简单的示例，演示如何使用HashSet存储一组字符串：

1
use std::collections::HashSet;
2

3
fn main() {
4
    let mut set = HashSet::new();
5
    set.insert("hello");
6
    set.insert("world");
7
    set.insert("rust");
8
    println!("{:?}", set);
9
}

在上面的示例中，我们首先创建了一个HashSet对象，并使用insert方法插入了三个元素。最后，我们使用println打印出了HashSet对象。

使用Hasher#

Hasher是Rust语言中的一个哈希算法实现，用于将任意类型的数据转换为固定长度的哈希值。下面是一个简单的示例，演示如何使用Hasher计算一个字符串的哈希值：

1
use std::collections::hash_map::DefaultHasher;
2
use std::hash::{Hash, Hasher};
3

4
fn main() {
5
    let mut hasher = DefaultHasher::new();
6
    "hello world".hash(&mut hasher);
7
    let hash_value = hasher.finish();
8
    println!("hash value: {}", hash_value);
9
}

使用Hasher自定义哈希算法#

在Rust语言中，我们可以自定义哈希算法，只需要实现Hasher trait即可。下面是一个简单的示例，演示如何使用自定义哈希算法计算一个字符串的哈希值：

1
use std::collections::hash_map::DefaultHasher;
2
use std::hash::{Hash, Hasher};
3

4
struct MyHasher(u64);
5

6
impl Hasher for MyHasher {
7
    fn finish(&self) -> u64 {
8
        self.0
9
    }
10

11
    fn write(&mut self, bytes: &[u8]) {
12
        for byte in bytes {
13
            self.0 = self.0.wrapping_mul(31).wrapping_add(*byte as u64);
14
        }
15
    }
16
}
17

18
fn main() {
19
    let mut hasher = MyHasher(0);
20
    "hello world".hash(&mut hasher);
21
    let hash_value = hasher.finish();
22
    println!("hash value: {}", hash_value);
23
}

展开收起

在上面的示例中，我们首先定义了一个MyHasher结构体，并实现了Hasher trait。在write方法中，我们使用了一个简单的哈希算法，将每个字节乘以31并加上上一个哈希值。最后，我们使用MyHasher对象计算字符串”hello world”的哈希值。

使用HashMap自定义哈希算法#

在Rust语言中，我们可以使用自定义哈希算法来实现HashMap的哈希函数。下面是一个简单的示例，演示如何使用自定义哈希算法实现一个简单的HashMap：

1
use std::collections::hash_map::RandomState;
2
use std::hash::{BuildHasher, Hasher};
3

4
struct MyHasher(u64);
5

6
impl Hasher for MyHasher {
7
    fn finish(&self) -> u64 {
8
        self.0
9
    }
10

11
    fn write(&mut self, bytes: &[u8]) {
12
        for byte in bytes {
13
            self.0 = self.0.wrapping_mul(31).wrapping_add(*byte as u64);
14
        }
15
    }
16
}
17

18
struct MyHasherBuilder;
19

20
impl BuildHasher for MyHasherBuilder {
21
    type Hasher = MyHasher;
22

23
    fn build_hasher(&self) -> MyHasher {
24
        MyHasher(0)
25
    }
26
}
27

28
fn main() {
29
    let mut map = std::collections::HashMap::with_hasher(MyHasherBuilder);
30
    map.insert("hello", 5);
31
    map.insert("world", 5);
32
    map.insert("rust", 4);
33
    println!("{:?}", map);
34
}

展开收起

在上面的示例中，我们首先定义了一个MyHasher结构体，并实现了Hasher trait。在write方法中，我们使用了一个简单的哈希算法，将每个字节乘以31并加上上一个哈希值。然后，我们定义了一个MyHasherBuilder结构体，并实现了BuildHasher trait。在build_hasher方法中，我们返回一个MyHasher对象。最后，我们使用with_hasher方法创建了一个使用自定义哈希算法的HashMap对象。

使用HashMap自定义键类型#

在Rust语言中，我们可以使用自定义类型作为HashMap的键类型。下面是一个简单的示例，演示如何使用自定义类型作为HashMap的键类型：

1
use std::collections::HashMap;
2

3
#[derive(Debug, PartialEq, Eq, Hash)]
4
struct Person {
5
    name: String,
6
    age: u32,
7
}
8

9
fn main() {
10
    let mut map = HashMap::new();
11
    let person = Person { name: "Alice".to_string(), age: 25 };
12
    map.insert(person, "Alice");
13
    let person = Person { name: "Bob".to_string(), age: 30 };
14
    map.insert(person, "Bob");
15
    println!("{:?}", map);
16
}

展开收起

在上面的示例中，我们首先定义了一个Person结构体，并实现了PartialEq、Eq和Hash trait。然后，我们创建了一个HashMap对象，并使用Person对象作为键插入了两个键值对。最后，我们使用println打印出了HashMap对象。

使用HashMap自定义值类型#

在Rust语言中，我们可以使用自定义类型作为HashMap的值类型。下面是一个简单的示例，演示如何使用自定义类型作为HashMap的值类型：

1
use std::collections::HashMap;
2

3
struct Person {
4
    name: String,
5
    age: u32,
6
}
7

8
fn main() {
9
    let mut map = HashMap::new();
10
    let person = Person { name: "Alice".to_string(), age: 25 };
11
    map.insert("Alice", person);
12
    let person = Person { name: "Bob".to_string(), age: 30 };
13
    map.insert("Bob", person);
14
    println!("{:?}", map);
15
}

展开收起

在上面的示例中，我们首先定义了一个Person结构体。然后，我们创建了一个HashMap对象，并使用字符串作为键，Person对象作为值插入了两个键值对。最后，我们使用println打印出了HashMap对象。

Hash特征的进阶用法#

Bloom Filter#

Bloom Filter是一种空间效率高、查询效率快的数据结构，它可以用于判断一个元素是否在一个集合中。Bloom Filter的基本原理是：使用多个Hash函数将一个元素映射到多个位上，如果这些位都为1，则认为这个元素在集合中。Bloom Filter可以容忍一定的误判率，误判率与Hash函数的个数和位数有关。

以下是一个使用Bloom Filter判断一个字符串是否在一个集合中的示例代码：

1
use bloom_filter::BloomFilter;
2

3
fn main() {
4
    let mut bloom_filter = BloomFilter::new(1000, 0.01);
5
    bloom_filter.insert("Hello");
6
    bloom_filter.insert("world");
7

8
    println!("'Hello' in set: {}", bloom_filter.contains("Hello"));
9
    println!("'world' in set: {}", bloom_filter.contains("world"));
10
    println!("'Rust' in set: {}", bloom_filter.contains("Rust"));
11
}

在这个示例代码中，我们使用了bloom_filter库中的BloomFilter结构体，创建了一个容量为1000，误判率为0.01的Bloom Filter。我们将字符串”Hello”和”world”插入到Bloom Filter中，并判断字符串”Hello”、“world”和”Rust”是否在集合中。输出结果为：

1
'Hello' in set: true
2
'world' in set: true
3
'Rust' in set: false

最佳实践#

使用std::collections::HashMap和std::collections::HashSet进行存储和检索数据
重写std::hash::Hash特征来实现自定义哈希函数
使用std::hash::Hasher特征来实现自定义哈希函数
当对大量数据进行哈希计算时，使用HashMap和HashSet时，应调整initial_capacity参数以提高性能
尽量使用DefaultHasher，而不是自行实现哈希算法，提高代码的可读性和可维护性

总结#

Hash特征是Rust语言中非常有用的一种特性，能够快速有效地进行数据存储和检索。本教程介绍了Rust语言中Hash特征的基本概念，并提供了四个示例来演示Hash特征的高级用法。通过学习这些示例，我们可以发现，Hash特征对于实际开发过程中，小到存储配置信息、大到存储海量数据，都是十分用得上的。

Rust语言从入门到精通系列 - Unsafe

Mon, 03 Apr 2023 00:00:00 GMT

Rust 是一门现代化的系统编程语言，它拥有高性能、内存安全和并发性等特点。Rust 的语法设计非常优秀，其中 match 语句是一种非常强大的语言特性。match 语句可以让我们根据不同的匹配模式执行不同的代码，这在处理复杂的逻辑时非常有用。在本教程中，我们将深入了解 Rust 的 match 语句，包括基础用法、进阶用法和实践经验等方面。

基础用法#

match 语句是 Rust 中的一种控制流语句，它可以让我们根据不同的模式匹配执行不同的代码。match 语句的基本语法如下：

1
match value {
2
    pattern1 => {
3
    // code1
4
    }
5
    pattern2 => {
6
    // code2
7
    }
8
    _ => {
9
    // 没有任何匹配
10
    }
11
}

其中，value 是要匹配的变量，pattern 是匹配模式，=>后面是要执行的代码块。如果 value 匹配了某个模式，就会执行对应的代码块。如果 value 没有匹配任何模式，就会执行默认的代码块（即_ => {…}）。

接下来，我们将通过一些示例来介绍 match 语句的基础用法。

匹配整数#

1
let x = 1;
2

3
match x {
4
    1 => println!("x is one"),
5
    2 => println!("x is two"),
6
    _ => println!("x is not one or two"),
7
}

在这个示例中，我们定义了一个整数变量 x，并使用 match 语句匹配它。如果 x 等于 1，就会执行第一个代码块，输出”x is one”；如果 x 等于 2，就会执行第二个代码块，输出”x is two”；如果 x 不等于 1 或 2，就会执行默认的代码块，输出”x is not one or two”。

匹配枚举类型#

1
enum Color {
2
    Red,
3
    Green,
4
    Blue,
5
}
6

7
let color = Color::Green;
8

9
match color {
10
    Color::Red => println!("The color is red"),
11
    Color::Green => println!("The color is green"),
12
    Color::Blue => println!("The color is blue"),
13
}

在这个示例中，我们定义了一个枚举类型 Color，并将变量 color 赋值为 Color::Green。然后，我们使用 match 语句匹配 color。如果 color 等于 Color::Red，就会执行第一个代码块，输出”The color is red”；如果 color 等于 Color::Green，就会执行第二个代码块，输出”The color is green”；如果 color 等于 Color::Blue，就会执行第三个代码块，输出”The color is blue”。

匹配元组#

1
let point = (1, 2);
2

3
match point {
4
    (0, 0) => println!("The point is at the origin"),
5
    (_, 0) => println!("The point is on the x-axis"),
6
    (0, _) => println!("The point is on the y-axis"),
7
    (x, y) => println!("The point is at ({}, {})", x, y),
8
}

在这个示例中，我们定义了一个元组变量 point，并使用 match 语句匹配它。如果 point 等于(0, 0)，就会执行第一个代码块，输出”The point is at the origin”；如果 point 的第二个元素等于 0，就会执行第二个代码块，输出”The point is on the x-axis”；如果 point 的第一个元素等于 0，就会执行第三个代码块，输出”The point is on the y-axis”；否则，就会执行第四个代码块，输出”The point is at ({}, {})“。

匹配范围#

1
let age = 20;
2

3
match age {
4
    0..=17 => println!("You are a minor"),
5
    18..=64 => println!("You are an adult"),
6
    _ => println!("You are a senior"),
7
}

在这个示例中，我们定义了一个整数变量 age，并使用 match 语句匹配它。如果 age 的值在 0 到 17 之间，就会执行第一个代码块，输出”You are a minor”；如果 age 的值在 18 到 64 之间，就会执行第二个代码块，输出”You are an adult”；否则，就会执行默认的代码块，输出”You are a senior”。

匹配引用#

1
let x = 1;
2
let y = &x;
3

4
match y {
5
    &1 => println!("The value is one"),
6
    _ => println!("The value is not one"),
7
}

在这个示例中，我们定义了一个整数变量 x 和一个指向 x 的引用 y。然后，我们使用 match 语句匹配 y。由于 y 是一个引用，所以我们需要在模式中使用&符号来匹配它。如果 y 指向的值等于 1，就会执行第一个代码块，输出”The value is one”；否则，就会执行默认的代码块，输出”The value is not one”。

匹配守卫#

1
let x = 5;
2

3
match x {
4
    n if n < 0 => println!("The value is negative"),
5
    n if n > 10 => println!("The value is greater than 10"),
6
    _ => println!("The value is between 0 and 10"),
7
}

在这个示例中，我们定义了一个整数变量 x，并使用 match 语句匹配它。在模式中，我们使用 if 语句添加了一个守卫条件。如果 x 小于 0，就会执行第一个代码块，输出”The value is negative”；如果 x 大于 10，就会执行第二个代码块，输出”The value is greater than 10”；否则，就会执行默认的代码块，输出”The value is between 0 and 10”。

进阶用法#

除了上面介绍的基础用法，match 语句还有一些进阶用法，可以让我们更加灵活地使用它。接下来，我们将介绍 match 语句的一些进阶用法，并通过示例来演示它们的用法。

使用|匹配多个模式#

1
let x = 1;
2

3
match x {
4
    1 | 2 => println!("The value is one or two"),
5
    _ => println!("The value is not one or two"),
6
}

在这个示例中，我们定义了一个整数变量 x，并使用 match 语句匹配它。在模式中，我们使用|符号来匹配多个模式。如果 x 等于 1 或 2，就会执行第一个代码块，输出”The value is one or two”；否则，就会执行默认的代码块，输出”The value is not one or two”。

使用..=匹配范围#

1
let age = 20;
2

3
match age {
4
    0..=17 => println!("You are a minor"),
5
    18..=64 => println!("You are an adult"),
6
    _ => println!("You are a senior"),
7
}

在这个示例中，我们定义了一个整数变量 age，并使用 match 语句匹配它。在模式中，我们使用..=符号来匹配范围。如果 age 的值在 0 到 17 之间，就会执行第一个代码块，输出”You are a minor”；如果 age 的值在 18 到 64 之间，就会执行第二个代码块，输出”You are an adult”；否则，就会执行默认的代码块，输出”You are a senior”。

使用@绑定变量#

1
let x = Some(5);
2

3
match x {
4
    Some(n @ 1..=10) => println!("The value is between 1 and 10: {}", n),
5
    Some(n @ 11..=20) => println!("The value is between 11 and 20: {}", n),
6
    Some(_) => println!("The value is not between 1 and 20"),
7
    None => (),
8
}

在这个示例中，我们定义了一个 Option 类型的变量 x，并使用 match 语句匹配它。在模式中，我们使用@符号来绑定一个变量。如果 x 是一个 Some 类型，并且它的值在 1 到 10 之间，就会执行第一个代码块，输出”The value is between 1 and 10”；如果 x 是一个 Some 类型，并且它的值在 11 到 20 之间，就会执行第二个代码块，输出”The value is between 11 and 20”；如果 x 是一个 Some 类型，但它的值不在 1 到 20 之间，就会执行第三个代码块，输出”The value is not between 1 and 20”；如果 x 是一个 None 类型，就不会执行任何代码。

使用_忽略模式#

1
let x = Some(5);
2

3
match x {
4
    Some(_) => println!("The value is some"),
5
    None => println!("The value is none"),
6
}

在这个示例中，我们定义了一个 Option 类型的变量 x，并使用 match 语句匹配它。在模式中，我们使用_符号来忽略模式。如果 x 是一个 Some 类型，就会执行第一个代码块，输出”The value is some”；如果 x 是一个 None 类型，就会执行第二个代码块，输出”The value is none”。

使用 if let 简化模式匹配#

1
let x = Some(5);
2

3
if let Some(n) = x {
4
    println!("The value is {}", n);
5
} else {
6
    println!("The value is None");
7
}

在这个示例中，我们定义了一个 Option 类型的变量 x，并使用 if let 语句匹配它。如果 x 是一个 Some 类型，就会执行 if 语句块，输出”The value is x”；如果 x 是一个 None 类型，就会执行 else 语句块，输出”The value is None”。使用 if let 语句可以简化模式匹配的代码，使代码更加清晰和简洁。

使用 while let 遍历迭代器#

1
let mut v = vec![1, 2, 3];
2
while let Some(n) = v.pop() {
3
    println!("{}", n);
4
}

在这个示例中，我们定义了一个整数数组 v，并使用 while let 语句遍历它的元素。在 while let 语句中，我们使用 pop()方法从数组中依次取出元素，并将它们绑定到变量 n 中。如果数组中还有元素，就会执行 while 语句块，输出元素的值；否则，就会退出 while 循环。使用 while let 语句可以方便地遍历迭代器或者其他可迭代对象。

实践经验#

在实际开发中，我们经常需要使用 match 语句来处理复杂的逻辑。以下是一些实践经验，可以帮助我们更好地使用 match 语句。

给每个分支加上花括号#

在 match 语句中，每个分支的代码块通常都比较复杂，因此我们应该给每个分支加上花括号，以便更好地阅读和维护代码。例如：

1
let x = 1;
2

3
match x {
4
    1 => {
5
        println!("The value is one");
6
        println!("This is a long message");
7
    }
8
    2 => {
9
        println!("The value is two");
10
    }
11
    _ => {
12
        println!("The value is not one or two");
13
    }
14
}

使用_忽略不需要的变量#

在 match 语句中，我们可以使用_符号来忽略不需要的变量。这样可以简化代码，并且让代码更加清晰。例如：

1
let x = (1, 2);
2

3
match x {
4
    (1, _) => println!("The first element is 1"),
5
    (_, 2) => println!("The second element is 2"),
6
    _ => (),
7
}

在这个示例中，我们使用_符号来忽略第二个元素，因为我们只关心第一个元素是否等于 1。

使用 if let 简化模式匹配#

在某些情况下，我们只需要匹配一个模式，而不需要处理其他模式。此时，我们可以使用 if let 语句来简化模式匹配的代码。例如：

1
let x = Some(5);
2

3
if let Some(n) = x {
4
    println!("The value is {}", n);
5
}

在这个示例中，我们只需要匹配 Some 类型的值，而不需要处理 None 类型的值。因此，使用 if let 语句可以让代码更加简洁和清晰。

使用 while let 遍历迭代器#

在遍历迭代器时，我们可以使用 while let 语句来依次取出元素，并进行处理。例如：

1
fn main() {
2
    let v = vec![1, 2, 3];
3

4
    for n in &v {
5
        println!("{}", n);
6
    }
7

8
    let mut v = vec![1, 2, 3];
9
    while let Some(n) = v.pop() {
10
        println!("{}", n);
11
    }
12
}

在这个示例中，我们使用 for 循环和 while let 语句来遍历整数数组 v 的元素。使用 while let 语句可以让代码更加简洁和清晰。

总结#

match 语句是 Rust 中非常强大的语言特性，它可以让我们根据不同的匹配模式执行不同的代码。在本教程中，我们介绍了 match 语句的基础用法、进阶用法和实践经验等方面。通过学习本教程，相信读者已经掌握了 match 语句的基本用法，并能够在实际开发中灵活运用它。

Rust语言从入门到精通系列 - Deref特征

Mon, 03 Apr 2023 00:00:00 GMT

在 Rust 语言中，Deref 特征用于将一个类型的引用转换为另一个类型的引用。这个特征在 Rust 中非常常见，特别是在处理数据结构中，例如字符串、向量等。Deref 特征的作用是让代码更加简洁，同时也提高了代码的可读性。

基础用法#

在 Rust 中，Deref 特征是通过实现 Deref trait 来实现的。Deref trait 定义了一个叫做 deref 的方法，它返回一个指向当前类型的引用。下面是一个简单的示例代码：

1
use std::ops::Deref;
2

3
struct MyString {
4
    s: String,
5
}
6

7
impl Deref for MyString {
8
    type Target = String;
9

10
    fn deref(&self) -> &Self::Target {
11
        &self.s
12
    }
13
}
14

15
fn main() {
16
    let my_string = MyString { s: String::from("Hello, world!") };
17
    println!("{}", *my_string);
18
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。在 main 函数中，我们通过解引用运算符（*）来获取 MyString 结构体中的 String 类型的值，并将其打印出来。

下面是更多的示例代码：

使用 Deref 转换字符串类型#

1
fn main() {
2
    let my_string = MyString { s: String::from("Hello, world!") };
3
    let s: &str = &*my_string;
4
    println!("{}", s);
5
}

在这个示例代码中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为字符串类型，并将其赋值给 s 变量。最后，我们将 s 变量打印出来。

使用 Deref 转换向量类型#

1
use std::ops::Deref;
2

3
struct MyVec<T> {
4
    v: Vec<T>,
5
}
6

7
impl<T> Deref for MyVec<T> {
8
    type Target = Vec<T>;
9

10
    fn deref(&self) -> &Self::Target {
11
        &self.v
12
    }
13
}
14

15
fn main() {
16
    let my_vec = MyVec { v: vec![1, 2, 3] };
17
    let v: &Vec<i32> = &*my_vec;
18
    println!("{:?}", v);
19
}

展开收起

在这个示例代码中，我们定义了一个 MyVec 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyVec 结构体中的 Vec 类型的引用。在 main 函数中，我们使用 Deref 将 MyVec 结构体中的 Vec 类型转换为 Vec 类型，并将其赋值给 v 变量。最后，我们将 v 变量打印出来。

使用 Deref 转换智能指针类型#

1
use std::ops::Deref;
2

3
struct MyBox<T>(T);
4

5
impl<T> Deref for MyBox<T> {
6
    type Target = T;
7

8
    fn deref(&self) -> &Self::Target {
9
        &self.0
10
    }
11
}
12

13
fn main() {
14
    let my_box = MyBox(String::from("Hello, world!"));
15
    let s: &str = &*my_box;
16
    println!("{}", s);
17
}

展开收起

在这个示例代码中，我们定义了一个 MyBox 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyBox 结构体中的 T 类型的引用。在 main 函数中，我们使用 Deref 将 MyBox 结构体中的 String 类型转换为字符串类型，并将其赋值给 s 变量。最后，我们将 s 变量打印出来。

使用 Deref 转换元组类型#

1
use std::ops::Deref;
2

3
struct MyTuple<T>(T);
4

5
impl<T> Deref for MyTuple<T> {
6
    type Target = T;
7

8
    fn deref(&self) -> &Self::Target {
9
        &self.0
10
    }
11
}
12

13
fn main() {
14
    let my_tuple = MyTuple((1, 2, 3));
15
    let t: &(i32, i32, i32) = &*my_tuple;
16
    println!("{:?}", t);
17
}

展开收起

在这个示例代码中，我们定义了一个 MyTuple 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyTuple 结构体中的 T 类型的引用。在 main 函数中，我们使用 Deref 将 MyTuple 结构体中的元组类型转换为元组类型，并将其赋值给 t 变量。最后，我们将 t 变量打印出来。

使用 Deref 转换可变引用类型#

1
use std::ops::Deref;
2

3
struct MyString {
4
    s: String,
5
}
6

7
impl Deref for MyString {
8
    type Target = String;
9

10
    fn deref(&self) -> &Self::Target {
11
        &self.s
12
    }
13
}
14

15
impl MyString {
16
    fn to_uppercase(&mut self) {
17
        self.s = self.s.to_uppercase();
18
    }
19
}
20

21
fn main() {
22
    let mut my_string = MyString { s: String::from("Hello, world!") };
23
    my_string.to_uppercase();
24
    println!("{}", *my_string);
25
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。在 MyString 结构体中，我们定义了一个 to_uppercase 方法，用于将字符串转换为大写。在 main 函数中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为可变引用类型，并调用 to_uppercase 方法将字符串转换为大写。最后，我们将转换后的字符串打印出来。

使用 Deref 转换为裸指针类型#

1
use std::ops::Deref;
2

3
struct MyString {
4
    s: String,
5
}
6

7
impl Deref for MyString {
8
    type Target = String;
9

10
    fn deref(&self) -> &Self::Target {
11
        &self.s
12
    }
13
}
14

15
fn main() {
16
    let my_string = MyString { s: String::from("Hello, world!") };
17
    let p: *const String = &*my_string;
18
    println!("{:p}", p);
19
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。在 main 函数中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为裸指针类型，并将其赋值给 p 变量。最后，我们将 p 变量打印出来。

使用 Deref 转换为引用计数类型#

1
use std::ops::Deref;
2
use std::rc::Rc;
3

4
struct MyString {
5
    s: Rc<String>,
6
}
7

8
impl Deref for MyString {
9
    type Target = String;
10

11
    fn deref(&self) -> &Self::Target {
12
        &self.s
13
    }
14
}
15

16
fn main() {
17
    let my_string = MyString { s: Rc::new(String::from("Hello, world!")) };
18
    let s: &str = &*my_string;
19
    let my_string2 = my_string.clone();
20
    let s2: &str = &*my_string2;
21
    println!("{} {}", s, s2);
22
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 Rc 类型的引用。在 main 函数中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为字符串类型，并将其赋值给 s 变量。然后，我们使用 Rc::clone 方法克隆 my_string 变量，并将其赋值给 my_string2 变量。最后，我们将 my_string 和 my_string2 变量中的字符串打印出来。

使用 Deref 转换为切片类型#

1
use std::ops::Deref;
2

3
struct MyVec<T> {
4
    v: Vec<T>,
5
}
6

7
impl<T> Deref for MyVec<T> {
8
    type Target = Vec<T>;
9

10
    fn deref(&self) -> &Self::Target {
11
        &self.v
12
    }
13
}
14

15
fn main() {
16
    let my_vec = MyVec { v: vec![1, 2, 3] };
17
    let slice: &[i32] = &*my_vec;
18
    println!("{:?}", slice);
19
}

展开收起

在这个示例代码中，我们定义了一个 MyVec 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyVec 结构体中的 Vec 类型的引用。在 main 函数中，我们使用 Deref 将 MyVec 结构体中的 Vec 类型转换为切片类型，并将其赋值给 slice 变量。最后，我们将 slice 变量打印出来。

进阶用法#

在 Rust 中，Deref 特征不仅可以用于简单的类型转换，还可以用于更复杂的场景。下面是一些进阶用法的示例代码：

使用 Deref 进行方法调用#

1
use std::ops::Deref;
2

3
struct MyString {
4
    s: String,
5
}
6

7
impl Deref for MyString {
8
    type Target = String;
9

10
    fn deref(&self) -> &Self::Target {
11
        &self.s
12
    }
13
}
14

15
impl MyString {
16
    fn new(s: &str) -> MyString {
17
        MyString { s: String::from(s) }
18
    }
19

20
    fn to_uppercase(&mut self) {
21
        self.s = self.s.to_uppercase();
22
    }
23
}
24

25
fn main() {
26
    let mut my_string = MyString::new("Hello, world!");
27
    my_string.to_uppercase();
28
    println!("{}", *my_string);
29
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。在 MyString 结构体中，我们定义了一个 new 方法，用于创建 MyString 结构体。我们还定义了一个 to_uppercase 方法，用于将字符串转换为大写。在 main 函数中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为可变引用类型，并调用 to_uppercase 方法将字符串转换为大写。最后，我们将转换后的字符串打印出来。

使用 Deref 进行运算符重载#

1
use std::ops::Deref;
2
use std::ops::Add;
3

4
struct MyString {
5
    s: String,
6
}
7

8
impl Deref for MyString {
9
    type Target = String;
10

11
    fn deref(&self) -> &Self::Target {
12
        &self.s
13
    }
14
}
15

16
impl Add for &MyString {
17
    type Output = MyString;
18

19
    fn add(self, other: &MyString) -> MyString {
20
        MyString { s: format!("{}{}", self, other) }
21
    }
22
}
23

24
fn main() {
25
    let my_string1 = MyString { s: String::from("Hello, ") };
26
    let my_string2 = MyString { s: String::from("world!") };
27
    let my_string3 = &my_string1 + &my_string2;
28
    println!("{}", *my_string3);
29
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。我们还实现了 Add trait，用于将两个 MyString 结构体合并为一个。在 main 函数中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为引用类型，并使用 + 运算符将两个 MyString 结构体合并为一个。最后，我们将合并后的字符串打印出来。

使用 Deref 进行类型转换#

1
use std::ops::Deref;
2
use std::convert::From;
3

4
struct MyString {
5
    s: String,
6
}
7

8
impl Deref for MyString {
9
    type Target = String;
10

11
    fn deref(&self) -> &Self::Target {
12
        &self.s
13
    }
14
}
15

16
impl From<MyString> for u32 {
17
    fn from(my_string: MyString) -> u32 {
18
        my_string.parse().unwrap()
19
    }
20
}
21

22
fn main() {
23
    let my_string = MyString { s: String::from("123") };
24
    let n: u32 = u32::from(*my_string);
25
    println!("{}", n);
26
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。我们还实现了 From trait，用于将 MyString 结构体转换为 u32 类型。在 main 函数中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为字符串类型，并使用 From trait 将字符串类型转换为 u32 类型。最后，我们将 u32 类型的值打印出来。

使用 Deref 进行类型推导#

1
use std::ops::Deref;
2

3
struct MyString {
4
    s: String,
5
}
6

7
impl Deref for MyString {
8
    type Target = String;
9

10
    fn deref(&self) -> &Self::Target {
11
        &self.s
12
    }
13
}
14

15
fn print_string(s: &str) {
16
    println!("{}", s);
17
}
18

19
fn main() {
20
    let my_string = MyString { s: String::from("Hello, world!") };
21
    print_string(&*my_string);
22
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。我们还定义了一个 print_string 函数，用于打印字符串。在 main 函数中，我们使用 Deref 将 MyString 结构体中的 String 类型转换为字符串类型，并将其传递给 print_string 函数。由于 Rust 编译器可以推导出参数类型，因此我们不需要显式地指定参数类型。

最佳实践#

在 Rust 中，Deref 特征是一个非常有用的特征，可以帮助我们编写更加简洁、易读的代码。以下是一些最佳实践：

在定义数据结构时，考虑是否需要实现 Deref trait，以方便类型转换。
在使用 Deref 特征时，尽量避免使用 * 运算符，而是使用 & 运算符将类型转换为引用类型。
在实现 Deref trait 时，使用 type Target = T; 来指定目标类型。
在使用 Deref 特征时，注意类型转换的顺序，以避免出现类型错误。
在使用 Deref 特征时，注意避免引用循环，以避免出现内存泄漏。

下面是一个示例代码，演示了如何使用 Deref 特征来简化代码：

1
use std::ops::Deref;
2

3
struct MyString(String);
4

5
impl Deref for MyString {
6
    type Target = String;
7

8
    fn deref(&self) -> &Self::Target {
9
        &self.0
10
    }
11
}
12

13
fn main() {
14
    let my_string = MyString(String::from("Hello, world!"));
15
    println!("{}", my_string.len());
16
}

展开收起

在这个示例代码中，我们定义了一个 MyString 结构体，并实现了 Deref trait。在 deref 方法中，我们返回了一个指向 MyString 结构体中的 String 类型的引用。在 main 函数中，我们使用 MyString 结构体的 len 方法来获取字符串的长度，而不需要使用 * 运算符来解引用 MyString 结构体。这样可以让代码更加简洁、易读。

Rust语言从入门到精通系列 - Clone特征

Mon, 03 Apr 2023 00:00:00 GMT

Rust 是一种系统编程语言，其设计目标是提供安全、并发和高性能。Rust 提供了一些特殊的语言特性，其中一个重要的特性就是 Clone。Clone 是 Rust 语言中的一个 trait，它允许我们复制一个值，而不是只是简单地将其移动。Clone 特征在 Rust 语言中非常重要，因为它允许我们在代码中复制值，而不是只是移动它们，这对于一些场景非常有用。

Copy特征只适用于基本类型和只包含基本类型成员的结构体和元组，而Clone特征适用于更广泛的类型。

基础用法#

克隆一个整数#

我们可以使用 clone 方法来克隆一个整数。下面是一个示例：

1
let a = 5;
2
let b = a.clone();
3

4
println!("a = {}, b = {}", a, b);

输出：

1
a = 5, b = 5

克隆一个字符串#

我们也可以使用 clone 方法来克隆一个字符串。下面是一个示例：

1
let a = String::from("hello");
2
let b = a.clone();
3

4
println!("a = {}, b = {}", a, b);

输出：

1
a = hello, b = hello

克隆一个数组#

我们也可以使用 clone 方法来克隆一个数组。下面是一个示例：

1
let a = [1, 2, 3];
2
let b = a.clone();
3

4
println!("a = {:?}, b = {:?}", a, b);

输出：

1
a = [1, 2, 3], b = [1, 2, 3]

克隆一个结构体#

我们也可以使用 clone 方法来克隆一个结构体。下面是一个示例：

1
#[derive(Clone)]
2
struct Person {
3
    name: String,
4
    age: u32,
5
}
6

7
let a = Person {
8
    name: String::from("Alice"),
9
    age: 30,
10
};
11
let b = a.clone();
12

13
println!("a = {:?}, b = {:?}", a, b);

输出：

1
a = Person { name: "Alice", age: 30 }, b = Person { name: "Alice", age: 30 }

克隆一个枚举#

我们也可以使用 clone 方法来克隆一个枚举。下面是一个示例：

1
#[derive(Clone)]
2
enum Color {
3
    Red,
4
    Green,
5
    Blue,
6
}
7

8
let a = Color::Red;
9
let b = a.clone();
10

11
println!("a = {:?}, b = {:?}", a, b);

输出：

1
a = Red, b = Red

克隆一个 Vec#

我们也可以使用 clone 方法来克隆一个 Vec。下面是一个示例：

1
let a = vec![1, 2, 3];
2
let b = a.clone();
3

4
println!("a = {:?}, b = {:?}", a, b);

输出：

1
a = [1, 2, 3], b = [1, 2, 3]

克隆一个 HashMap#

我们也可以使用 clone 方法来克隆一个 HashMap。下面是一个示例：

1
use std::collections::HashMap;
2

3
let mut a = HashMap::new();
4
a.insert("one", 1);
5
a.insert("two", 2);
6
let b = a.clone();
7

8
println!("a = {:?}, b = {:?}", a, b);

输出：

1
a = {"one": 1, "two": 2}, b = {"one": 1, "two": 2}

克隆一个自定义类型#

我们也可以使用 clone 方法来克隆一个自定义类型。下面是一个示例：

1
#[derive(Clone)]
2
struct MyType {
3
    data: Vec<u32>,
4
}
5

6
let a = MyType {
7
    data: vec![1, 2, 3],
8
};
9
let b = a.clone();
10

11
println!("a = {:?}, b = {:?}", a, b);

输出：

1
a = MyType { data: [1, 2, 3] }, b = MyType { data: [1, 2, 3] }

进阶用法#

自定义 Clone 方法#

有时候，我们需要自定义 Clone 方法来实现特定的克隆行为。下面是一个示例：

1
#[derive(Clone)]
2
struct MyType {
3
    data: Vec<u32>,
4
}
5

6
impl MyType {
7
    fn custom_clone(&self) -> MyType {
8
        MyType {
9
            data: self.data.iter().map(|x| x + 1).collect(),
10
        }
11
    }
12
}
13

14
let a = MyType {
15
    data: vec![1, 2, 3],
16
};
17
let b = a.custom_clone();
18

19
println!("a = {:?}, b = {:?}", a, b);

展开收起

输出：

1
a = MyType { data: [1, 2, 3] }, b = MyType { data: [2, 3, 4] }

克隆一个闭包#

我们可以使用 clone 方法来克隆一个闭包。下面是一个示例：

1
let a = |x| x + 1;
2
let b = a.clone();
3

4
println!("{}", a(1));
5
println!("{}", b(2));

输出：

克隆一个迭代器#

我们也可以使用 clone 方法来克隆一个迭代器。下面是一个示例：

1
let a = vec![1, 2, 3];
2
let b = a.iter().cloned().collect::<Vec<_>>();
3

4
for x in a {
5
    println!("{}", x);
6
}
7

8
for x in b {
9
    println!("{}", x);
10
}

输出：

克隆一个 Rc#

我们也可以使用 clone 方法来克隆一个 Rc。下面是一个示例：

1
use std::rc::Rc;
2

3
let a = Rc::new(5);
4
let b = a.clone();
5

6
println!("a = {}, b = {}", a, b);

输出：

1
a = 5, b = 5

最佳实践#

在使用 Clone 特征时，有一些最佳实践可以帮助我们编写更好的代码。

只克隆必要的数据

在克隆一个对象时，我们应该只克隆必要的数据，而不是克隆整个对象。这样可以减少内存使用量和克隆时间。

实现自定义 Clone 方法

有时候，我们需要实现自定义的 Clone 方法来实现特定的克隆行为。这可以帮助我们更好地控制克隆行为。

使用 Rc 代替 Clone

在一些场景下，我们可以使用 Rc 代替 Clone 来避免克隆数据。Rc 是一个引用计数类型，它允许多个所有者共享同一个对象。

避免过度使用 Clone

在编写代码时，我们应该避免过度使用 Clone。因为克隆数据会增加内存使用量和克隆时间，所以我们应该尽可能避免不必要的克隆。

结论#

在本教程中，我们学习了 Rust 语言中的 Clone 特征。我们了解了如何使用 Clone 特征来克隆整数、字符串、数组、结构体、枚举、Vec、HashMap 和自定义类型。我们还学习了如何实现自定义的 Clone 方法，如何克隆闭包、迭代器和 Rc，以及一些最佳实践。通过学习本教程，我们可以更好地使用 Rust 语言中的 Clone 特征，编写更好的代码。

Rust语言从入门到精通系列 - Copy特征

Mon, 03 Apr 2023 00:00:00 GMT

Rust 是一种系统级编程语言，它的设计目标是安全、并发、高效。Rust 语言具有许多特征，其中一个非常重要的特征是 Copy 特征。Copy 特征是 Rust 语言中的一个 trait，它允许我们在不使用引用的情况下复制一个值。这个特征的使用非常广泛，因为它可以提高程序的性能和可读性。

Copy特征只适用于基本类型和只包含基本类型成员的结构体和元组，而Clone特征适用于更广泛的类型。

基础用法#

在本节中，我们将介绍 Copy 特征的基础用法，并提供至少 8 个示例。

基本类型#

Rust 中的基本类型都实现了 Copy 特征，包括整数、浮点数、布尔值和字符。这意味着我们可以直接复制它们，而不需要使用引用。

1
fn main() {
2
    let x = 42;
3
    let y = x;
4
    println!("x = {}, y = {}", x, y);
5
}

输出：

1
x = 42, y = 42

结构体#

如果一个结构体中的所有字段都实现了 Copy 特征，那么这个结构体也会自动实现 Copy 特征。下面是一个示例：

1
#[derive(Copy, Clone)]
2
struct Point {
3
    x: i32,
4
    y: i32,
5
}
6

7
fn main() {
8
    let p1 = Point { x: 1, y: 2 };
9
    let p2 = p1;
10
    println!("p1 = ({}, {}), p2 = ({}, {})", p1.x, p1.y, p2.x, p2.y);
11
}

输出：

1
p1 = (1, 2), p2 = (1, 2)

数组#

数组也实现了 Copy 特征，因此我们可以直接复制它们。

1
fn main() {
2
    let a1 = [1, 2, 3];
3
    let a2 = a1;
4
    println!("a1 = {:?}, a2 = {:?}", a1, a2);
5
}

输出：

1
a1 = [1, 2, 3], a2 = [1, 2, 3]

元组#

如果一个元组中的所有元素都实现了 Copy 特征，那么这个元组也会自动实现 Copy 特征。

1
fn main() {
2
    let t1 = (1, 2, 3);
3
    let t2 = t1;
4
    println!("t1 = {:?}, t2 = {:?}", t1, t2);
5
}

输出：

1
t1 = (1, 2, 3), t2 = (1, 2, 3)

字符串#

字符串类型 String 并没有实现 Copy 特征，因为它是一个动态分配的类型。如果我们想要复制一个字符串，可以使用 clone 方法。

1
fn main() {
2
    let s1 = String::from("hello");
3
    let s2 = s1.clone();
4
    println!("s1 = {}, s2 = {}", s1, s2);
5
}

输出：

1
s1 = hello, s2 = hello

枚举#

枚举类型也可以实现 Copy 特征，但是需要注意枚举的所有成员都实现了 Copy 特征。

1
#[derive(Copy, Clone)]
2
enum Color {
3
    Red,
4
    Green,
5
    Blue,
6
}
7

8
fn main() {
9
    let c1 = Color::Red;
10
    let c2 = c1;
11
    println!("c1 = {:?}, c2 = {:?}", c1, c2);
12
}

输出：

1
c1 = Red, c2 = Red

引用#

引用类型不实现 Copy 特征，因为它们是指向内存中的数据的指针。如果我们想要复制一个引用，需要使用 clone 方法。

1
fn main() {
2
    let v1 = vec![1, 2, 3];
3
    let v2 = v1.clone();
4
    println!("v1 = {:?}, v2 = {:?}", v1, v2);
5
}

输出：

1
v1 = [1, 2, 3], v2 = [1, 2, 3]

函数#

函数类型也不实现 Copy 特征，因为函数是代码的一部分，而不是数据。如果我们想要复制一个函数，可以使用指针或闭包。

1
fn add(x: i32, y: i32) -> i32 {
2
    x + y
3
}
4

5
fn main() {
6
    let f1 = add;
7
    let f2 = f1;
8
    println!("f1(2, 3) = {}, f2(2, 3) = {}", f1(2, 3), f2(2, 3));
9
}

输出：

1
f1(2, 3) = 5, f2(2, 3) = 5

进阶用法#

在本节中，我们将介绍 Copy 特征的进阶用法，并提供至少 4 个示例。

自定义类型#

我们可以为自定义类型实现 Copy 特征，这需要我们手动实现 Copy trait 并为每个字段实现 Copy 特征。下面是一个示例：

1
#[derive(Clone, Debug)]
2
struct Person {
3
    name: String,
4
    age: i32,
5
}
6

7
impl Clone for Person {
8
    fn clone(&self) -> Person {
9
        Person {
10
            name: self.name.clone(),
11
            age: self.age,
12
        }
13
    }
14
}
15

16
fn main() {
17
    let p1 = Person {
18
        name: String::from("Alice"),
19
        age: 25,
20
    };
21
    let p2 = p1.clone();
22
    println!("p1 = {:?}, p2 = {:?}", p1, p2);
23
}

展开收起

输出：

1
p1 = Person { name: "Alice", age: 25 }, p2 = Person { name: "Alice", age: 25 }

复杂类型#

如果一个类型中包含了其他类型，我们需要为这些类型实现 Copy 特征，才能为这个类型实现 Copy 特征。

1
#[derive(Copy, Clone)]
2
struct Rectangle {
3
    top_left: Point,
4
    bottom_right: Point,
5
}
6

7
#[derive(Copy, Clone)]
8
struct Point {
9
    x: i32,
10
    y: i32,
11
}
12

13
impl Copy for Point {}
14

15
impl Clone for Point {
16
    fn clone(&self) -> Point {
17
        Point {
18
            x: self.x,
19
            y: self.y,
20
        }
21
    }
22
}
23

24
fn main() {
25
    let r1 = Rectangle {
26
        top_left: Point { x: 0, y: 0 },
27
        bottom_right: Point { x: 10, y: 10 },
28
    };
29
    let r2 = r1;
30
    println!(
31
        "r1 = ({}, {}), ({}, {}), r2 = ({}, {}), ({}, {})",
32
        r1.top_left.x, r1.top_left.y, r1.bottom_right.x, r1.bottom_right.y, r2.top_left.x, r2.top_left.y, r2.bottom_right.x, r2.bottom_right.y,
33
    );
34
}

展开收起

输出：

1
r1 = (0, 0), (10, 10), r2 = (0, 0), (10, 10)

引用计数#

引用计数类型 Rc 和 Arc 也实现了 Copy 特征，但它们并不总是安全的。如果我们复制一个 Rc 或 Arc，会增加它们的引用计数，这可能会导致内存泄漏或数据竞争。因此，在使用 Rc 或 Arc 时，我们应该避免复制它们。

1
use std::rc::Rc;
2

3
fn main() {
4
    let x = Rc::new(42);
5
    let y = x.clone();
6
    println!("x = {}, y = {}", x, y);
7
}

输出：

1
x = 42, y = 42

unsafe 代码#

如果我们在 unsafe 代码中使用 Copy 特征，需要注意内存安全。因为 unsafe 代码可以直接操作内存，如果我们复制一个指针或引用，可能会导致悬垂指针或内存泄漏。因此，在使用 Copy 特征时，我们应该特别小心。

1
unsafe fn copy_memory<T: Copy>(src: *const T, dst: *mut T, count: usize) {
2
    let src_slice = std::slice::from_raw_parts(src, count);
3
    let dst_slice = std::slice::from_raw_parts_mut(dst, count);
4
    dst_slice.copy_from_slice(src_slice);
5
}
6

7
fn main() {
8
    let mut a = [1, 2, 3];
9
    let mut b = [0; 3];
10
    unsafe {
11
        copy_memory(a.as_ptr(), b.as_mut_ptr(), a.len());
12
    }
13
    println!("a = {:?}, b = {:?}", a, b);
14
}

输出：

1
a = [1, 2, 3], b = [1, 2, 3]

最佳实践#

在本节中，我们将介绍使用 Copy 特征的最佳实践，并提供示例代码。

避免不必要的引用#

如果一个类型实现了 Copy 特征，我们可以直接复制它，而不需要使用引用。这可以避免不必要的内存分配和释放，提高程序的性能。

1
fn add(x: i32, y: i32) -> i32 {
2
    x + y
3
}
4

5
fn main() {
6
    let x = 1;
7
    let y = 2;
8
    let z = add(x, y);
9
    println!("z = {}", z);
10
}

输出：

1
z = 3

避免不必要的 clone#

如果一个类型没有实现 Copy 特征，我们需要使用 clone 方法复制它。但是，clone 方法可能会分配新的内存，因此我们应该避免不必要的 clone。

1
fn main() {
2
    let s1 = String::from("hello");
3
    let s2 = s1.clone();
4
    let s3 = s1.clone();
5
    println!("s1 = {}, s2 = {}, s3 = {}", s1, s2, s3);
6
}

输出：

1
s1 = hello, s2 = hello, s3 = hello

避免复制大型数据#

如果一个类型实现了 Copy 特征，我们可以直接复制它，但是如果这个类型包含大量的数据，复制它可能会导致性能问题。因此，在复制大型数据时，我们应该使用引用或指针。

1
fn main() {
2
    let v1 = vec![1, 2, 3];
3
    let v2 = &v1;
4
    println!("v1 = {:?}, v2 = {:?}", v1, v2);
5
}

输出：

1
v1 = [1, 2, 3], v2 = [1, 2, 3]

避免复制不可变数据#

如果一个类型是不可变的，我们可以使用引用或指针来避免复制它。这可以避免不必要的内存分配和释放，提高程序的性能。

1
fn main() {
2
    let a = [1, 2, 3];
3
    let b = &a;
4
    println!("a = {:?}, b = {:?}", a, b);
5
}

输出：

1
a = [1, 2, 3], b = [1, 2, 3]

结论#

Copy 特征是 Rust 语言中非常重要的一个特征，它可以提高程序的性能和可读性。在使用 Copy 特征时，我们需要遵循最佳实践，避免不必要的内存分配和释放，提高程序的性能和安全性。

Rust语言从入门到精通系列 - 堆对象智能指针Box

Mon, 03 Apr 2023 00:00:00 GMT

Rust 是一种系统编程语言，它的设计目标是提供安全性、并发性和性能。它是一种静态类型语言，具有内存安全和数据竞争安全的特性。

在 Rust 中，Box 是一种智能指针，它允许在堆上分配内存，并在不需要时自动释放。Box 是 Rust 中最基本的智能指针之一，它是对堆上分配的内存的所有权的一种抽象。

基础用法#

创建一个 Box#

1
let b = Box::new(5);

这个例子创建了一个 Box，它包含一个整数 5。Box 的类型是Box<i32>。

将一个值放入 Box 中#

1
let x = 5;
2
let b = Box::new(x);

这个例子将一个整数 5 放入了 Box 中。

从 Box 中获取值#

1
let b = Box::new(5);
2
let x = *b;

这个例子从 Box 中获取了一个整数 5，并将其赋值给变量 x。注意，需要使用解引用运算符*来获取 Box 中的值。

在函数中传递 Box#

1
fn print_box(b: Box<i32>) {
2
    println!("The value of b is {}", *b);
3
}
4

5
let b = Box::new(5);
6
print_box(b);

这个例子定义了一个函数print_box，它接受一个 Box 作为参数，并打印 Box 中的值。然后，创建一个 Box 并将其传递给函数。

在函数中返回 Box#

1
fn create_box() -> Box<i32> {
2
    Box::new(5)
3
}
4

5
let b = create_box();

这个例子定义了一个函数create_box，它返回一个 Box，其中包含整数 5。然后，创建一个 Box 并将其赋值给变量 b。

将 Box 转换为引用#

1
let b = Box::new(5);
2
let r = &*b;

这个例子将一个 Box 转换为一个引用。注意，需要使用解引用运算符*来获取 Box 中的值，然后使用引用运算符&来获取引用。

将 Box 转换为可变引用#

1
let mut b = Box::new(5);
2
let r = &mut *b;
3
*r = 6;

这个例子将一个 Box 转换为一个可变引用。注意，需要使用解引用运算符*来获取 Box 中的值，然后使用可变引用运算符&mut来获取可变引用。

在结构体中使用 Box#

1
struct Point {
2
    x: i32,
3
    y: i32,
4
}
5

6
struct Rectangle {
7
    top_left: Box<Point>,
8
    bottom_right: Box<Point>,
9
}
10

11
let rect = Rectangle {
12
    top_left: Box::new(Point { x: 0, y: 0 }),
13
    bottom_right: Box::new(Point { x: 10, y: 10 }),
14
};

这个例子定义了两个结构体，Point 和 Rectangle。Rectangle 包含两个 Box，它们分别表示矩形的左上角和右下角。然后，创建一个 Rectangle 并初始化它的两个 Box。

进阶用法#

使用 Box 在堆上分配大量内存#

1
let mut v = Vec::new();
2
for i in 0..1000000 {
3
    v.push(Box::new(i));
4
}

这个例子创建了一个包含 1000000 个整数的 Vec。由于整数是通过 Box 分配在堆上的，因此 Vec 的大小只包含指针的大小，而不是整个整数的大小。

使用 Box 实现递归数据结构#

1
enum List {
2
    Cons(i32, Box<List>),
3
    Nil,
4
}
5

6
let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));

这个例子定义了一个递归的 List 枚举类型。它可以包含一个整数和一个指向另一个 List 的 Box，或者是一个空 List。然后，创建一个包含两个整数的 List。

使用 Box 实现自引用结构体#

1
use std::cell::RefCell;
2
use std::rc::Rc;
3

4
struct Node {
5
    value: i32,
6
    next: Option<Rc<RefCell<Node>>>,
7
}
8

9
let n1 = Rc::new(RefCell::new(Node {
10
    value: 1,
11
    next: None,
12
}));
13
let n2 = Rc::new(RefCell::new(Node {
14
    value: 2,
15
    next: None,
16
}));
17

18
n1.borrow_mut().next = Some(n2.clone());
19
n2.borrow_mut().next = Some(n1.clone());

展开收起

这个例子定义了一个 Node 结构体，它包含一个整数和一个指向另一个 Node 的 Box。然后，创建两个 Node 并将它们相互引用。

使用 Box 实现动态分配的多态类型#

1
trait Shape {
2
    fn area(&self) -> f64;
3
}
4

5
struct Circle {
6
    radius: f64,
7
}
8

9
impl Shape for Circle {
10
    fn area(&self) -> f64 {
11
        std::f64::consts::PI * self.radius * self.radius
12
    }
13
}
14

15
struct Rectangle {
16
    width: f64,
17
    height: f64,
18
}
19

20
impl Shape for Rectangle {
21
    fn area(&self) -> f64 {
22
        self.width * self.height
23
    }
24
}
25

26
let shapes: Vec<Box<dyn Shape>> = vec![
27
    Box::new(Circle { radius: 1.0 }),
28
    Box::new(Rectangle { width: 2.0, height: 3.0 }),
29
];
30
for shape in shapes {
31
    println!("Area = {}", shape.area());
32
}

展开收起

这个例子定义了一个 Shape trait 和两个实现它的结构体 Circle 和 Rectangle。然后，创建一个包含两个 Shape 的 Vec，并遍历它打印每个 Shape 的面积。

最佳实践#

避免过度使用 Box

Box 是在堆上分配内存的一种方式，因此使用过多的 Box 可能会导致性能问题。在 Rust 中，应该尽可能地使用栈上分配内存，只在需要时才使用 Box。

使用 Box 来避免所有权问题

在 Rust 中，所有权是一个重要的概念。使用 Box 可以避免所有权问题，因为 Box 可以在不同的作用域中传递所有权。

使用 Box 实现递归数据结构

在 Rust 中，递归数据结构是一种常见的数据结构。使用 Box 可以方便地实现递归数据结构，因为 Box 可以在堆上分配内存，并在不需要时自动释放。

使用 Box 实现动态分配的多态类型

在 Rust 中，多态类型是一种常见的编程模式。使用 Box 可以方便地实现动态分配的多态类型，因为 Box 可以在堆上分配内存，并在不需要时自动释放。

总结#

Box 是 Rust 中最基本的智能指针之一，它允许在堆上分配内存，并在不需要时自动释放。在本教程中，我们介绍了 Box 的基础用法和进阶用法，并提供了示例代码。最后，我们提供了一些最佳实践，以帮助您更好地使用 Box。

Rust语言从入门到精通系列 - 不可变引用智能指针RefCell特征

Mon, 03 Apr 2023 00:00:00 GMT

RefCell 是 Rust 标准库提供的一种类型，它可以在运行时检查借用规则，使得我们可以在某些情况下绕过 Rust 的静态借用检查。RefCell 的主要作用是允许在不可变引用存在的情况下，获取可变引用。这样就可以在不破坏 Rust 的安全性和所有权规则的前提下，实现一些特殊的需求。

在 Rust 中，为了避免数据竞争，任何时候只能有一个可变引用或多个不可变引用。但是，在某些情况下，我们确实需要在不可变引用的情况下修改数据。这时候，就可以使用 RefCell。

基础用法#

创建 RefCell#

首先，我们需要创建一个 RefCell 对象。可以使用 new() 方法来创建一个新的 RefCell，示例代码如下：

1
use std::cell::RefCell;
2

3
let my_cell = RefCell::new(42);

这里，我们创建了一个名为 my_cell 的 RefCell，并将其初始化为整数 42。

获取 RefCell 中的值#

要访问 RefCell 中的值，我们需要使用 borrow() 方法。这个方法返回一个 Ref 对象，它像一个不可变引用一样使用，但是它可以访问 RefCell 中的值。示例代码如下：

1
use std::cell::RefCell;
2

3
fn main() {
4
    let my_cell = RefCell::new(42);
5

6
    let my_ref = my_cell.borrow();
7
    println!("The value in my_cell is: {}", *my_ref);
8
}
9
//    输出结果
10
//    The value in my_cell is: 42

这里，我们首先创建了一个 RefCell，然后使用 borrow() 方法获取了一个 Ref 对象。我们可以使用 * 运算符来访问 Ref 中的值。

修改 RefCell 中的值#

要修改 RefCell 中的值，我们需要使用 borrow_mut() 方法。这个方法返回一个 RefMut 对象，它像一个可变引用一样使用，但是它可以修改 RefCell 中的值。示例代码如下：

1
use std::cell::RefCell;
2

3
fn main() {
4
    let my_cell = RefCell::new(42);
5

6
    let mut my_ref = my_cell.borrow_mut();
7
    *my_ref = 100;
8
    println!("The new value in my_cell is: {}", *my_ref);
9
}
10
//    输出结果
11
//    The new value in my_cell is: 100

这里，我们首先创建了一个 RefCell，然后使用 borrow_mut() 方法获取了一个 RefMut 对象。我们可以使用 * 运算符来修改 RefMut 中的值。

获取 RefCell 中的不可变引用#

如果我们在获取 RefCell 的可变引用之前，已经获取了一个不可变引用，那么 Rust 会在运行时检查，如果发现了错误，就会 panic。示例代码如下：

1
use std::cell::RefCell;
2

3
fn main() {
4
    let my_cell = RefCell::new(42);
5

6
    let my_ref = my_cell.borrow();
7
    let my_mut_ref = my_cell.borrow_mut(); // panic!
8
}
9
//    输出结果
10
// thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:17:26

这里，我们首先获取了一个不可变引用 my_ref，然后试图获取一个可变引用 my_mut_ref。由于我们已经有了一个不可变引用，所以 Rust 会在运行时检查，发现了错误，就会 panic。

获取 RefCell 中的可变引用#

如果我们在获取 RefCell 的可变引用之前，已经获取了一个可变引用，那么 Rust 会在编译时检查，如果发现了错误，就会报错。示例代码如下：

1
use std::cell::RefCell;
2

3
let my_cell = RefCell::new(42);
4

5
let mut my_mut_ref = my_cell.borrow_mut();
6
let my_ref = my_cell.borrow(); // compile error!
7
//    输出结果
8
// thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:17:22

这里，我们首先获取了一个可变引用 my_mut_ref，然后试图获取一个不可变引用 my_ref。由于我们已经有了一个可变引用，所以 Rust 会在编译时检查，发现了错误，就会报错。

获取 RefCell 中的多个不可变引用#

如果我们在获取 RefCell 的多个不可变引用时，其中一个引用已经被转换为可变引用，那么 Rust 会在运行时检查，如果发现了错误，就会 panic。示例代码如下：

1
use std::cell::RefCell;
2

3
let my_cell = RefCell::new(42);
4

5
let my_ref1 = my_cell.borrow();
6
let my_ref2 = my_cell.borrow();
7
let mut my_mut_ref = my_cell.borrow_mut(); // panic!
8
//    thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:18:30

这里，我们首先获取了两个不可变引用 my_ref1 和 my_ref2，然后试图获取一个可变引用 my_mut_ref。由于我们已经有了两个不可变引用，所以 Rust 会在运行时检查，发现了错误，就会 panic。

获取 RefCell 中的多个可变引用#

如果我们在获取 RefCell 的多个可变引用时，其中一个引用已经被转换为不可变引用，那么 Rust 会在编译时检查，如果发现了错误，就会报错。示例代码如下：

1
use std::cell::RefCell;
2

3
let my_cell = RefCell::new(42);
4

5
let mut my_mut_ref1 = my_cell.borrow_mut();
6
let my_mut_ref2 = my_cell.borrow_mut(); // compile error!

这里，我们首先获取了一个可变引用 my_mut_ref1，然后试图获取另一个可变引用 my_mut_ref2。由于我们已经有了一个可变引用，所以 Rust 会在编译时检查，发现了错误，就会报错。

使用 RefCell 来实现引用计数#

RefCell 还可以用来实现引用计数。我们可以将 RefCell 包装在一个 Rc 中，这样就可以在多个地方共享 RefCell。示例代码如下：

1
use std::cell::RefCell;
2
use std::rc::Rc;
3

4
fn main() {
5
    let my_cell = Rc::new(RefCell::new(42));
6

7
    let my_ref1 = my_cell.borrow().clone();
8
    let my_ref2 = my_cell.borrow().clone();
9
    {
10
        let mut my_mut_ref = my_cell.borrow_mut();
11
        *my_mut_ref = 100;
12
    }
13
    println!("The value in my_cell is: {:?}", my_ref1);
14
    println!("The value in my_cell is: {:?}", my_ref2);
15
}

展开收起

这里，我们首先创建了一个 Rc<RefCell<i32>>，然后分别获取了两个不可变引用 my_ref1 和 my_ref2，以及一个可变引用 my_mut_ref。我们可以使用 * 运算符来访问 Ref 和 RefMut 中的值。

进阶用法#

使用 RefCell 来实现线程安全的可变变量#

在 Rust 中，如果我们需要在线程之间共享可变变量，通常会使用 Mutex 或 RwLock。但是，这些类型的性能可能不太好，因为它们需要在每个访问上进行加锁和解锁操作。如果我们只需要在单个线程中共享可变变量，那么可以使用 RefCell 来实现，这样可以避免加锁和解锁的开销。

示例代码如下：

1
use std::cell::RefCell;
2

3
let my_cell = RefCell::new(0);
4

5
let mut my_mut_ref1 = my_cell.borrow_mut();
6
*my_mut_ref1 += 1;
7
let mut my_mut_ref2 = my_cell.borrow_mut();
8
*my_mut_ref2 += 2;
9

10
println!("The value in my_cell is: {}", *my_mut_ref1);

这里，我们首先创建了一个 RefCell<i32>，然后获取了两个可变引用 my_mut_ref1 和 my_mut_ref2，并分别修改了它们。由于我们只在单个线程中使用 RefCell，所以不需要加锁和解锁。

使用 RefCell 来实现循环引用#

在 Rust 中，如果两个对象互相引用，那么它们之间就会形成一个循环引用。这时候，就可以使用 RefCell 来实现。示例代码如下：

1
use std::cell::RefCell;
2
use std::rc::Rc;
3

4
struct Node {
5
    value: i32,
6
    next: Option<Rc<RefCell<Node>>>,
7
}
8

9
fn main() {
10
    let node1 = Rc::new(RefCell::new(Node {
11
        value: 1,
12
        next: None,
13
    }));
14
    let node2 = Rc::new(RefCell::new(Node {
15
        value: 2,
16
        next: None,
17
    }));
18

19
    {
20
        node1.borrow_mut().next = Some(node2.clone());
21
    }
22
    {
23
        node2.borrow_mut().next = Some(node1.clone());
24
    }
25

26
    println!("The value of node1 is: {}", node1.borrow().value);
27
    println!("The value of node2 is: {}", node2.borrow().value);
28
}
29
//    输出结果
30
// The value of node1 is: 1
31
// The value of node2 is: 2

展开收起

这里，我们创建了两个 Rc<RefCell<Node>>，然后将它们互相引用。由于我们使用了 RefCell，所以可以在创建时互相引用，而不需要先创建一个对象，然后再修改它们的引用。

使用 RefCell 来实现可变借用嵌套#

在 Rust 中，如果我们需要在一个可变引用中嵌套另一个可变引用，通常会出现编译时错误。但是，如果我们使用 RefCell，就可以实现可变借用嵌套。示例代码如下：

1
use std::cell::RefCell;
2
use std::rc::Rc;
3

4
struct Node {
5
    value: i32,
6
    next: Option<Rc<RefCell<Node>>>,
7
}
8

9
fn main() {
10
    let node1 = Rc::new(RefCell::new(Node { value: 1, next: None }));
11
    let node2 = Rc::new(RefCell::new(Node { value: 2, next: None }));
12

13
    {
14
        node1.borrow_mut().next = Some(node2.clone());
15
        node2.borrow_mut().next = Some(node1.clone());
16
    }
17

18
    println!("The value of node1 is: {}", node1.borrow().value);
19
    println!("The value of node2 is: {}", node2.borrow().value);
20
}

展开收起

这里，我们创建了两个 Box<RefCell<Node>>，然后将它们互相引用。由于我们使用了 RefCell，所以可以在可变引用中嵌套另一个可变引用。

使用 RefCell 来实现内部可变性#

在 Rust 中，如果我们需要在一个结构体中存储一个可变变量，通常会使用 mut 关键字来标记结构体字段。但是，如果我们使用 RefCell，就可以实现内部可变性。示例代码如下：

1
use std::cell::RefCell;
2

3
struct Person {
4
    name: String,
5
    age: RefCell<i32>,
6
}
7

8
fn main() {
9
    let person = Person { name: "Alice".to_string(), age: RefCell::new(30) };
10
    {
11
        let mut my_age = person.age.borrow_mut();
12
        *my_age += 1;
13
    }
14
    println!("{} is now {} years old.", person.name, *person.age.borrow());
15
}
16
//    输出结果
17
//    Alice is now 31 years old.

展开收起

这里，我们创建了一个 Person 结构体，其中包含一个 String 类型的 name 字段和一个 RefCell<i32> 类型的 age 字段。我们可以在不可变引用的情况下修改 age 字段中的值。

最佳实践#

避免过多的可变引用#

虽然 RefCell 可以在不可变引用的情况下修改数据，但是过多的可变引用会导致代码难以维护。因此，应该尽量避免过多的可变引用。

使用 RefCell 来实现状态机#

RefCell 可以用于实现状态机。在状态机中，状态之间的转换通常需要修改状态机中的某些变量。由于状态机本身是不可变的，因此可以使用 RefCell 来存储状态机中的可变变量。

示例代码如下：

1
use std::cell::RefCell;
2

3
#[derive(Debug)]
4
enum State {
5
    A,
6
    B,
7
    C,
8
}
9

10
#[derive(Debug)]
11
struct StateMachine {
12
    state: RefCell<State>,
13
    count: RefCell<i32>,
14
}
15

16
impl StateMachine {
17
    fn new() -> StateMachine {
18
        StateMachine { state: RefCell::new(State::A), count: RefCell::new(0) }
19
    }
20

21
    fn next(&self) {
22
        let mut state = self.state.borrow_mut();
23
        let mut count = self.count.borrow_mut();
24

25
        match *state {
26
            State::A => {
27
                *state = State::B;
28
                *count += 1;
29
            },
30
            State::B => {
31
                *state = State::C;
32
                *count += 2;
33
            },
34
            State::C => {
35
                *state = State::A;
36
                *count += 3;
37
            },
38
        }
39
    }
40
}
41

42
fn main() {
43
    let sm = StateMachine::new();
44

45
    sm.next();
46
    println!("State is {:?}, count is {}", *sm.state.borrow(), *sm.count.borrow());
47
    sm.next();
48
    println!("State is {:?}, count is {}", *sm.state.borrow(), *sm.count.borrow());
49
    sm.next();
50
    println!("State is {:?}, count is {}", *sm.state.borrow(), *sm.count.borrow());
51
}
52
//    输出结果
53
// State is B, count is 1
54
// State is C, count is 3
55
// State is A, count is 6

展开收起

这里，我们创建了一个 StateMachine 结构体，其中包含一个 RefCell<State> 类型的 state 字段和一个 RefCell<i32> 类型的 count 字段。我们可以在不可变引用的情况下修改 state 和 count 字段中的值。

使用 RefCell 来实现链表#

RefCell 可以用于实现链表。在链表中，每个节点通常包含一个指向下一个节点的指针。由于每个节点的指针是可变的，因此可以使用 RefCell 来存储节点中的指针。

示例代码如下：

1
use std::cell::RefCell;
2
use std::rc::Rc;
3

4
struct Node {
5
    value: i32,
6
    next: Option<Rc<RefCell<Node>>>,
7
}
8

9
fn main() {
10
    let node1 = Rc::new(RefCell::new(Node { value: 1, next: None }));
11
    let node2 = Rc::new(RefCell::new(Node { value: 2, next: None }));
12
    let node3 = Rc::new(RefCell::new(Node { value: 3, next: None }));
13

14
    node1.borrow_mut().next = Some(node2.clone());
15
    node2.borrow_mut().next = Some(node3.clone());
16

17
    let mut node = node1;
18
    while let Some(next) = node.borrow().next.clone() {
19
        println!("The value of node is: {}", next.borrow().value);
20
        node = next;
21
    }
22
    println!("The value of node is: {}", node.borrow().value);
23
}

展开收起

这里，我们创建了三个 Rc<RefCell<Node>>，然后将它们连接成一个链表。我们可以使用 borrow() 方法来访问节点中的值，使用 borrow_mut() 方法来修改节点中的指针。

总结#

在使用 RefCell 时，需要注意避免过多的可变引用，以及使用 RefCell 实现状态机和链表等数据结构。

Rust语言从入门到精通系列 - 如何判断对象是否相等？

Mon, 03 Apr 2023 00:00:00 GMT

在 Rust 语言中，PartialEq 和 Eq 是两个非常重要的 trait。它们用于比较类型的值，PartialEq 用于比较部分相等（不需要完全相等），而 Eq 用于比较完全相等。

在 Rust 中，任何类型都可以实现 PartialEq 和 Eq，因此这两个 trait 非常灵活。

基础用法#

比较整数#

1
fn main() {
2
    let a = 10;
3
    let b = 20;
4
    if a == b {
5
        println!("a equals b");
6
    } else {
7
        println!("a does not equal b");
8
    }
9
}

输出：

1
a does not equal b

比较字符串#

1
fn main() {
2
    let a = "hello";
3
    let b = "world";
4
    if a == b {
5
        println!("a equals b");
6
    } else {
7
        println!("a does not equal b");
8
    }
9
}

输出：

1
a does not equal b

比较自定义类型#

1
#[derive(PartialEq, Eq)]
2
struct Person {
3
    name: String,
4
    age: u8,
5
}
6

7
fn main() {
8
    let p1 = Person {
9
        name: "Alice".to_string(),
10
        age: 30,
11
    };
12
    let p2 = Person {
13
        name: "Bob".to_string(),
14
        age: 30,
15
    };
16
    if p1 == p2 {
17
        println!("p1 equals p2");
18
    } else {
19
        println!("p1 does not equal p2");
20
    }
21
}

展开收起

输出：

1
p1 does not equal p2

比较浮点数#

1
fn main() {
2
    let a = 0.1 + 0.2;
3
    let b = 0.3;
4
    if a == b {
5
        println!("a equals b");
6
    } else {
7
        println!("a does not equal b");
8
    }
9
}

输出：

1
a does not equal b

自定义比较函数#

1
struct Person {
2
    name: String,
3
    age: u8,
4
}
5

6
impl PartialEq for Person {
7
    fn eq(&self, other: &Self) -> bool {
8
        self.age == other.age
9
    }
10
}
11

12
impl Eq for Person {}
13

14
fn main() {
15
    let p1 = Person {
16
        name: "Alice".to_string(),
17
        age: 30,
18
    };
19
    let p2 = Person {
20
        name: "Bob".to_string(),
21
        age: 30,
22
    };
23
    if p1 == p2 {
24
        println!("p1 equals p2");
25
    } else {
26
        println!("p1 does not equal p2");
27
    }
28
}

展开收起

输出：

1
p1 equals p2

比较枚举类型#

1
#[derive(PartialEq, Eq)]
2
enum Color {
3
    Red,
4
    Blue,
5
}
6

7
fn main() {
8
    let c1 = Color::Red;
9
    let c2 = Color::Blue;
10
    if c1 == c2 {
11
        println!("c1 equals c2");
12
    } else {
13
        println!("c1 does not equal c2");
14
    }
15
}

展开收起

输出：

1
c1 does not equal c2

使用 assert_eq!宏#

1
fn main() {
2
    let a = 10;
3
    let b = 20;
4
    assert_eq!(a, b);
5
}

输出：

1
thread 'main' panicked at 'assertion failed: `(left == right)`
2
  left: `10`,
3
 right: `20`', src/main.rs:4:5
4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

使用 assert_ne!宏#

1
fn main() {
2
    let a = 10;
3
    let b = 20;
4
    assert_ne!(a, b);
5
}

输出：

1
thread 'main' panicked at 'assertion failed: `(left != right)`
2
  left: `10`,
3
 right: `10`', src/main.rs:4:5
4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

进阶用法#

自定义比较函数#

1
struct Person {
2
    name: String,
3
    age: u8,
4
}
5

6
impl PartialEq for Person {
7
    fn eq(&self, other: &Self) -> bool {
8
        self.age == other.age
9
    }
10
}
11

12
impl Eq for Person {}
13

14
fn main() {
15
    let p1 = Person {
16
        name: "Alice".to_string(),
17
        age: 30,
18
    };
19
    let p2 = Person {
20
        name: "Bob".to_string(),
21
        age: 40,
22
    };
23
    if p1 == p2 {
24
        println!("p1 equals p2");
25
    } else {
26
        println!("p1 does not equal p2");
27
    }
28
}

展开收起

输出：

1
p1 does not equal p2

使用泛型#

1
#[derive(PartialEq, Eq)]
2
struct Pair<T> {
3
    first: T,
4
    second: T,
5
}
6

7
fn main() {
8
    let p1 = Pair {
9
        first: 1,
10
        second: 2,
11
    };
12
    let p2 = Pair {
13
        first: 2,
14
        second: 1,
15
    };
16
    if p1 == p2 {
17
        println!("p1 equals p2");
18
    } else {
19
        println!("p1 does not equal p2");
20
    }
21
}

展开收起

输出：

1
p1 does not equal p2

使用 PartialOrd 和 Ord#

1
#[derive(PartialEq, Eq, PartialOrd, Ord)]
2
struct Person {
3
    name: String,
4
    age: u8,
5
}
6

7
fn main() {
8
    let p1 = Person {
9
        name: "Alice".to_string(),
10
        age: 30,
11
    };
12
    let p2 = Person {
13
        name: "Bob".to_string(),
14
        age: 40,
15
    };
16
    if p1 < p2 {
17
        println!("p1 is younger than p2");
18
    } else {
19
        println!("p1 is older than or equal to p2");
20
    }
21
}

展开收起

输出：

1
p1 is younger than p2

使用 Debug 和 Display#

1
#[derive(Debug, PartialEq, Eq)]
2
struct Person {
3
    name: String,
4
    age: u8,
5
}
6

7
use std::fmt;
8

9
impl fmt::Display for Person {
10
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11
        write!(f, "{} ({})", self.name, self.age)
12
    }
13
}
14

15
fn main() {
16
    let p1 = Person {
17
        name: "Alice".to_string(),
18
        age: 30,
19
    };
20
    let p2 = Person {
21
        name: "Bob".to_string(),
22
        age: 40,
23
    };
24
    println!("p1: {}", p1);
25
    println!("p2: {}", p2);
26
}

展开收起

输出：

1
p1: Alice (30)
2
p2: Bob (40)

最佳实践#

在实现 PartialEq 和 Eq 时，应该考虑以下几点：

对于自定义类型，应该比较所有的成员变量，而不仅仅是一部分。
对于浮点数，应该使用近似比较而不是精确比较。
对于枚举类型，应该比较所有的成员变量，而不仅仅是枚举值本身。
如果需要比较的类型实现了 PartialOrd 和 Ord，应该优先使用这两个 trait。

结论#

在 Rust 语言中，PartialEq 和 Eq 是非常重要的 trait，用于比较类型的值。这两个 trait 非常灵活，任何类型都可以实现它们。在实现 PartialEq 和 Eq 时，应该考虑到类型的特点，比较所有的成员变量，使用近似比较等。

Rust语言从入门到精通系列 - Default特征

Mon, 03 Apr 2023 00:00:00 GMT

Rust 是一种系统级编程语言，它的设计目标是安全、并发和高效。Rust 的设计灵感来自于 C++、Rust 和 Haskell 等语言，它的特点是静态类型、内存安全、并发性和高性能。

Default 是 Rust 标准库中的一个 trait，它定义了一个类型的默认值。在 Rust 中，每个类型都有一个默认值，这个默认值可以通过 Default trait 来获取。Rust 的默认值是零值，也就是说，如果一个类型没有定义它的默认值，那么它的默认值就是 0 或者 null。

基础用法#

使用 Default trait 获取类型的默认值#

在 Rust 中，可以使用 Default trait 来获取一个类型的默认值。例如，以下代码演示了如何获取一个整数类型的默认值：

1
fn main() {
2
    let x: i32 = Default::default();
3
    println!("The default value of i32 is {}", x);
4
}

输出结果为：

1
The default value of i32 is 0

自定义类型的默认值#

在 Rust 中，可以为自定义类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个结构体类型实现 Default trait：

1
#[derive(Default)]
2
struct Point {
3
    x: i32,
4
    y: i32,
5
}
6

7
fn main() {
8
    let p: Point = Default::default();
9
    println!("The default value of Point is ({}, {})", p.x, p.y);
10
}

输出结果为：

1
The default value of Point is (0, 0)

使用泛型获取类型的默认值#

在 Rust 中，可以使用泛型来获取任意类型的默认值。例如，以下代码演示了如何使用泛型获取一个字符串类型的默认值：

1
fn main() {
2
    let s: String = Default::default();
3
    println!("The default value of String is '{}'", s);
4
}

输出结果为：

1
The default value of String is ''

使用 Option 类型获取默认值#

在 Rust 中，Option 类型是一个枚举类型，它可以表示一个值的存在或不存在。如果一个变量的类型是 Option 类型，则它的默认值是 None。例如，以下代码演示了如何获取一个 Option 类型的默认值：

1
fn main() {
2
    let opt: Option<i32> = Default::default();
3
    println!("The default value of Option<i32> is {:?}", opt);
4
}

输出结果为：

1
The default value of Option<i32> is None

使用数组类型获取默认值#

在 Rust 中，数组类型的默认值是一个由零值组成的数组。例如，以下代码演示了如何获取一个数组类型的默认值：

1
fn main() {
2
    let arr: [i32; 3] = Default::default();
3
    println!("The default value of [i32; 3] is {:?}", arr);
4
}

输出结果为：

1
The default value of [i32; 3] is [0, 0, 0]

使用元组类型获取默认值#

在 Rust 中，元组类型的默认值是一个由每个元素的默认值组成的元组。例如，以下代码演示了如何获取一个元组类型的默认值：

1
fn main() {
2
    let tup: (i32, bool, String) = Default::default();
3
    println!("The default value of (i32, bool, String) is {:?}", tup);
4
}

输出结果为：

1
The default value of (i32, bool, String) is (0, false, '')

使用枚举类型获取默认值#

在 Rust 中，枚举类型的默认值是它的第一个成员。例如，以下代码演示了如何获取一个枚举类型的默认值：

1
#[derive(Debug)]
2
enum Color {
3
    Red,
4
    Green,
5
    Blue,
6
}
7

8
impl Default for Color {
9
    fn default() -> Self {
10
        Color::Red
11
    }
12
}
13

14
fn main() {
15
    let color: Color = Default::default();
16
    println!("The default value of Color is {:?}", color);
17
}

展开收起

输出结果为：

1
The default value of Color is Red

使用结构体获取默认值#

在 Rust 中，结构体类型的默认值是由每个字段的默认值组成的结构体。例如，以下代码演示了如何获取一个结构体类型的默认值：

1
#[derive(Debug)]
2
struct Person {
3
    name: String,
4
    age: i32,
5
    is_male: bool,
6
}
7

8
impl Default for Person {
9
    fn default() -> Self {
10
        Self {
11
            name: String::default(),
12
            age: i32::default(),
13
            is_male: bool::default(),
14
        }
15
    }
16
}
17

18
fn main() {
19
    let p: Person = Default::default();
20
    println!("The default value of Person is {:?}", p);
21
}

展开收起

输出结果为：

1
The default value of Person is Person { name: '', age: 0, is_male: false }

进阶用法#

使用 Default trait 实现结构体的默认值#

在 Rust 中，可以为结构体类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个结构体类型实现 Default trait：

1
#[derive(Default)]
2
struct Point {
3
    x: i32,
4
    y: i32,
5
}
6

7
fn main() {
8
    let p: Point = Default::default();
9
    println!("The default value of Point is ({}, {})", p.x, p.y);
10
}

输出结果为：

1
The default value of Point is (0, 0)

使用 Default trait 实现枚举类型的默认值#

在 Rust 中，可以为枚举类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个枚举类型实现 Default trait：

1
enum Color {
2
    Red,
3
    Green,
4
    Blue,
5
}
6

7
impl Default for Color {
8
    fn default() -> Self {
9
        Color::Red
10
    }
11
}
12

13
fn main() {
14
    let color: Color = Default::default();
15
    println!("The default value of Color is {:?}", color);
16
}

展开收起

输出结果为：

1
The default value of Color is Red

使用 Default trait 实现元组类型的默认值#

在 Rust 中，可以为元组类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个元组类型实现 Default trait：

1
fn main() {
2
    let tup: (i32, bool, String) = Default::default();
3
    println!("The default value of (i32, bool, String) is {:?}", tup);
4
}

输出结果为：

1
The default value of (i32, bool, String) is (0, false, '')

使用 Default trait 实现泛型类型的默认值#

在 Rust 中，可以为泛型类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个泛型类型实现 Default trait：

1
struct Pair<T> {
2
    x: T,
3
    y: T,
4
}
5

6
impl<T: Default> Default for Pair<T> {
7
    fn default() -> Self {
8
        Self {
9
            x: T::default(),
10
            y: T::default(),
11
        }
12
    }
13
}
14

15
fn main() {
16
    let pair: Pair<i32> = Default::default();
17
    println!("The default value of Pair<i32> is ({}, {})", pair.x, pair.y);
18
}

展开收起

输出结果为：

1
The default value of Pair<i32> is (0, 0)

最佳实践#

在 Rust 中，使用 Default trait 可以方便地获取类型的默认值。以下是一些最佳实践：

为自定义类型实现 Default trait#

为自定义类型实现 Default trait 可以方便地为它们定义默认值。例如，以下代码演示了如何为一个结构体类型实现 Default trait：

1
#[derive(Default)]
2
struct Point {
3
    x: i32,
4
    y: i32,
5
}
6

7
fn main() {
8
    let p: Point = Default::default();
9
    println!("The default value of Point is ({}, {})", p.x, p.y);
10
}

输出结果为：

1
The default value of Point is (0, 0)

使用泛型获取类型的默认值#

在 Rust 中，可以使用泛型来获取任意类型的默认值。例如，以下代码演示了如何使用泛型获取一个字符串类型的默认值：

1
fn main() {
2
    let s: String = Default::default();
3
    println!("The default value of String is '{}'", s);
4
}

输出结果为：

1
The default value of String is ''

使用 Option 类型获取默认值#

1
fn main() {
2
    let opt: Option<i32> = Default::default();
3
    println!("The default value of Option<i32> is {:?}", opt);
4
}

输出结果为：

1
The default value of Option<i32> is None

为泛型类型实现 Default trait#

为泛型类型实现 Default trait 可以方便地为它们定义默认值。例如，以下代码演示了如何为一个泛型类型实现 Default trait：

1
struct Pair<T> {
2
    x: T,
3
    y: T,
4
}
5

6
impl<T: Default> Default for Pair<T> {
7
    fn default() -> Self {
8
        Self {
9
            x: T::default(),
10
            y: T::default(),
11
        }
12
    }
13
}
14

15
fn main() {
16
    let pair: Pair<i32> = Default::default();
17
    println!("The default value of Pair<i32> is ({}, {})", pair.x, pair.y);
18
}

展开收起

输出结果为：

1
The default value of Pair<i32> is (0, 0)

结论#

在 Rust 中，Default trait 可以方便地获取类型的默认值。使用 Default trait 可以简化代码，并提高代码的可读性和可维护性。同时，为自定义类型实现 Default trait 可以方便地为它们定义默认值。在使用 Default trait 时，可以根据需要为泛型类型实现 Default trait，以便为它们定义默认值。

Rust语言从入门到精通系列 - 深入理解From和Into特征

Mon, 03 Apr 2023 00:00:00 GMT

Rust 是一种系统编程语言，其设计目标是提供安全性、速度和并发性。Rust 的安全性特别强，这是因为它在编译时就会检查代码中的内存安全问题。Rust 还具有良好的性能和并发性，这使得它成为了开发高性能、可靠和安全的系统级应用的首选语言。

Rust 中的 From 和 Into 是两个重要的 trait，它们可以帮助我们进行类型转换。From trait 允许我们从一个类型转换到另一个类型，而 Into trait 则允许我们将一个类型转换为另一个类型。这两个 trait 的实现可以帮助我们更好地处理类型转换的问题。

本教程将介绍 Rust 中的 From 和 Into trait 的基础使用方法和进阶用法。

基础用法#

从字符串转换为数字#

我们可以使用 From trait 将一个字符串转换为数字类型。例如，我们将字符串”123”转换为 i32 类型。

1
let num: i32 = "123".parse::<i32>().unwrap();

从数字转换为字符串#

我们可以使用 Into trait 将一个数字类型转换为字符串。例如，我们将数字 123 转换为字符串类型。

1
let num: i32 = 123;
2
let str: String = String::from(num.to_string());

从一个类型转换为另一个类型#

我们可以使用 From trait 将一个类型转换为另一个类型。例如，我们将一个 i32 类型的变量转换为一个 u32 类型的变量。

1
let num: i32 = 123;
2
let new_num: u32 = num.try_into().unwrap();

从一个类型转换为另一个类型#

我们可以使用 Into trait 将一个类型转换为另一个类型。例如，我们将一个 i32 类型的变量转换为一个 u32 类型的变量。

1
let num: i32 = 123;
2
let new_num: u32 = num.try_into().unwrap();

从一个 Option 类型转换为另一个 Option 类型#

我们可以使用 From trait 将一个 Option 类型转换为另一个 Option 类型。例如，我们将一个 Option类型的变量转换为一个 Option类型的变量。

1
let num: Option<i32> = Some(123);
2
let new_num: Option<u32> = num.map(|n| n as u32);

从一个 Vec 类型转换为另一个 Vec 类型#

我们可以使用 From trait 将一个 Vec 类型转换为另一个 Vec 类型。例如，我们将一个 Vec类型的变量转换为一个 Vec类型的变量。

1
let vec: Vec<i32> = vec![1, 2, 3];
2
let new_vec: Vec<u32> = vec.into_iter().map(|x| x as u32).collect::<Vec<u32>>();

从一个数组类型转换为另一个数组类型#

我们可以使用 From trait 将一个数组类型转换为另一个数组类型。例如，我们将一个[i32; 3]类型的数组转换为一个[u32; 3]类型的数组。

1
let arr: [i32; 3] = [1, 2, 3];
2
let new_arr: [u32; 3] = arr.map(|x| x as u32);

从一个枚举类型转换为另一个枚举类型#

我们可以使用 From trait 将一个枚举类型转换为另一个枚举类型。例如，我们将一个 Option类型的枚举转换为一个 Option类型的枚举。

1
enum OptionInt {
2
    Some(i32),
3
    None,
4
}
5

6
enum OptionUint {
7
    Some(u32),
8
    None,
9
}
10

11
impl From<OptionInt> for OptionUint {
12
    fn from(option_int: OptionInt) -> OptionUint {
13
        match option_int {
14
            OptionInt::Some(n) => OptionUint::Some(n as u32),
15
            OptionInt::None => OptionUint::None,
16
        }
17
    }
18
}
19

20
let option_int = OptionInt::Some(123);
21
let option_uint: OptionUint = OptionUint::from(option_int);

展开收起

进阶用法#

为自定义类型实现 From trait#

我们可以为自定义类型实现 From trait，以便将自定义类型转换为其他类型。例如，我们为自定义类型 MyInt 实现 From trait，以便将它转换为 i32 类型。

1
struct MyInt(i32);
2

3
impl From<MyInt> for i32 {
4
    fn from(my_int: MyInt) -> i32 {
5
        my_int.0
6
    }
7
}
8

9
let my_int = MyInt(123);
10
let num: i32 = my_int.into();

为自定义类型实现 Into trait#

我们可以为自定义类型实现 Into trait，以便将其他类型转换为自定义类型。例如，我们为自定义类型 MyInt 实现 Into trait，以便将 i32 类型转换为它。

1
struct MyInt(i32);
2

3
impl Into<MyInt> for i32 {
4
    fn into(self) -> MyInt {
5
        MyInt(self)
6
    }
7
}
8

9
let num: i32 = 123;
10
let my_int: MyInt = num.into();

使用泛型实现 From trait#

我们可以使用泛型实现 From trait，以便将任意类型转换为另一个类型。例如，我们使用泛型实现 From trait，以便将任意类型转换为字符串类型。

1
struct MyStruct<T>(T);
2

3
impl<T: std::fmt::Display> From<MyStruct<T>> for String {
4
    fn from(my_struct: MyStruct<T>) -> String {
5
        format!("{}", my_struct.0)
6
    }
7
}
8

9
let my_struct = MyStruct(123);
10
let str: String = my_struct.into();

使用泛型实现 Into trait#

我们可以使用泛型实现 Into trait，以便将任意类型转换为另一个类型。例如，我们使用泛型实现 Into trait，以便将任意类型转换为字符串类型。

1
struct MyStruct<T>(T);
2

3
impl<T: std::fmt::Display> Into<String> for MyStruct<T> {
4
    fn into(self) -> String {
5
        format!("{}", self.0)
6
    }
7
}
8

9
let my_struct = MyStruct(123);
10
let str: String = my_struct.into();

最佳实践#

在 Rust 中，From 和 Into trait 是非常有用的，它们可以帮助我们进行类型转换。在实现 From 和 Into trait 时，我们需要注意以下几点：

实现 From 和 Into trait 时，需要考虑类型转换的安全性和正确性。
实现 From 和 Into trait 时，需要考虑性能问题，避免不必要的类型转换。
在实现 From 和 Into trait 时，需要遵循 Rust 的惯例和规范，以便代码更易于理解和维护。

下面是一些最佳实践示例代码：

为自定义类型实现 From 和 Into trait#

1
struct MyInt(i32);
2

3
impl From<MyInt> for i32 {
4
    fn from(my_int: MyInt) -> i32 {
5
        my_int.0
6
    }
7
}
8

9
impl Into<MyInt> for i32 {
10
    fn into(self) -> MyInt {
11
        MyInt(self)
12
    }
13
}

使用泛型实现 From 和 Into trait#

1
struct MyStruct<T>(T);
2

3
impl<T: std::fmt::Display> From<MyStruct<T>> for String {
4
    fn from(my_struct: MyStruct<T>) -> String {
5
        format!("{}", my_struct.0)
6
    }
7
}
8

9
impl<T: std::fmt::Display> Into<String> for MyStruct<T> {
10
    fn into(self) -> String {
11
        format!("{}", self.0)
12
    }
13
}

使用 From 和 Into trait 进行类型转换#

1
let my_int = MyInt(123);
2
let num: i32 = my_int.into();
3

4
let my_struct = MyStruct(123);
5
let str: String = my_struct.into();

总结#

在本教程中，我们介绍了 Rust 中的 From 和 Into trait 的基础使用方法和进阶用法。From trait 允许我们从一个类型转换到另一个类型，而 Into trait 则允许我们将一个类型转换为另一个类型。我们还提供了一些示例代码和最佳实践，以帮助您更好地理解和应用 From 和 Into trait。

Rust语言从入门到精通系列 - Stream特征

Mon, 03 Apr 2023 00:00:00 GMT

Stream 是 Rust 语言中的一种迭代器，它可以使得我们在处理数据时更加高效、灵活。Stream 不仅可以处理大量数据，还可以进行异步操作，这使得它在处理网络请求等 IO 操作时非常有用。

Stream 的核心概念是将数据视为流，每次处理一个元素，而不是将整个数据集加载到内存中。这样可以避免内存占用过大的问题，同时也能够提高程序的效率。

基础用法#

创建 Stream#

在 Rust 中，我们可以使用iter方法来创建 Stream。例如，我们可以使用以下代码来创建一个包含 1 到 5 的 Stream：

1
let stream = (1..5).into_iter();

这里使用了into_iter方法将一个范围转换为 Stream。

遍历 Stream#

遍历 Stream 可以使用for_each方法，例如：

1
stream.for_each(|x| println!("{}", x));

这里使用了闭包来打印每个元素。

过滤 Stream#

我们可以使用filter方法来过滤 Stream 中的元素，例如：

1
let stream = (1..5).into_iter().filter(|x| x % 2 == 0);

这里使用了闭包来判断元素是否为偶数。

映射 Stream#

我们可以使用map方法来对 Stream 中的元素进行映射，例如：

1
let stream = (1..5).into_iter().map(|x| x * 2);

这里使用了闭包来将每个元素乘以 2。

合并 Stream#

我们可以使用chain方法来合并多个 Stream，例如：

1
let stream1 = (1..3).into_iter();
2
let stream2 = (4..6).into_iter();
3
let stream = stream1.chain(stream2);

这里使用了chain方法将两个 Stream 合并为一个。

排序 Stream#

我们可以使用sorted方法来对 Stream 中的元素进行排序，例如：

1
let stream = vec![3, 1, 4, 1, 5, 9].into_iter().sorted();

这里使用了sorted方法将 Stream 中的元素按照升序排序。

取前 n 个元素#

我们可以使用take方法来取 Stream 中的前 n 个元素，例如：

1
let stream = (1..5).into_iter().take(3);

这里使用了take方法取 Stream 中的前 3 个元素。

跳过前 n 个元素#

我们可以使用skip方法来跳过 Stream 中的前 n 个元素，例如：

1
let stream = (1..5).into_iter().skip(2);

这里使用了skip方法跳过 Stream 中的前 2 个元素。

统计元素个数#

我们可以使用count方法来统计 Stream 中的元素个数，例如：

1
let stream = (1..5).into_iter();
2
let count = stream.count();
3
println!("{}", count);

这里使用了count方法统计 Stream 中的元素个数，并打印出来。

进阶用法#

异步 Stream#

在 Rust 中，我们可以使用futures库来创建异步 Stream。例如，我们可以使用以下代码来创建一个异步 Stream：

1
use futures::stream::StreamExt;
2

3
let stream = futures::stream::iter(vec![1, 2, 3]);

这里使用了iter方法来创建一个包含 1 到 3 的异步 Stream。

并行 Stream#

在 Rust 中，我们可以使用rayon库来创建并行 Stream。例如，我们可以使用以下代码来创建一个并行 Stream：

1
rayon = "1.7"

1
use rayon::iter::ParallelIterator;
2

3
let stream = (1..5).into_par_iter();

这里使用了into_par_iter方法将一个范围转换为并行 Stream。

处理 Stream 中的错误#

在处理 Stream 时，有时候会出现错误。我们可以使用Result来处理这些错误。例如，我们可以使用以下代码来处理 Stream 中的错误：

1
let stream = vec![1, 2, "a", 3].into_iter().map(|x| {
2
    if let Some(y) = x.downcast_ref::<i32>() {
3
        Ok(*y)
4
    } else {
5
        Err("not a number")
6
    }
7
});
8

9
for item in stream {
10
    match item {
11
        Ok(x) => println!("{}", x),
12
        Err(e) => println!("{}", e),
13
    }
14
}

这里使用了downcast_ref方法将元素转换为i32类型，如果转换失败则返回错误。

无限 Stream#

在 Rust 中，我们可以使用repeat方法来创建一个无限 Stream。例如，我们可以使用以下代码来创建一个包含无限个 1 的 Stream：

1
let stream = std::iter::repeat(1);

这里使用了repeat方法将 1 重复无限次。

处理 Stream 中的重复元素#

在处理 Stream 时，有时候会出现重复元素的情况。我们可以使用dedup方法来去除 Stream 中的重复元素。例如：

1
let stream = vec![1, 2, 2, 3, 3, 3].into_iter().dedup();

这里使用了dedup方法去除 Stream 中的重复元素。

处理 Stream 中的空元素#

在处理 Stream 时，有时候会出现空元素的情况。我们可以使用filter方法来过滤掉 Stream 中的空元素。例如：

1
let stream = vec![1, 2, "", 3, "", ""].into_iter().filter(|x| !x.is_empty());

这里使用了filter方法过滤掉 Stream 中的空元素。

处理 Stream 中的 None 值#

在处理 Stream 时，有时候会出现 None 值的情况。我们可以使用filter_map方法来过滤掉 Stream 中的 None 值。例如：

1
let stream = vec![Some(1), None, Some(2), None, Some(3)].into_iter().filter_map(|x| x);

这里使用了filter_map方法过滤掉 Stream 中的 None 值。

处理 Stream 中的重复元素#

在处理 Stream 时，有时候会出现重复元素的情况。我们可以使用dedup_by方法来去除 Stream 中的重复元素。例如：

1
let stream = vec!["a", "b", "bc", "cd", "de", "ef"].into_iter().dedup_by(|a, b| a.chars().next() == b.chars().next());

这里使用了dedup_by方法去除 Stream 中的重复元素，去重条件是元素的首字母相同。

最佳实践#

在使用 Stream 时，我们应该注意以下几点：

尽量使用异步 Stream 来处理 IO 操作，这样可以避免阻塞线程。
在处理大量数据时，应该使用并行 Stream 来提高程序的效率。
在处理错误时，应该使用Result来处理错误，避免程序崩溃。
在处理无限 Stream 时，应该使用take方法限制 Stream 的大小，避免程序无限运行。
在处理重复元素时，应该使用dedup或dedup_by方法去除重复元素，避免重复计算。

示例代码#

下面是一个完整的示例代码，演示了如何使用 Stream 来处理数据：

1
itertools = "0.10.5"
2
rayon = "1.7"
3
futures = "0.3.28"

1
use futures::stream::StreamExt;
2
use itertools::Itertools;
3
use rayon::iter::ParallelIterator;
4

5
fn main() {
6
    // 创建Stream
7
    let stream = (1..5).into_iter();
8

9
    // 遍历Stream
10
    stream.for_each(|x| println!("{}", x));
11

12
    // 过滤Stream
13
    let stream = (1..5).into_iter().filter(|x| x % 2 == 0);
14
    stream.for_each(|x| println!("{}", x));
15

16
    // 映射Stream
17
    let stream = (1..5).into_iter().map(|x| x * 2);
18
    stream.for_each(|x| println!("{}", x));
19

20
    // 合并Stream
21
    let stream1 = (1..3).into_iter();
22
    let stream2 = (4..6).into_iter();
23
    let stream = stream1.chain(stream2);
24
    stream.for_each(|x| println!("{}", x));
25

26
    // 排序Stream
27
    let stream = vec![3, 1, 4, 1, 5, 9].into_iter().sorted();
28
    stream.for_each(|x| println!("{}", x));
29

30
    // 取前n个元素
31
    let stream = (1..5).into_iter().take(3);
32
    stream.for_each(|x| println!("{}", x));
33

34
    // 跳过前n个元素
35
    let stream = (1..5).into_iter().skip(2);
36
    stream.for_each(|x| println!("{}", x));
37

38
    // 统计元素个数
39
    let stream = (1..5).into_iter();
40
    let count = stream.count();
41
    println!("{}", count);
42

43
    // 异步Stream
44
    let stream = futures::stream::iter(vec![1, 2, 3]);
45
    futures::executor::block_on(async {
46
        stream.for_each(|x| async move {
47
            println!("{}", x);
48
        }).await;
49
    });
50

51
    // 并行Stream
52
    let stream = (1..5).into_par_iter();
53
    stream.for_each(|x| println!("{}", x));
54

55
    // 处理Stream中的错误
56
    let stream = vec![1, 2, "a", 3].into_iter().map(|x| {
57
        if let Some(y) = x.downcast_ref::<i32>() {
58
            Ok(*y)
59
        } else {
60
            Err("not a number")
61
        }
62
    });
63

64
    for item in stream {
65
        match item {
66
            Ok(x) => println!("{}", x),
67
            Err(e) => println!("{}", e),
68
        }
69
    }
70

71
    // 无限Stream
72
    let stream = std::iter::repeat(1).take(5);
73
    stream.for_each(|x| println!("{}", x));
74

75
    // 处理Stream中的重复元素
76
    let stream = vec![1, 2, 2, 3, 3, 3].into_iter().dedup();
77
    stream.for_each(|x| println!("{}", x));
78

79
    // 处理Stream中的空元素
80
    let stream = vec![1, 2, "", 3, "", ""].into_iter().filter(|x| !x.is_empty());
81
    stream.for_each(|x| println!("{}", x));
82

83
    // 处理Stream中的None值
84
    let stream = vec![Some(1), None, Some(2), None, Some(3)].into_iter().filter_map(|x| x);
85
    stream.for_each(|x| println!("{}", x));
86

87
    // 处理Stream中的重复元素
88
    let stream = vec!["a", "b", "bc", "cd", "de", "ef"].into_iter().dedup_by(|a, b| a.chars().next() == b.chars().next());
89
    stream.for_each(|x| println!("{}", x));
90
}

展开收起

总结#

Stream 是 Rust 语言中非常重要的一个概念，它可以使得我们在处理数据时更加高效、灵活。在使用 Stream 时，我们应该注意异步、并行、错误处理、无限 Stream、重复元素等问题，这样才能写出高效、健壮的程序。

TinyZ's Blog

Rust语言从入门到精通系列 - SeaORM框架实战(数据库DML篇)

准备工作#

定义 Entity#

增加记录#

删除记录#

更新记录#

查询记录#

联表查询#

总结#

Rust语言从入门到精通系列 - SeaORM框架实践(基础篇)

基础用法#

连接到数据库#

定义表#

插入数据#

查询数据#

更新数据#

删除数据#

进阶用法#

关联表查询#

事务处理#

总结#

Rust语言从入门到精通系列 - SQLx模块MySQL入门

基础用法#

连接数据库#

URL连接#

配置文件连接#

查询数据#

使用query()方法#

使用query_as()方法#

插入数据#

使用execute()方法#

使用execute_with()方法#

更新数据#

使用execute()方法#

使用execute_with()方法#

删除数据#

使用execute()方法#

使用execute_with()方法#

进阶用法#

事务#

连接池#

总结#

Rust语言从入门到精通系列 - SQLx模块PostgreSQL入门

基础用法#

安装SQLx#

连接数据库#

执行查询#

使用query方法#

使用execute方法#

事务处理#

使用连接池#

使用SQLx宏#

进阶用法#

自定义类型映射#

使用SQLx的连接池管理器#

总结#

Rust语言从入门到精通系列 - SQLx模块SQLite入门

基础用法#

连接数据库#

创建表#

插入数据#

查询数据#

更新数据#

删除数据#

进阶用法#

事务#

批量插入#

总结#

Rust语言从入门到精通系列 - paho-mqtt模块实战(入门)

环境准备#

连接MQTT服务器#

发布MQTT消息#

订阅MQTT主题#

同时发布和订阅MQTT消息#

断开MQTT服务器连接#

进阶使用#

使用SSL/TLS连接MQTT服务器#

使用认证机制连接MQTT服务器#

总结#

定义 `Entity`#