首页 > 其他分享> > [开源]OSharpNS 步步为营系列 - 3. 添加业务服务层

[开源]OSharpNS 步步为营系列 - 3. 添加业务服务层

2019-05-11 08:52:29 作者：互联网

什么是OSharp

OSharpNS全称OSharp Framework with .NetStandard2.0，是一个基于.NetStandard2.0开发的一个.NetCore快速开发框架。这个框架使用最新稳定版的.NetCore SDK（当前是.NET Core 2.2），对 AspNetCore 的配置、依赖注入、日志、缓存、实体框架、Mvc(WebApi)、身份认证、权限授权等模块进行更高一级的自动化封装，并规范了一套业务实现的代码结构与操作流程，使 .Net Core 框架更易于应用到实际项目开发中。

开源地址：https://github.com/i66soft/osharp
官方示例：https://www.osharp.org
文档中心：https://docs.osharp.org
VS 插件：https://marketplace.visualstudio.com/items?itemName=LiuliuSoft.osharp

概述

一个模块的服务层，主要负责如下几个方面的工作：

向 API层提供各个实体的数据查询的 IQueryable<T> 类型的数据源
接收 API层传入的 IInputDto 参数，完成实体的 新增、更新、删除 等业务操作
接收 API层传入的参数，处理各种 模块级别 的综合业务
处理完业务之后，将数据通过数据仓储IRepository 更新到数据库
向 事件总线 模块发布业务处理事件，触发订阅的业务事件
向 API 层返回业务操作结果

整个过程如下图所示：

服务层代码布局

服务层代码布局分析

一个业务模块，是负责完成一系列功能的，这些功能相互之间具有密切的关联性，所以对于一个模块来说，业务服务是一个整体，不应把他们再按单个实体拆分开来。
OSharp 的业务模块代码结构设计，也是根据这一原则来设计的。设计规则如下：

服务接口IBlogsContract：一个模块的业务服务共享一个服务接口，接口中包含模块的综合业务服务，也包含模块的各个实体的查询数据集、新增、更新、删除等自有业务服务。
服务实现BlogsService：服务实现使用分部类partial 设计，例如本例中的博客模块业务，文件拆分如下：
- BlogsService.cs：博客模块服务实现类的主文件，负责各实体的仓储服务注入，辅助服务注入，模块综合业务实现
- BlogsService.Blog.cs：博客模块服务的博客实体服务实现类，负责博客实体的 查询数据集、增改删 业务实现
- BlogsService.Post.cs：博客模块服务的文章实体服务实现类，负责文章实体的 查询数据集、增改删 业务实现
模块入口BlogsPack：定义模块的级别、启动顺序、执行服务添加、模块初始化等功能

综上，服务层代码布局如下所示：

src                                         # 源代码文件夹
└─Liuliu.Blogs.Core                         # 项目核心工程
   └─Blogs                                  # 博客模块文件夹
        ├─Events                            # 业务事件文件夹
        │    ├─VerifyBlogEventData.cs       # 审核博客事件数据
        │    └─VerifyBlogEventHandler.cs    # 审核博客事件处理器
        ├─BlogsPack.cs                      # 博客模块入口类
        ├─BlogsService.cs                   # 博客服务类
        ├─BlogsService.Blog.cs              # 博客模块-博客服务类
        ├─BlogsService.Post.cs              # 博客模块-文章服务类
        └─IBlogsContract.cs                 # 博客模块服务接口

服务接口 IBlogsContract

接口定义分析

数据查询

对于数据查询，业务层只向 API 层开放一个 IQueryable<TEntity> 的查询数据集。原则上，服务层不实现 纯数据查询（例如用于列表分页数据、下拉菜单选项等数据，不涉及数据变更的查询操作）的服务，所有的 纯数据查询 都在 API层按需要进行查询。具体分析请看 >>数据查询应该在哪做>>

额外的，根据一定条件判断一个数据是否存在 这种需求经常会用到（例如在新增或修改一个要求唯一的字符串时，需要异步检查输入的字符串是否已存在），因此设计一个检查实体是否存在CheckEntityExists 的服务很有必要。

!!!node
对于新增、更新、删除操作，除非很确定一次只操作一条记录除外，为了支持可能的批量操作，设计上都应把服务层的增改删操作设计为数组型参数的批量操作，同时使用 params 关键字使操作支持单个数据操作。

数据变更

对于每一个实体，服务层按 业务需求分析 的要求定义必要的 新增、更新、删除 等操作，OSharp框架定义了一个业务操作结果信息类 OperationResult 来封装业务操作结果，这个结果可以返回操作结果类型（成功/错误/未变化/不存在/验证失败）、返回消息、返回附加数据等丰富的信息，API层接受操作结果后可进行相应的处理。

博客模块的接口定义

回到我们的 Liuliu.Blogs 项目，根据 <业务模块设计#服务层> 的需求分析，我们需要给博客Blog 实体定义 申请开通、开通审核、更新、删除 服务，给文章Post 实体类定义 新增、更新、删除 服务。

接口定义如下：


/// <summary>
/// 业务契约接口：博客模块
/// </summary>
public interface IBlogsContract
{
    #region 博客信息业务

