ABP - 工作单元（Unit of Work）[UnitOfWorkAttribute、IUnitOfWorkManager、UnitOfWorkOptions]

一、工作单元（Unit of Work）

核心辅助类：

IUnitOfWorkManager：管理工作单元。
UnitOfWorkAttribute：标记方法为工作单元（自动事务）。
UnitOfWorkOptions：工作单元配置选项（如事务隔离级别、超时时间）。

在ABP框架中，工作单元（Unit of Work，简称UoW） 是管理数据一致性的核心机制，用于将多个数据库操作（如新增、更新、删除）封装在一个事务中，确保“要么全部成功，要么全部失败”。以下是IUnitOfWorkManager、UnitOfWorkAttribute、UnitOfWorkOptions三个核心类的详细示例和示例：

一、UnitOfWorkAttribute：声明式事务管理（最常用）

UnitOfWorkAttribute是标记方法为工作单元的特性，通过声明式语法自动管理事务：当方法执行成功时自动提交事务，发生异常时自动回滚，无需手动编写事务代码。

1. 基础用法（默认事务）

using Volo.Abp.UnitOfWork;
using Volo.Abp.Application.Services;

public class OrderAppService : ApplicationService
{
    private readonly IRepository<Order, Guid> _orderRepo;
    private readonly IRepository<Inventory, Guid> _inventoryRepo;

    public OrderAppService(
        IRepository<Order, Guid> orderRepo,
        IRepository<Inventory, Guid> inventoryRepo)
    {
        _orderRepo = orderRepo;
        _inventoryRepo = inventoryRepo;
    }

    // 标记此方法为工作单元：订单创建和库存扣减在同一事务中
    [UnitOfWork]
    public async Task CreateOrderAsync(CreateOrderInput input)
    {
        // 1. 创建订单
        var order = new Order
        {
            ProductId = input.ProductId,
            Quantity = input.Quantity,
            TotalAmount = input.Quantity * input.UnitPrice
        };
        await _orderRepo.InsertAsync(order);

        // 2. 扣减库存（若此处抛异常，订单创建会自动回滚）
        var inventory = await _inventoryRepo.GetAsync(x => x.ProductId == input.ProductId);
        inventory.Stock -= input.Quantity;
        if (inventory.Stock < 0)
        {
            throw new UserFriendlyException("库存不足！"); // 触发回滚
        }
        await _inventoryRepo.UpdateAsync(inventory);
    }
}

2. 自定义事务配置（通过`UnitOfWorkOptions`）

通过特性参数配置事务隔离级别、超时时间等：

// 自定义事务：隔离级别为ReadCommitted，超时时间30秒
[UnitOfWork(IsolationLevel = IsolationLevel.ReadCommitted, Timeout = 30)]
public async Task BatchUpdatePricesAsync(decimal rate)
{
    var products = await _productRepo.GetListAsync();
    foreach (var product in products)
    {
        product.Price *= rate; // 批量更新价格
    }
    await _productRepo.UpdateManyAsync(products);
}

讲解

自动事务管理：被[UnitOfWork]标记的方法，框架会自动开启事务，所有仓储操作（InsertAsync/UpdateAsync等）都在同一事务中执行。
异常回滚：若方法内部抛出未捕获的异常，事务会自动回滚，确保数据一致性。
适用场景：多步数据库操作（如“创建订单+扣减库存”“转账+记录流水”），需要保证原子性的场景。

二、IUnitOfWorkManager：手动管理工作单元（灵活控制）

当需要更灵活的事务控制（如嵌套事务、条件性提交）时，可通过IUnitOfWorkManager手动创建和管理工作单元。

1. 手动开启和提交事务

using Volo.Abp.UnitOfWork;
using Volo.Abp.DependencyInjection;

public class InventoryService : ITransientDependency
{
    private readonly IUnitOfWorkManager _unitOfWorkManager;
    private readonly IRepository<Inventory, Guid> _inventoryRepo;
    private readonly IRepository<InventoryLog, Guid> _logRepo;

    public InventoryService(
        IUnitOfWorkManager unitOfWorkManager,
        IRepository<Inventory, Guid> inventoryRepo,
        IRepository<InventoryLog, Guid> logRepo)
    {
        _unitOfWorkManager = unitOfWorkManager;
        _inventoryRepo = inventoryRepo;
        _logRepo = logRepo;
    }

