.NetCore基于SqlSugar的工作单元—UnitOfWork

.NetCore基于SqlSugar和Aop的工作单元模式(UnitOfWork)实现

Unit Of Work 是什么

Unit Of Work模式，即工作单元，它是一种数据访问模式。它是用来维护一个由已经被业务修改(如增加、删除和更新等)的业务对象组成的列表。它负责协调这些业务对象的持久化工作及并发问题。通过数据库事务Unit Of Work模式会记录所有对象模型修改过的信息，在提交的时候，一次性修改，并把结果同步到数据库。 这个过程通常被封装在事务中。所以在采用Unit Of Work模式好处就在于能够确保数据的完整性，如果在持有一系列业务对象（同属于一个事务）的过程中出现问题，就可以将所有的修改回滚，以确保数据始终处于有效状态，不会出现脏数据。
用一句话概括就是：它让一个接口内的所有增删改操作都在一个事务中，要么同时成功提交，要么同时失败回滚。
代码实现

创建工作单元依赖接口：

1. /// <summary>
2. /// 工作单元依赖接口
3. /// </summary>
4. public interface IUnitOfWork
5. {
6.     /// <summary>
7.     /// 开启工作单元处理
8.     /// </summary>
9.     /// <param name="context"></param>
10.     /// <param name="unitOfWork"></param>
11.     void BeginTransaction(ActionExecutingContext context);
13.     /// <summary>
14.     /// 提交工作单元处理
15.     /// </summary>
16.     /// <param name="resultContext"></param>
17.     /// <param name="unitOfWork"></param>
18.     void CommitTransaction(ActionExecutedContext resultContext);
20.     /// <summary>
21.     /// 回滚工作单元处理
22.     /// </summary>
23.     /// <param name="resultContext"></param>
24.     /// <param name="unitOfWork"></param>
25.     void RollbackTransaction(ActionExecutedContext resultContext);
27.     /// <summary>
28.     /// 执行完毕（无论成功失败）
29.     /// </summary>
30.     /// <param name="context"></param>
31.     /// <param name="resultContext"></param>
32.     void OnCompleted(ActionExecutingContext context, ActionExecutedContext resultContext);
33. }

复制代码

继承接口并实现：

1. public class SqlSugarUnitOfWork : IUnitOfWork
2. {
3.     private readonly ISqlSugarClient _sqlSugarClient;
5.     public SqlSugarUnitOfWork(ISqlSugarClient sqlSugarClient)
6.     {
7.         this._sqlSugarClient = sqlSugarClient;
8.     }
9.     public void BeginTransaction(ActionExecutingContext context)
10.     {
11.         _sqlSugarClient.AsTenant().BeginTran();
12.     }
14.     public void CommitTransaction(ActionExecutedContext resultContext)
15.     {
16.         _sqlSugarClient.AsTenant().CommitTran();
17.     }
19.     public void OnCompleted(ActionExecutingContext context, ActionExecutedContext resultContext)
20.     {
21.         _sqlSugarClient.Dispose();
22.     }
24.     public void RollbackTransaction(ActionExecutedContext resultContext)
25.     {
26.         _sqlSugarClient.AsTenant().RollbackTran();
27.     }
28. }

复制代码

注入到容器中：

1. services.AddTransient<IUnitOfWork, SqlSugarUnitOfWork>(); // 注册工作单元到容器

复制代码

此时，工作单元已经添加到容器中，为了更方便的使用，我们可以使用AspNetCore框架自带的过滤器实现AOP的方式来使用工作单元。
首先需要创建工作单元特性（特性是为了方便配置哪些接口需要启用工作单元）：

1. /// <summary>
2. /// 工作单元配置特性
3. /// </summary>
4. [AttributeUsage(AttributeTargets.Method)]
5. public class UnitOfWorkAttribute : Attribute {}

复制代码

然后创建过滤器：