    /// <summary>
    /// 获取 博客信息查询数据集
    /// </summary>
    IQueryable<Blog> Blogs { get; }

    /// <summary>
    /// 检查博客信息是否存在
    /// </summary>
    /// <param name="predicate">检查谓语表达式</param>
    /// <param name="id">更新的博客信息编号</param>
    /// <returns>博客信息是否存在</returns>
    Task<bool> CheckBlogExists(Expression<Func<Blog, bool>> predicate, int id = 0);

    /// <summary>
    /// 申请博客信息
    /// </summary>
    /// <param name="dto">申请博客信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    Task<OperationResult> ApplyForBlog(BlogInputDto dto);

    /// <summary>
    /// 审核博客信息
    /// </summary>
    /// <param name="id">博客编号</param>
    /// <param name="isEnabled">是否通过</param>
    /// <returns>业务操作结果</returns>
    Task<OperationResult> VerifyBlog(int id, bool isEnabled);

    /// <summary>
    /// 更新博客信息
    /// </summary>
    /// <param name="dtos">包含更新信息的博客信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    Task<OperationResult> UpdateBlogs(params BlogInputDto[] dtos);

    /// <summary>
    /// 删除博客信息
    /// </summary>
    /// <param name="ids">要删除的博客信息编号</param>
    /// <returns>业务操作结果</returns>
    Task<OperationResult> DeleteBlogs(params int[] ids);

    #endregion

    #region 文章信息业务

    /// <summary>
    /// 获取 文章信息查询数据集
    /// </summary>
    IQueryable<Post> Posts { get; }

    /// <summary>
    /// 检查文章信息是否存在
    /// </summary>
    /// <param name="predicate">检查谓语表达式</param>
    /// <param name="id">更新的文章信息编号</param>
    /// <returns>文章信息是否存在</returns>
    Task<bool> CheckPostExists(Expression<Func<Post, bool>> predicate, int id = 0);

    /// <summary>
    /// 添加文章信息
    /// </summary>
    /// <param name="dtos">要添加的文章信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    Task<OperationResult> CreatePosts(params PostInputDto[] dtos);

    /// <summary>
    /// 更新文章信息
    /// </summary>
    /// <param name="dtos">包含更新信息的文章信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    Task<OperationResult> UpdatePosts(params PostInputDto[] dtos);

    /// <summary>
    /// 删除文章信息
    /// </summary>
    /// <param name="ids">要删除的文章信息编号</param>
    /// <returns>业务操作结果</returns>
    Task<OperationResult> DeletePosts(params int[] ids);

    #endregion
}

服务实现 BlogsService

依赖服务注入方式分析

服务层的业务实现，通过向服务实现类注入数据仓储IRepository<TEntity, TKey> 对象来获得向数据库存取数据的能力。根据 .NetCore 的依赖注入使用原则，常规的做法是在服务实现类的 构造函数 进行依赖服务的注入。形如：


/// <summary>
/// 业务服务实现：博客模块
/// </summary>
public class BlogsService : IBlogsContract
{
    private readonly IRepository<Blog, int> _blogRepository;
    private readonly IRepository<Post, int> _postRepository;
    private readonly IRepository<User, int> _userRepository;
    private readonly IRepository<Role, int> _roleRepository;
    private readonly IRepository<UserRole, Guid> _userRoleRepository;
    private readonly IEventBus _eventBus;

    /// <summary>
    /// 初始化一个<see cref="BlogsService"/>类型的新实例
    /// </summary>
    public BlogsService(IRepository<Blog, int> blogRepository,
        IRepository<Post, int> postRepository,
        IRepository<User, int> userRepository,
        IRepository<Role, int> roleRepository,
        IRepository<UserRole, Guid> userRoleRepository,
        IEventBus eventBus)
    {
        _blogRepository = blogRepository;
        _postRepository = postRepository;
        _userRepository = userRepository;
        _roleRepository = roleRepository;
        _userRoleRepository = userRoleRepository;
        _eventBus = eventBus;
    }
}

构造函数注入带来的性能影响

每个仓储都使用构造函数注入的话，如果模块的业务比较复杂，涉及的实体比较多（比如十几个实体是很经常的事），就会造成每次实例化 BlogsService 类的实例的时候，都需要去实例化很多个依赖服务，而实际上 一次业务执行只执行服务中的某个方法，可能也就用到其中的一两个依赖服务，这就造成了很多不必要的额外工作，也就是性能损耗。

依赖服务注入的性能优化

如果 不考虑业务服务的可测试性（单元测试通常需要Mock依赖服务）的话，在构造函数中只注入 IServiceProvider 实例，然后在业务代码中使用 serviceProvider.GetService<T>() 的方式来 按需获取 依赖服务的实例，是比较经济的方式。则服务实现变为如下所示：

/// <summary>
/// 业务服务实现：博客模块
/// </summary>
public class BlogsService : IBlogsContract
{
    private readonly IServiceProvider _serviceProvider;