    public async Task AdjustStockAsync(Guid productId, int count)
    {
        // 1. 手动开启工作单元（事务）
        using (var uow = _unitOfWorkManager.Begin(
            options: new UnitOfWorkOptions
            {
                IsolationLevel = IsolationLevel.Serializable, // 高隔离级别
                Timeout = 60 // 超时时间60秒
            }))
        {
            // 2. 扣减库存
            var inventory = await _inventoryRepo.GetAsync(x => x.ProductId == productId);
            inventory.Stock += count;
            await _inventoryRepo.UpdateAsync(inventory);

            // 3. 记录操作日志
            await _logRepo.InsertAsync(new InventoryLog
            {
                ProductId = productId,
                AdjustCount = count,
                OperateTime = DateTime.Now
            });

            // 4. 手动提交事务（若不调用，using结束后会自动回滚）
            await uow.CompleteAsync();
        }
    }
}

2. 嵌套工作单元（子事务）

ABP支持嵌套工作单元，子单元共享父单元的事务，只有最外层单元提交后才会真正执行：

[UnitOfWork] // 外层工作单元
public async Task ProcessOrderAsync(Guid orderId)
{
    // 外层操作：更新订单状态
    var order = await _orderRepo.GetAsync(orderId);
    order.Status = OrderStatus.Processing;
    await _orderRepo.UpdateAsync(order);

    // 调用包含内层工作单元的方法（共享外层事务）
    await _inventoryService.AdjustStockAsync(order.ProductId, -order.Quantity);
    await _paymentService.RecordPaymentAsync(orderId, order.TotalAmount);
}

// 内层方法（无需单独标记，自动加入外层事务）
public async Task AdjustStockAsync(Guid productId, int count)
{
    // 操作自动加入外层事务
    var inventory = await _inventoryRepo.GetAsync(x => x.ProductId == productId);
    inventory.Stock += count;
    await _inventoryRepo.UpdateAsync(inventory);
}

讲解

核心方法：
- Begin()：手动开启工作单元，返回IUnitOfWork对象。
- CompleteAsync()：手动提交事务（必须调用，否则事务会回滚）。
共享事务：嵌套工作单元不会创建新事务，而是共享外层事务，确保所有操作在同一事务中。
适用场景：需要条件性提交（如“满足某个条件才提交”）、动态控制事务范围的复杂场景。

三、UnitOfWorkOptions：工作单元配置选项

UnitOfWorkOptions用于配置工作单元的行为，如事务隔离级别、超时时间、是否启用事务等，可配合[UnitOfWork]特性或IUnitOfWorkManager.Begin()使用。

常用配置项

配置项	作用	示例值
`IsolationLevel`	事务隔离级别（控制并发数据可见性）	`IsolationLevel.ReadCommitted`（默认）、`IsolationLevel.Serializable`（最高隔离）
`Timeout`	事务超时时间（秒）	`30`（30秒超时）
`IsTransactional`	是否启用事务（默认`true`）	`false`（仅查询时可禁用事务提升性能）
`Scope`	事务范围（`Required`/`RequiresNew`）	`TransactionScopeOption.RequiresNew`（强制创建新事务）

示例：禁用事务（纯查询场景）

// 纯查询操作，禁用事务提升性能
[UnitOfWork(IsTransactional = false)]
public async Task<List<ProductDto>> GetProductsAsync()
{
    var products = await _productRepo.GetListAsync();
    return ObjectMapper.Map<List<Product>, List<ProductDto>>(products);
}

示例：强制创建新事务

public async Task ImportDataAsync(List<Product> products)
{
    // 强制创建独立事务（不依赖外层事务）
    using (var uow = _unitOfWorkManager.Begin(
        new UnitOfWorkOptions { Scope = TransactionScopeOption.RequiresNew }))
    {
        await _productRepo.InsertManyAsync(products);
        await uow.CompleteAsync(); // 独立提交
    }
}

讲解

隔离级别选择：高隔离级别（如Serializable）保证数据一致性，但并发性能低；低隔离级别（如ReadUncommitted）性能高，但可能出现脏读，需根据业务场景选择。
禁用事务：纯查询操作（无写入）可禁用事务（IsTransactional = false），减少数据库性能开销。
新事务场景：需要独立提交的操作（如“日志记录无论主操作成功与否都必须保存”），可强制创建新事务。

四、工作单元的核心原理与最佳实践

1. 自动生效场景

ABP框架在以下场景会自动启用工作单元（无需手动标记）：

