如何在Service层实现与Repository层类似的数据库事务？

完全可行，核心思路是通过抽象事务上下文隔离数据库实现细节，让Service层仅依赖抽象接口而非具体数据库类型。

具体实现步骤 #

1. 定义抽象事务上下文Trait #

创建不包含数据库特定类型的Trait，作为事务的通用抽象：

use std::future::Future;

// 抽象事务上下文，屏蔽数据库底层细节
pub trait TransactionContext {
    // 通用执行方法，允许Repository层基于上下文操作
    fn run<F, R, E>(&mut self, f: F) -> impl Future<Output = Result<R, E>>
    where
        F: FnOnce(&mut dyn TransactionContext) -> impl Future<Output = Result<R, E>>,
        E: std::error::Error;
}

2. 适配Repository层方法签名 #

修改Repository的方法，将参数从具体数据库事务替换为抽象的TransactionContext：

pub trait PlayerRepository {
    async fn find_player_id(&self, tx: Option<&mut dyn TransactionContext>, id: &str) -> Result<String, Error>;
    async fn find_team_id(&self, tx: Option<&mut dyn TransactionContext>, id: &str) -> Result<String, Error>;
}

3. 数据库实现适配抽象上下文 #

针对PostgreSQL事务实现TransactionContext，把具体事务包装成抽象类型：

use sqlx::postgres::PgTransaction;

// 包装PgTransaction的上下文实现
pub struct PgTxContext {
    tx: PgTransaction<'static>,
}

impl TransactionContext for PgTxContext {
    async fn run<F, R, E>(&mut self, f: F) -> Result<R, E>
    where
        F: FnOnce(&mut dyn TransactionContext) -> impl Future<Output = Result<R, E>>,
        E: std::error::Error,
    {
        f(self).await
    }
}

// 修改PgDatabase的Repository实现，适配抽象上下文
impl PlayerRepository for PgDatabase {
    async fn find_player_id(&self, tx: Option<&mut dyn TransactionContext>, id: &str) -> Result<String, Error> {
        match tx {
            Some(tx) => {
                // 通过类型向下转型获取具体事务，执行查询
                let query = sqlx::query_scalar!("SELECT player_id FROM players WHERE id = $1", id)
                    .fetch_one(tx.downcast_mut::<PgTxContext>().unwrap())
                    .await?;
                Ok(query.unwrap_or_default())
            }
            None => {
                // 无事务时直接使用连接池
                let query = sqlx::query_scalar!("SELECT player_id FROM players WHERE id = $1", id)
                    .fetch_one(&self.pool)
                    .await?;
                Ok(query.unwrap_or_default())
            }
        }
    }

    // find_team_id方法做同样适配即可
}

4. Service层管理事务 #

Service层仅依赖抽象的Repository和事务上下文，完全看不到数据库具体类型：

pub struct PlayerService {
    player_repo: Box<dyn PlayerRepository>,
    db_pool: sqlx::PgPool, // 可进一步抽象连接池Trait彻底隐藏
}

impl PlayerService {
    async fn process_player(&self, id: &str) -> Result<String, Error> {
        // 开启事务并包装为抽象上下文
        let mut tx = self.db_pool.begin().await?;
        let mut tx_ctx = PgTxContext { tx };

        // 在事务内调用Repository方法
        let _team_id = self.player_repo.find_team_id(Some(&mut tx_ctx), id).await?;
        let player_id = self.player_repo.find_player_id(Some(&mut tx_ctx), id).await?;

        // 执行其他事务内操作...

        // 提交事务
        tx_ctx.tx.commit().await?;

        Ok(player_id)
    }
}

进阶优化：彻底隐藏连接池 #

若要完全脱离具体数据库连接池，可再定义抽象连接池Trait：

pub trait DbPool {
    async fn begin(&self) -> Result<Box<dyn TransactionContext>, Error>;
}

impl DbPool for sqlx::PgPool {
    async fn begin(&self) -> Result<Box<dyn TransactionContext>, Error> {
        let tx = self.begin().await?;
        Ok(Box::new(PgTxContext { tx }))
    }
}

此时Service层的db_pool可替换为Box<dyn DbPool>，实现与数据库实现的完全解耦。

内容的提问来源于stack exchange，提问作者Fred Hors