    /// <summary>
    /// 初始化一个<see cref="BlogsService"/>类型的新实例
    /// </summary>
    public BlogsService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    /// <summary>
    /// 获取 博客仓储对象
    /// </summary>
    protected IRepository<Blog, int> BlogRepository => _serviceProvider.GetService<IRepository<Blog, int>>();

    /// <summary>
    /// 获取 文章仓储对象
    /// </summary>
    protected IRepository<Post, int> PostRepository => _serviceProvider.GetService<IRepository<Post, int>>();

    /// <summary>
    /// 获取 用户仓储对象
    /// </summary>
    protected IRepository<User, int> UserRepository => _serviceProvider.GetService<IRepository<User, int>>();

    /// <summary>
    /// 获取 角色仓储对象
    /// </summary>
    protected IRepository<Role, int> RoleRepository => _serviceProvider.GetService<IRepository<Role, int>>();

    /// <summary>
    /// 获取 角色仓储对象
    /// </summary>
    protected IRepository<UserRole, Guid> UserRoleRepository => _serviceProvider.GetService<IRepository<UserRole, Guid>>();

    /// <summary>
    /// 获取 事件总线对象
    /// </summary>
    protected IEventBus EventBus => _serviceProvider.GetService<IEventBus>();
}

各个依赖服务改为属性的存在方式，并且可访问性为 protected，这就保证了依赖服务的安全性。依赖服务使用 serviceProvider.GetService<T>() 的方式创建实例，可以做到 按需创建，达到性能优化的目的。

增改删操作的简化

常规批量操作的弊端

直接通过数据仓储IRepository<TEntity, TKey> 实现数据的增改删的批量操作，总免不了要使用循环来遍历传进来的多个InputDto，例如文章的更新操作，以下几个步骤是免不了的：

由 dto.Id 查找出相应的文章实体 entity，如果不存在，中止操作并返回
进行更新前的数据检查
1. 检查 dto 的合法性，比如文章标题要求唯一，dto.Title 就要验证唯一性，中止操作并返回
2. 检查 entity 的合法性，比如文章已锁定，就不允许编辑，要进行拦截，检查不通过，中止操作并返回
使用 AutoMapper 将 dto 的值更新到 entity
进行其他关联实体的更新
1. 比如添加文章的编辑记录
2. 比如给当前操作人加积分
将 entity 的更新提交到数据库

整个过程实现代码如下：

/// <summary>
/// 更新文章信息
/// </summary>
/// <param name="dtos">包含更新信息的文章信息DTO信息</param>
/// <returns>业务操作结果</returns>
public virtual async Task<OperationResult> UpdatePosts(params PostInputDto[] dtos)
{
    Check.Validate<PostInputDto, int>(dtos, nameof(dtos));

    int count = 0;
    foreach (PostInputDto dto in dtos)
    {
        Post entity = await PostRepository.GetAsync(dto.Id);
        if (entity == null)
        {
            return new OperationResult(OperationResultType.QueryNull, $"编号为{dto.Id}的文章信息无法找到");
        }

        // todo:
        // 在这里要检查 dto 的合法性，比如文章标题要求唯一，dto.Title 就要验证唯一性
        // 在这里要检查 entity 的合法性，比如文章已锁定，就不允许编辑，要进行拦截

        entity = dto.MapTo(entity);

        // todo:
        // 在这里要进行其他实体的关联更新，比如添加文章的编辑记录

        count += await PostRepository.UpdateAsync(entity);
    }

    if (count > 0)
    {
        return new OperationResult(OperationResultType.Success, $"{dtos.Length}个文章信息更新成功");
    }
    return OperationResult.NoChanged;
}

批量操作改进

这是个重复性很大的繁琐工作，整个流程中只有第2步和第4步是变化的，其余步骤都相对固定。为了简化这类操作，我们可以将第2、4步骤变化点封装起来，使用 委托 将操作内容作为参数传进来。
OSharp在数据仓储IRepository<TEntity, TKey> 中定义了关于这类 IInputDto 类型参数的实体批量操作API。

例如批量更新，实现如下：

/// <summary>
/// 异步以DTO为载体批量更新实体
/// </summary>
/// <typeparam name="TEditDto">更新DTO类型</typeparam>
/// <param name="dtos">更新DTO信息集合</param>
/// <param name="checkAction">更新信息合法性检查委托</param>
/// <param name="updateFunc">由DTO到实体的转换委托</param>
/// <returns>业务操作结果</returns>
public virtual async Task<OperationResult> UpdateAsync<TEditDto>(ICollection<TEditDto> dtos,
    Func<TEditDto, TEntity, Task> checkAction = null,
    Func<TEditDto, TEntity, Task<TEntity>> updateFunc = null) where TEditDto : IInputDto<TKey>
{
    List<string> names = new List<string>();
    foreach (TEditDto dto in dtos)
    {
        try
        {
            TEntity entity = await _dbSet.FindAsync(dto.Id);
            if (entity == null)
            {
                return new OperationResult(OperationResultType.QueryNull);
            }
            if (checkAction != null)
            {
                await checkAction(dto, entity);
            }
            entity = dto.MapTo(entity);
            if (updateFunc != null)
            {
                entity = await updateFunc(dto, entity);
            }
            entity = CheckUpdate(entity)[0];
            _dbContext.Update<TEntity, TKey>(entity);
        }
        catch (OsharpException e)
        {
            return new OperationResult(OperationResultType.Error, e.Message);
        }
        catch (Exception e)
        {
            _logger.LogError(e, e.Message);
            return new OperationResult(OperationResultType.Error, e.Message);
        }
        names.AddIfNotNull(GetNameValue(dto));
    }
    int count = await _dbContext.SaveChangesAsync(_cancellationTokenProvider.Token);
    return count > 0
        ? new OperationResult(OperationResultType.Success,
            names.Count > 0
                ? "信息“{0}”更新成功".FormatWith(names.ExpandAndToString())
                : "{0}个信息更新成功".FormatWith(dtos.Count))
        : new OperationResult(OperationResultType.NoChanged);
}