1. /// <summary>
2. /// 工作单元Action过滤器
3. /// </summary>
4. public class UnitOfWorkFilter : IAsyncActionFilter, IOrderedFilter
5. {
7.     private readonly ILogger<UnitOfWorkFilter> _logger;
8.     public UnitOfWorkFilter(ILogger<UnitOfWorkFilter> logger)
9.     {
10.         this._logger = logger;
11.     }
12.     /// <summary>
13.     /// 过滤器排序
14.     /// </summary>
15.     internal const int FilterOrder = 999;
17.     /// <summary>
18.     /// 排序属性
19.     /// </summary>
20.     public int Order => FilterOrder;
22.     /// <summary>
23.     /// 拦截请求
24.     /// </summary>
25.     /// <param name="context">动作方法上下文</param>
26.     /// <param name="next">中间件委托</param>
27.     public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
28.     {
29.         // 获取动作方法描述器
30.         var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
31.         var method = actionDescriptor.MethodInfo;
33.         // 获取请求上下文
34.         var httpContext = context.HttpContext;
36.         // 如果没有定义工作单元过滤器，则跳过
37.         if (!method.IsDefined(typeof(UnitOfWorkAttribute), true))
38.         {
39.             // 调用方法
40.             _ = await next();
42.             return;
43.         }
45.         // 打印工作单元开始消息
46.         _logger.LogInformation($@"{nameof(UnitOfWorkFilter)} Beginning");
48.         // 解析工作单元服务
49.         var _unitOfWork = httpContext.RequestServices.GetRequiredService<IUnitOfWork>();
51.         // 调用开启事务方法
52.         _unitOfWork.BeginTransaction(context);
54.         // 获取执行 Action 结果
55.         var resultContext = await next();
57.         if (resultContext == null || resultContext.Exception == null)
58.         {
59.             // 调用提交事务方法
60.             _unitOfWork.CommitTransaction(resultContext);
61.         }
62.         else
63.         {
64.             // 调用回滚事务方法
65.             _unitOfWork.RollbackTransaction(resultContext);
66.         }
68.         // 调用执行完毕方法
69.         _unitOfWork.OnCompleted(context, resultContext);
71.         // 打印工作单元结束消息  
72.         _logger.LogInformation($@"{nameof(UnitOfWorkFilter)} Ending");
74.     }
75. }

复制代码

需要将过滤器添加到通信管道中才会起作用：

1. services.AddControllers(options =>
2. {
3.     // 添加 工作单元过滤器
4.     options.Filters.Add<UnitOfWorkFilter>();
5. });

复制代码

到这一步，工作单元已经准备好了。
接下来是调用方式，很简单，只要在你想启用工作单元的接口上（也就是Controller中的Action），加上工作单元的特性就可以了，像这样：

1. [Route("test")]
2. public class TestController : ControllerBase
3. {
4.     private readonly IBaseRepository<Student> _studentRepository;
5.     private readonly IBaseRepository<Teacher> _teacherRepository;
7.     public TestController(IBaseRepository<Student> studentRepository,
8.         IBaseRepository<Teacher> teacherRepository)
9.     {
10.         this._studentRepository = studentRepository;
11.         this._teacherRepository = teacherRepository;
12.     }
14.     [HttpGet, UnitOfWork]
15.     public async Task<IActionResult> AddTestAsync()
16.     {
17.         await _studentRepository.InsertAsync(new Student
18.         {
19.             Name = "Hello",
20.             Age = 22
21.         });
23.         await _teacherRepository.InsertAsync(new Teacher
24.         {
25.             Name = "World",
26.             Age = 35,
27.             Subject = 1
28.         });
30.         return Ok("Ok");
31.     }
32. }

复制代码

由上面的例子可以看到，_studentRepository 和 _teacherRepository 两个仓储分别进行了添加操作，但是他们实际是在一个事务中进行的，所以如果出现异常，事务中的所有操作都会回滚，从而达到操作原子性。
为了缩减篇幅，代码我省略一部分，详细的示例项目上传到GitHub：

1. https://github.com/young-qiang/UnitOfWork.Demo.git

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！