应用服务（ApplicationService）的公共方法。
仓储的InsertAsync/UpdateAsync/DeleteAsync等方法。

2. 最佳实践

优先使用[UnitOfWork]特性：声明式语法更简洁，适合大多数场景。
纯查询禁用事务：通过IsTransactional = false提升查询性能。
控制事务范围：避免超大事务（如批量处理10万条数据），拆分小事务减少锁表时间。
嵌套事务慎用RequiresNew：除非必要，否则优先共享事务，减少数据库压力。

总结：三类核心类的关系与适用场景

类/特性	作用	适用场景
`UnitOfWorkAttribute`	声明式标记工作单元，自动管理事务	大多数CRUD场景，多步操作需原子性
`IUnitOfWorkManager`	手动创建和控制工作单元	复杂事务逻辑（条件提交、嵌套事务）
`UnitOfWorkOptions`	配置工作单元行为（隔离级别、超时等）	自定义事务属性，优化性能或保证数据一致性

通过工作单元，ABP框架简化了事务管理复杂度，开发者无需深入数据库事务细节，即可确保数据操作的一致性。

二、工作单元（Unit of Work）入门详解：从概念到实操

如果你是第一次接触“工作单元”，可以先把它理解成 “数据库操作的打包工具” ——把多个零散的数据库操作（比如“创建订单+扣减库存”）装进一个“包”里，这个“包”要么全部执行成功，要么全部失败，绝不会出现“订单创建了但库存没扣”的混乱情况。

下面用更通俗的语言，结合生活例子和基础代码，把UnitOfWorkAttribute、IUnitOfWorkManager、UnitOfWorkOptions讲清楚，确保零基础也能懂。

一、先搞懂：为什么需要工作单元？（生活例子）

假设你在网上买手机，整个支付流程要做两件事：

扣你银行卡里的钱（操作1：更新银行卡余额）；
给你生成订单（操作2：新增订单记录）。

如果没有“工作单元”，可能出现两种糟糕情况：

情况1：钱扣了，但订单没生成（你亏了）；
情况2：订单生成了，但钱没扣（商家亏了）。

而“工作单元”就是给这两个操作加了个“保险”：只有两件事都成功，才算整个流程完成；只要有一件失败，就恢复到操作前的状态（钱不扣，订单也不生成），这就是“事务一致性”。

二、UnitOfWorkAttribute：最简单的“打包工具”（一键生效）

这是最常用的工具，不用写复杂代码，只要给方法加个[UnitOfWork]标签，就能自动把方法里的所有数据库操作“打包”成一个事务。

1. 基础例子：创建订单+扣减库存

// 订单服务类
public class OrderService : ApplicationService
{
    // 依赖两个仓储（可以理解成“操作订单表”和“操作库存表”的工具）
    private readonly IRepository<Order, Guid> _orderRepo; // 订单表操作工具
    private readonly IRepository<Inventory, Guid> _inventoryRepo; // 库存表操作工具

    // 构造函数：框架自动把两个工具“递”进来
    public OrderService(IRepository<Order, Guid> orderRepo, IRepository<Inventory, Guid> inventoryRepo)
    {
        _orderRepo = orderRepo;
        _inventoryRepo = inventoryRepo;
    }

    // 给方法加[UnitOfWork]标签：自动打包事务
    [UnitOfWork]
    public async Task BuyPhoneAsync(BuyPhoneInput input)
    {
        // 操作1：创建订单（往订单表插一条数据）
        var order = new Order
        {
            PhoneModel = input.PhoneModel, // 手机型号（比如“iPhone 15”）
            Price = input.Price, // 价格
            BuyTime = DateTime.Now // 购买时间
        };
        await _orderRepo.InsertAsync(order); // 执行插入

        // 操作2：扣减库存（往库存表改一条数据）
        // 先找到这款手机的库存记录
        var phoneInventory = await _inventoryRepo.GetAsync(x => x.PhoneModel == input.PhoneModel);
        // 库存减1
        phoneInventory.Stock -= 1;

        // 关键：如果库存不够（比如只剩0了），抛异常
        if (phoneInventory.Stock < 0)
        {
            throw new UserFriendlyException("库存不足，买不了！");
        }

        // 执行库存更新
        await _inventoryRepo.UpdateAsync(phoneInventory);
    }
}

2. 它是怎么工作的？（通俗解释）