如上高亮代码，此方法定义了 Func<TEditDto, TEntity, Task> checkAction 和 Func<TEditDto, TEntity, Task<TEntity>> updateFunc 两个委托参数作为 更新前参数检查 和 更新后关联更新 的操作传入方式，方法中是以 OsharpException 类型异常来作为中止信号的，如果需要在委托中中止操作，直接抛 OsharpException 异常即可。在调用时，即可极大简化批量更新的操作，如上的更新代码，简化如下：

/// <summary>
/// 更新文章信息
/// </summary>
/// <param name="dtos">包含更新信息的文章信息DTO信息</param>
/// <returns>业务操作结果</returns>
public virtual async Task<OperationResult> UpdatePosts(params PostInputDto[] dtos)
{
    Check.Validate<PostInputDto, int>(dtos, nameof(dtos));

    return await PostRepository.UpdateAsync(dtos, async (dto, entity) =>
        {
            // todo:
            // 在这里要检查 dto 的合法性，比如文章标题要求唯一，dto.Title 就要验证唯一性
            // 在这里要检查 entity 的合法性，比如文章已锁定，就不允许编辑，要进行拦截
        },
        async (dto, entity) =>
        {
            // todo:
            // 在这里要进行其他实体的关联更新，比如添加文章的编辑记录

            return entity;
        });
}

如果没有必要做额外的更新前检查和更新后的关联更新，上面的批量更新可以简化到极致：

/// <summary>
/// 更新文章信息
/// </summary>
/// <param name="dtos">包含更新信息的文章信息DTO信息</param>
/// <returns>业务操作结果</returns>
public virtual async Task<OperationResult> UpdatePosts(params PostInputDto[] dtos)
{
    Check.Validate<PostInputDto, int>(dtos, nameof(dtos));

    return await PostRepository.UpdateAsync(dtos);
}

服务层的事务管理

事务开启与重用

OSharp的数据层在一次业务处理请求中遇到数据的 新增、更新、删除 操作并第一次执行 SaveChanges 操作时，会自动开启手动事务，以后再次执行 SaveChanges 操作时，会直接使用 同一连接对象 的现有事务，以保证一次业务请求的操作都自在一个事务内。

public override int SaveChanges()
{
    // ...

    //开启或使用现有事务
    BeginOrUseTransaction();

    int count = base.SaveChanges();
    
    // ...

    return count;
}

事务提交

为了方便事务管理和不同的服务层之间的事务同步，OSharp框架默认的事务提交是在 API 层通过 MVC 的 UnitOfWorkAttribute 特性来提交的。

/// <summary>
/// 新用户注册
/// </summary>
/// <param name="dto">注册信息</param>
/// <returns>JSON操作结果</returns>
[HttpPost]
[ServiceFilter(typeof(UnitOfWorkAttribute))]
[ModuleInfo]
[Description("用户注册")]
public async Task<AjaxResult> Register(RegisterDto dto)
{
    // ...
}

当然，你也可以不在 API 层标注 [UnitOfWorkAttribute]，而是在需要的时候通过 IUnitOfWork.Commit() 手动提交事务

IUnitOfWork unitOfWork = HttpContext.RequestServices.GetUnitOfWork<User, int>();
unitOfWork.Commit();

业务服务事件订阅与发布

业务服务事件，是通过事件总线EventBus 来实现的，OSharp构建了一个简单的事件总线基础建设，可以很方便地订阅和发布业务事件。

订阅事件

订阅事件很简单，只需要定义一组配套的事件数据EventData 和相应的事件处理器EventHandler，即可完成事件订阅的工作。

IEventData

事件数据EventData 是业务服务发布事件时向事件总线传递的数据，每一种业务，都有特定的事件数据，一个事件数据可触发多个事件处理器
定义一个事件数据，需要实现 IEventData 接口

/// <summary>
/// 定义事件数据，所有事件都要实现该接口
/// </summary>
public interface IEventData
{
    /// <summary>
    /// 获取 事件编号
    /// </summary>
    Guid Id { get; }

    /// <summary>
    /// 获取 事件发生的时间
    /// </summary>
    DateTime EventTime { get; }

    /// <summary>
    /// 获取或设置 事件源，触发事件的对象
    /// </summary>
    object EventSource { get; set; }
}

EventDataBase

为了方便事件数据的定义，OSharp定义了一个通用事件数据基类EventDataBase，继承此基类，只需要添加事件触发需要的业务数据即可

/// <summary>
/// 事件源数据信息基类
/// </summary>
public abstract class EventDataBase : IEventData
{
    /// <summary>
    /// 初始化一个<see cref="EventDataBase"/>类型的新实例
    /// </summary>
    protected EventDataBase()
    {
        Id = Guid.NewGuid();
        EventTime = DateTime.Now;
    }

    /// <summary>
    /// 获取 事件编号
    /// </summary>
    public Guid Id { get; }

    /// <summary>
    /// 获取 事件发生时间
    /// </summary>
    public DateTime EventTime { get; }

    /// <summary>
    /// 获取或设置 触发事件的对象
    /// </summary>
    public object EventSource { get; set; }
}

IEventHandler

业务事件的处理逻辑，是通过事件处理器 EventHandler 来实现的，事件处理器应遵从 单一职责 原则，一个处理器只做一件事，业务服务层发布一项事件数据，可触发多个事件处理器

/// <summary>
/// 定义事件处理器，所有事件处理都要实现该接口
/// EventBus中，Handler的调用是同步执行的，如果需要触发就不管的异步执行，可以在实现EventHandler的Handle逻辑时使用Task.Run
/// </summary>
[IgnoreDependency]
public interface IEventHandler
{
    /// <summary>
    /// 是否可处理指定事件
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    /// <returns>是否可处理</returns>
    bool CanHandle(IEventData eventData);

    /// <summary>
    /// 事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    void Handle(IEventData eventData);

    /// <summary>
    /// 异步事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    /// <param name="cancelToken">异步取消标识</param>
    /// <returns></returns>
    Task HandleAsync(IEventData eventData, CancellationToken cancelToken = default(CancellationToken));
}

泛型事件处理器

/// <summary>
/// 定义泛型事件处理器
/// EventBus中，Handler的调用是同步执行的，如果需要触发就不管的异步执行，可以在实现EventHandler的Handle逻辑时使用Task.Run
/// </summary>
/// <typeparam name="TEventData">事件源数据</typeparam>
[IgnoreDependency]
public interface IEventHandler<in TEventData> : IEventHandler where TEventData : IEventData
{
    /// <summary>
    /// 事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    void Handle(TEventData eventData);

    /// <summary>
    /// 异步事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    /// <param name="cancelToken">异步取消标识</param>
    Task HandleAsync(TEventData eventData, CancellationToken cancelToken = default(CancellationToken));
}

EventHandlerBase

同样的，为了方便事件处理器的定义，OSharp定义了一个通用的事件处理器基类EventHandlerBase<TEventData>，继承此基类，只需要实现核心的事件处理逻辑即可

/// <summary>
/// 事件处理器基类
/// </summary>
public abstract class EventHandlerBase<TEventData> : IEventHandler<TEventData> where TEventData : IEventData
{
    /// <summary>
    /// 是否可处理指定事件
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    /// <returns>是否可处理</returns>
    public virtual bool CanHandle(IEventData eventData)
    {
        return eventData.GetType() == typeof(TEventData);
    }

    /// <summary>
    /// 事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    public virtual void Handle(IEventData eventData)
    {
        if (!CanHandle(eventData))
        {
            return;
        }
        Handle((TEventData)eventData);
    }

    /// <summary>
    /// 异步事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    /// <param name="cancelToken">异步取消标识</param>
    /// <returns></returns>
    public virtual Task HandleAsync(IEventData eventData, CancellationToken cancelToken = default(CancellationToken))
    {
        if (!CanHandle(eventData))
        {
            return Task.FromResult(0);
        }
        return HandleAsync((TEventData)eventData, cancelToken);
    }

    /// <summary>
    /// 事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    public abstract void Handle(TEventData eventData);

    /// <summary>
    /// 异步事件处理
    /// </summary>
    /// <param name="eventData">事件源数据</param>
    /// <param name="cancelToken">异步取消标识</param>
    /// <returns>是否成功</returns>
    public virtual Task HandleAsync(TEventData eventData, CancellationToken cancelToken = default(CancellationToken))
    {
        return Task.Run(() => Handle(eventData), cancelToken);
    }
}

发布事件

事件的发布，就相当简单了，只需要实例化一个事件数据EventData的实例，然后通过IEventBus.Publish(eventData)即可发布事件，触发该EventData的所有订阅处理器

XXXEventData eventData = new XXXEventData()
{
    // ...
};
EventBus.Publish(eventData);

博客模块的业务事件实现

回到我们的 Liuliu.Blogs 项目，根据 <业务模块设计#博客业务需求分析> 的需求分析的第二条，审核博客之后需要发邮件通知用户，发邮件属于审核博客业务计划外的需求，使用业务事件来实现正当其时。

审核博客业务事件数据

/// <summary>
/// 审核博客事件数据
/// </summary>
public class VerifyBlogEventData : EventDataBase
{
    /// <summary>
    /// 获取或设置 博客名称
    /// </summary>
    public string BlogName { get; set; }

    /// <summary>
    /// 获取或设置 用户名
    /// </summary>
    public string UserName { get; set; }