当你调用BuyPhoneAsync方法时，框架看到[UnitOfWork]标签，会先对数据库说：“准备开始一组操作，先别真正执行，等我通知”；
然后执行“创建订单”和“扣减库存”：这两步只是“临时记录”，没真正写到数据库；
如果没抛异常（库存足够）：框架通知数据库“所有操作都没问题，现在真正执行”；
如果抛异常（库存不足）：框架通知数据库“操作失败，把刚才的临时记录全删掉，恢复原样”。

3. 适合场景

只要方法里有多个数据库操作（比如“插表+改表”“改表+改表”），都建议加这个标签，避免数据混乱。

三、IUnitOfWorkManager：手动“打包”（更灵活的场景）

有时候你需要更灵活的控制，比如“先判断一个条件，满足条件才执行整个包”，这时候就需要用IUnitOfWorkManager手动“打包”。

1. 例子：满足“余额足够”才扣钱+生成订单

public class PaymentService : ApplicationService
{
    // 手动打包工具
    private readonly IUnitOfWorkManager _uowManager;
    // 操作表的工具：订单表、用户余额表
    private readonly IRepository<Order, Guid> _orderRepo;
    private readonly IRepository<UserBalance, Guid> _balanceRepo;

    // 框架自动把工具递进来
    public PaymentService(IUnitOfWorkManager uowManager, IRepository<Order, Guid> orderRepo, IRepository<UserBalance, Guid> balanceRepo)
    {
        _uowManager = uowManager;
        _orderRepo = orderRepo;
        _balanceRepo = balanceRepo;
    }

    public async Task PayWithBalanceAsync(PayInput input)
    {
        // 1. 先查用户余额（这步不进“包”，只是普通查询）
        var userBalance = await _balanceRepo.GetAsync(x => x.UserId == input.UserId);
        // 判断：如果余额不够，直接返回失败，不执行后续操作
        if (userBalance.Money < input.PayAmount)
        {
            throw new UserFriendlyException("余额不够，支付失败！");
        }

        // 2. 手动开启“包”（事务）
        using (var uow = _uowManager.Begin())
        {
            // 操作1：扣用户余额
            userBalance.Money -= input.PayAmount;
            await _balanceRepo.UpdateAsync(userBalance);

            // 操作2：生成支付订单
            var order = new Order
            {
                UserId = input.UserId,
                PayAmount = input.PayAmount,
                PayType = "余额支付"
            };
            await _orderRepo.InsertAsync(order);

            // 3. 手动告诉框架：“所有操作没问题，执行这个包”
            await uow.CompleteAsync();
        }
    }
}

2. 关键细节

using (var uow = _uowManager.Begin())：相当于“打开一个空包，准备装操作”；
await uow.CompleteAsync()：相当于“包已经装满，现在执行所有操作”；
如果CompleteAsync()之前抛异常，框架会自动“扔掉这个包”（不执行任何操作）。

3. 适合场景

需要先做判断，再决定是否执行整个事务，或者需要分步骤控制事务范围（比如“先查数据，再执行修改”）的场景。

四、UnitOfWorkOptions：给“包”加配置（优化性能/保证安全）

这个工具相当于给“包”加一些“规则”，比如“这个包最多执行30秒，超时就失败”“这个包不需要事务，只查数据”。

1. 常用配置：3个最实用的规则

配置项	作用（通俗解释）	例子
`IsTransactional`	是否需要事务（默认需要）	纯查询时设为`false`，更快
`Timeout`	超时时间（秒）：超过时间就失败	设为`30`，避免操作卡太久
`IsolationLevel`	隔离级别（控制并发安全）	高并发场景设为`Serializable`，更安全

2. 例子1：纯查询场景，关闭事务（更快）

如果方法里只有“查数据”，没有“改数据”，可以关闭事务，让查询更快：

// 给方法加标签，配置“不需要事务”
[UnitOfWork(IsTransactional = false)]
public async Task<List<PhoneDto>> GetAllPhonesAsync()
{
    // 只有查询，没有修改，关闭事务提升速度
    var phones = await _phoneRepo.GetListAsync();
    return ObjectMapper.Map<List<Phone>, List<PhoneDto>>(phones);
}

3. 例子2：手动配置“超时30秒”

public async Task BatchImportDataAsync(List<Phone> phones)
{
    // 手动开启包，配置“最多执行30秒”
    using (var uow = _uowManager.Begin(
        new UnitOfWorkOptions { Timeout = 30 }))
    {
        // 批量插入数据（可能很慢，所以加超时）
        await _phoneRepo.InsertManyAsync(phones);
        await uow.CompleteAsync();
    }
}