    /// <summary>
    /// 获取或设置 审核是否通过
    /// </summary>
    public bool IsEnabled { get; set; }
}

审核博客业务事件处理器

/// <summary>
/// 审核博客事件处理器
/// </summary>
public class VerifyBlogEventHandler : EventHandlerBase<VerifyBlogEventData>
{
    private readonly ILogger _logger;

    /// <summary>
    /// 初始化一个<see cref="VerifyBlogEventHandler"/>类型的新实例
    /// </summary>
    public VerifyBlogEventHandler(IServiceProvider serviceProvider)
    {
        _logger = serviceProvider.GetService<ILoggerFactory>().CreateLogger<VerifyBlogEventHandler>();
    }

    /// <summary>事件处理</summary>
    /// <param name="eventData">事件源数据</param>
    public override void Handle(VerifyBlogEventData eventData)
    {
        _logger.LogInformation(
            $"触发 审核博客事件处理器，用户“{eventData.UserName}”的博客“{eventData.BlogName}”审核结果：{(eventData.IsEnabled ? "通过" : "未通过")}");
    }
}

博客模块的服务实现

回到我们的 Liuliu.Blogs 项目，根据 <业务模块设计#服务层> 的需求分析，综合使用OSharp框架提供的基础建设，博客模块的业务服务实现如下：

BlogsService.cs

/// <summary>
/// 业务服务实现：博客模块
/// </summary>
public partial class BlogsService : IBlogsContract
{
    private readonly IServiceProvider _serviceProvider;

    /// <summary>
    /// 初始化一个<see cref="BlogsService"/>类型的新实例
    /// </summary>
    public BlogsService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    /// <summary>
    /// 获取 博客仓储对象
    /// </summary>
    protected IRepository<Blog, int> BlogRepository => _serviceProvider.GetService<IRepository<Blog, int>>();

    /// <summary>
    /// 获取 文章仓储对象
    /// </summary>
    protected IRepository<Post, int> PostRepository => _serviceProvider.GetService<IRepository<Post, int>>();

    /// <summary>
    /// 获取 用户仓储对象
    /// </summary>
    protected IRepository<User, int> UserRepository => _serviceProvider.GetService<IRepository<User, int>>();
}

BlogsService.Blog.cs

public partial class BlogsService
{
    /// <summary>
    /// 获取 博客信息查询数据集
    /// </summary>
    public virtual IQueryable<Blog> Blogs => BlogRepository.Query();

    /// <summary>
    /// 检查博客信息是否存在
    /// </summary>
    /// <param name="predicate">检查谓语表达式</param>
    /// <param name="id">更新的博客信息编号</param>
    /// <returns>博客信息是否存在</returns>
    public virtual Task<bool> CheckBlogExists(Expression<Func<Blog, bool>> predicate, int id = 0)
    {
        Check.NotNull(predicate, nameof(predicate));
        return BlogRepository.CheckExistsAsync(predicate, id);
    }

    /// <summary>
    /// 申请博客信息
    /// </summary>
    /// <param name="dto">申请博客信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    public virtual async Task<OperationResult> ApplyForBlog(BlogInputDto dto)
    {
        Check.Validate(dto, nameof(dto));

        // 博客是以当前用户的身份来申请的
        ClaimsPrincipal principal = _serviceProvider.GetCurrentUser();
        if (principal == null || !principal.Identity.IsAuthenticated)
        {
            return new OperationResult(OperationResultType.Error, "用户未登录或登录已失效");
        }

        int userId = principal.Identity.GetUserId<int>();
        User user = await UserRepository.GetAsync(userId);
        if (user == null)
        {
            return new OperationResult(OperationResultType.QueryNull, $"编号为“{userId}”的用户信息不存在");
        }
        Blog blog = BlogRepository.TrackQuery(m => m.UserId == userId).FirstOrDefault();
        if (blog != null)
        {
            return new OperationResult(OperationResultType.Error, "当前用户已开通博客，不能重复申请");
        }

        if (await CheckBlogExists(m => m.Url == dto.Url))
        {
            return new OperationResult(OperationResultType.Error, $"Url 为“{dto.Url}”的博客已存在，不能重复添加");
        }
        blog = dto.MapTo<Blog>();
        blog.UserId = userId;
        int count = await BlogRepository.InsertAsync(blog);
        return count > 0
            ? new OperationResult(OperationResultType.Success, "博客申请成功")
            : OperationResult.NoChanged;
    }

    /// <summary>
    /// 审核博客信息
    /// </summary>
    /// <param name="id">博客编号</param>
    /// <param name="isEnabled">是否通过</param>
    /// <returns>业务操作结果</returns>
    public virtual async Task<OperationResult> VerifyBlog(int id, bool isEnabled)
    {
        Blog blog = await BlogRepository.GetAsync(id);
        if (blog == null)
        {
            return new OperationResult(OperationResultType.QueryNull, $"编号为“{id}”的博客信息不存在");
        }

        // 更新博客
        blog.IsEnabled = isEnabled;
        int count = await BlogRepository.UpdateAsync(blog);

        User user = await UserRepository.GetAsync(blog.UserId);
        if (user == null)
        {
            return new OperationResult(OperationResultType.QueryNull, $"编号为“{blog.UserId}”的用户信息不存在");
        }

        // 如果开通博客，给用户开通博主身份
        if (isEnabled)
        {
            // 查找博客主的角色，博主角色名可由配置系统获得
            const string roleName = "博主";
            // 用于CUD操作的实体，要用 TrackQuery 方法来查询出需要的数据，不能用 Query，因为 Query 会使用 AsNoTracking
            Role role = RoleRepository.TrackQuery(m => m.Name == roleName).FirstOrDefault();
            if (role == null)
            {
                return new OperationResult(OperationResultType.QueryNull, $"名称为“{roleName}”的角色信息不存在");
            }

            UserRole userRole = UserRoleRepository.TrackQuery(m => m.UserId == user.Id && m.RoleId == role.Id)
                .FirstOrDefault();
            if (userRole == null)
            {
                userRole = new UserRole() { UserId = user.Id, RoleId = role.Id, IsLocked = false };
                count += await UserRoleRepository.InsertAsync(userRole);
            }
        }

        OperationResult result = count > 0
            ? new OperationResult(OperationResultType.Success, $"博客“{blog.Display}”审核 {(isEnabled ? "通过" : "未通过")}")
            : OperationResult.NoChanged;
        if (result.Succeeded)
        {
            VerifyBlogEventData eventData = new VerifyBlogEventData()
            {
                BlogName = blog.Display,
                UserName = user.NickName,
                IsEnabled = isEnabled
            };
            EventBus.Publish(eventData);
        }

        return result;
    }

    /// <summary>
    /// 更新博客信息
    /// </summary>
    /// <param name="dtos">包含更新信息的博客信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    public virtual Task<OperationResult> UpdateBlogs(params BlogInputDto[] dtos)
    {
        return BlogRepository.UpdateAsync(dtos, async (dto, entity) =>
        {
            if (await BlogRepository.CheckExistsAsync(m => m.Url == dto.Url, dto.Id))
            {
                throw new OsharpException($"Url为“{dto.Url}”的博客已存在，不能重复");
            }
        });
    }

    /// <summary>
    /// 删除博客信息
    /// </summary>
    /// <param name="ids">要删除的博客信息编号</param>
    /// <returns>业务操作结果</returns>
    public virtual Task<OperationResult> DeleteBlogs(params int[] ids)
    {
        return BlogRepository.DeleteAsync(ids, entity =>
        {
            if (PostRepository.Query(m => m.BlogId == entity.Id).Any())
            {
                throw new OsharpException($"博客“{entity.Display}”中还有文章未删除，请先删除所有文章，再删除博客");
            }
            return Task.FromResult(0);
        });
    }
}

BlogsService.Post.cs

public partial class BlogsService
{
    /// <summary>
    /// 获取 文章信息查询数据集
    /// </summary>
    public virtual IQueryable<Post> Posts => PostRepository.Query();

    /// <summary>
    /// 检查文章信息是否存在
    /// </summary>
    /// <param name="predicate">检查谓语表达式</param>
    /// <param name="id">更新的文章信息编号</param>
    /// <returns>文章信息是否存在</returns>
    public virtual Task<bool> CheckPostExists(Expression<Func<Post, bool>> predicate, int id = 0)
    {
        Check.NotNull(predicate, nameof(predicate));
        return PostRepository.CheckExistsAsync(predicate, id);
    }

    /// <summary>
    /// 添加文章信息
    /// </summary>
    /// <param name="dtos">要添加的文章信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    public virtual async Task<OperationResult> CreatePosts(params PostInputDto[] dtos)
    {
        Check.Validate<PostInputDto, int>(dtos, nameof(dtos));
        if (dtos.Length == 0)
        {
            return OperationResult.NoChanged;
        }

        // 文章是以当前用户身份来添加的
        ClaimsPrincipal principal = _serviceProvider.GetCurrentUser();
        if (principal == null || !principal.Identity.IsAuthenticated)
        {
            throw new OsharpException("用户未登录或登录已失效");
        }
        // 检查当前用户的博客状态
        int userId = principal.Identity.GetUserId<int>();
        Blog blog = BlogRepository.TrackQuery(m => m.UserId == userId).FirstOrDefault();
        if (blog == null || !blog.IsEnabled)
        {
            throw new OsharpException("当前用户的博客未开通，无法添加文章");
        }

        // 没有前置检查，checkAction为null
        return await PostRepository.InsertAsync(dtos, null, (dto, entity) =>
        {
            // 给新建的文章关联博客和作者
            entity.BlogId = blog.Id;
            entity.UserId = userId;
            return Task.FromResult(entity);
        });
    }

    /// <summary>
    /// 更新文章信息
    /// </summary>
    /// <param name="dtos">包含更新信息的文章信息DTO信息</param>
    /// <returns>业务操作结果</returns>
    public virtual Task<OperationResult> UpdatePosts(params PostInputDto[] dtos)
    {
        Check.Validate<PostInputDto, int>(dtos, nameof(dtos));

        return PostRepository.UpdateAsync(dtos);
    }