五、零基础必记的3个关键点

核心目的：工作单元就是为了保证“多个数据库操作的一致性”，要么全成，要么全败；
优先用[UnitOfWork]：90%的场景用这个标签就够了，简单高效；
纯查询关事务：如果方法里只有“查数据”，记得加IsTransactional = false，让查询更快。

六、常见问题（新手避坑）

问题1：加了[UnitOfWork]但没生效？
答：检查方法是不是public（框架只对公共方法生效），或者是不是在ApplicationService、DomainService等框架管理的类里。
问题2：手动开启包后，忘了写CompleteAsync()？
答：会导致事务自动回滚，所有操作都不生效，一定要记得在using块里加await uow.CompleteAsync()。

posted @ 2025-10-24 21:17 【唐】三三阅读(3) 评论(0) 收藏举报

刷新页面返回顶部

【唐】三三

ConFused Road, ConFused People, All In [Tang]San.

ABP - 工作单元（Unit of Work）[UnitOfWorkAttribute、IUnitOfWorkManager、UnitOfWorkOptions]

一、工作单元（Unit of Work）

一、UnitOfWorkAttribute：声明式事务管理（最常用）

1. 基础用法（默认事务）

2. 自定义事务配置（通过`UnitOfWorkOptions`）

讲解

二、IUnitOfWorkManager：手动管理工作单元（灵活控制）

1. 手动开启和提交事务

2. 嵌套工作单元（子事务）

讲解

三、UnitOfWorkOptions：工作单元配置选项

常用配置项

示例：禁用事务（纯查询场景）

示例：强制创建新事务

讲解

四、工作单元的核心原理与最佳实践

1. 自动生效场景

2. 最佳实践

总结：三类核心类的关系与适用场景

二、工作单元（Unit of Work）入门详解：从概念到实操

一、先搞懂：为什么需要工作单元？（生活例子）

二、UnitOfWorkAttribute：最简单的“打包工具”（一键生效）

1. 基础例子：创建订单+扣减库存

2. 它是怎么工作的？（通俗解释）

3. 适合场景

三、IUnitOfWorkManager：手动“打包”（更灵活的场景）

1. 例子：满足“余额足够”才扣钱+生成订单

2. 关键细节

3. 适合场景

四、UnitOfWorkOptions：给“包”加配置（优化性能/保证安全）

1. 常用配置：3个最实用的规则

2. 例子1：纯查询场景，关闭事务（更快）

3. 例子2：手动配置“超时30秒”

五、零基础必记的3个关键点

六、常见问题（新手避坑）

公告

【唐】三三

ConFused Road, ConFused People, All In [Tang]San.

ABP - 工作单元（Unit of Work）[UnitOfWorkAttribute、IUnitOfWorkManager、UnitOfWorkOptions]

一、工作单元（Unit of Work）

一、UnitOfWorkAttribute：声明式事务管理（最常用）

1. 基础用法（默认事务）

2. 自定义事务配置（通过UnitOfWorkOptions）

讲解

二、IUnitOfWorkManager：手动管理工作单元（灵活控制）

1. 手动开启和提交事务

2. 嵌套工作单元（子事务）

讲解

三、UnitOfWorkOptions：工作单元配置选项

常用配置项

示例：禁用事务（纯查询场景）

示例：强制创建新事务

讲解

四、工作单元的核心原理与最佳实践

1. 自动生效场景

2. 最佳实践

总结：三类核心类的关系与适用场景

二、工作单元（Unit of Work）入门详解：从概念到实操

一、先搞懂：为什么需要工作单元？（生活例子）

二、UnitOfWorkAttribute：最简单的“打包工具”（一键生效）

1. 基础例子：创建订单+扣减库存

2. 它是怎么工作的？（通俗解释）

3. 适合场景

三、IUnitOfWorkManager：手动“打包”（更灵活的场景）

1. 例子：满足“余额足够”才扣钱+生成订单

2. 关键细节

3. 适合场景

四、UnitOfWorkOptions：给“包”加配置（优化性能/保证安全）

1. 常用配置：3个最实用的规则

2. 例子1：纯查询场景，关闭事务（更快）

3. 例子2：手动配置“超时30秒”

五、零基础必记的3个关键点

六、常见问题（新手避坑）

公告

2. 自定义事务配置（通过`UnitOfWorkOptions`）