    /// <summary>
    /// 删除文章信息
    /// </summary>
    /// <param name="ids">要删除的文章信息编号</param>
    /// <returns>业务操作结果</returns>
    public virtual Task<OperationResult> DeletePosts(params int[] ids)
    {
        Check.NotNull(ids, nameof(ids));
        return PostRepository.DeleteAsync(ids);
    }
}

模块入口 BlogsPack

模块入口基类

非AspNetCore模块基类 OsharpPack

前面多次提到，每个Pack模块都是继承自一个模块基类OsharpPack，这个基类用于定义模块初始化UsePack 过程中未涉及 AspNetCore 环境的模块。

/// <summary>
/// OSharp模块基类
/// </summary>
public abstract class OsharpPack
{
    /// <summary>
    /// 获取 模块级别，级别越小越先启动
    /// </summary>
    public virtual PackLevel Level => PackLevel.Business;

    /// <summary>
    /// 获取 模块启动顺序，模块启动的顺序先按级别启动，同一级别内部再按此顺序启动，
    /// 级别默认为0，表示无依赖，需要在同级别有依赖顺序的时候，再重写为>0的顺序值
    /// </summary>
    public virtual int Order => 0;

    /// <summary>
    /// 获取 是否已可用
    /// </summary>
    public bool IsEnabled { get; protected set; }

    /// <summary>
    /// 将模块服务添加到依赖注入服务容器中
    /// </summary>
    /// <param name="services">依赖注入服务容器</param>
    /// <returns></returns>
    public virtual IServiceCollection AddServices(IServiceCollection services)
    {
        return services;
    }

    /// <summary>
    /// 应用模块服务
    /// </summary>
    /// <param name="provider">服务提供者</param>
    public virtual void UsePack(IServiceProvider provider)
    {
        IsEnabled = true;
    }

    /// <summary>
    /// 获取当前模块的依赖模块类型
    /// </summary>
    /// <returns></returns>
    internal Type[] GetDependPackTypes(Type packType = null)
    {
        // ...
    }
}

模块基类OsharpPack 定义了两个可重写属性：

PackLevel：模块级别，级别越小越先启动
模块级别按模块在框架中不同的功能层次，定义了如下几个级别：

/// <summary>
/// 模块级别，级别越核心，优先启动
/// </summary>
public enum PackLevel
{
    /// <summary>
    /// 核心级别，表示系统的核心模块，
    /// 这些模块不涉及第三方组件，在系统运行中是不可替换的，核心模块将始终加载
    /// </summary>
    Core = 1,
    /// <summary>
    /// 框架级别，表示涉及第三方组件的基础模块
    /// </summary>
    Framework = 10,
    /// <summary>
    /// 应用级别，表示涉及应用数据的基础模块
    /// </summary>
    Application = 20,
    /// <summary>
    /// 业务级别，表示涉及真实业务处理的模块
    /// </summary>
    Business = 30
}

Order：级别内模块启动顺序，模块启动的顺序先按级别启动，同一级别内部再按此顺序启动，级别默认为 0，表示无依赖，需要在同级别有依赖顺序的时候，再重写为 >0 的顺序值

同时，模块基类还定义了两个方法：

AddServices：用于将模块内定义的服务注入到 依赖注入服务容器 中。
UsePack：用于使用服务对当前模块进行初始化。

AspNetCore模块基类 AspOsharpPack

AspOsharpPack 基类继承了 OsharpPack，添加了一个对 IApplicationBuilder 支持的 UsePack 方法，用于实现与 AspNetCore 关联的模块初始化工作，例如 Mvc模块初始化的时候需要应用中间件：app.UseMvcWithAreaRoute();

/// <summary>
///  基于AspNetCore环境的Pack模块基类
/// </summary>
public abstract class AspOsharpPack : OsharpPack
{
    /// <summary>
    /// 应用AspNetCore的服务业务
    /// </summary>
    /// <param name="app">Asp应用程序构建器</param>
    public virtual void UsePack(IApplicationBuilder app)
    {
        base.UsePack(app.ApplicationServices);
    }
}

博客模块的模块入口实现

回到我们的 Liuliu.Blogs 项目，我们来实现投票模块的模块入口类 BlogsPack：

博客模块属于业务模块，因此 PackLevel 设置为 Business
博客模块的启动顺序无需重写，保持 0 即可
将博客业务服务注册到服务容器中
无甚初始化业务

实现代码如下：

/// <summary>
/// 博客模块
/// </summary>
public class BlogsPack : OsharpPack
{
    /// <summary>
    /// 获取 模块级别，级别越小越先启动
    /// </summary>
    public override PackLevel Level { get; } = PackLevel.Business;

    /// <summary>将模块服务添加到依赖注入服务容器中</summary>
    /// <param name="services">依赖注入服务容器</param>
    /// <returns></returns>
    public override IServiceCollection AddServices(IServiceCollection services)
    {
        services.TryAddScoped<IBlogsContract, BlogsService>();

        return services;
    }
}

至此，博客模块的服务层实现完毕。

标签：return,OSharpNS,步步为营,博客,开源,信息,模块,服务,public
来源： https://www.cnblogs.com/guomingfeng/p/osharpns-steps-service.html