基於 abp vNext 和 .NET Core 開發博客項目 - 自定義倉儲之增刪改查

上一篇文章(http://www.javashuo.com/article/p-hkllrruz-er.html)咱們用Code-First的方式建立了博客所需的實體類，生成了數據庫表，完成了對EF Core的封裝。

本篇說一下自定義倉儲的實現方式，其實在abp框架中已經默認給咱們實現了默認的通用(泛型)倉儲，IRepository<TEntity, TKey>，有着標準的CRUD操做，能夠看：https://docs.abp.io/zh-Hans/abp/latest/Repositories 學習更多。

之因此實現自定義倉儲，是由於abp沒有給咱們實現批量插入、更新的方法，這個是須要本身去擴展的。

既然是自定義倉儲，那麼就有了很高的自由度，咱們能夠任意發揮，能夠接入第三方批量處理數據的庫，能夠接入Dapper操做等等，在這裏貼一下微軟官方推薦的一些EF Core的工具和擴展：https://docs.microsoft.com/zh-cn/ef/core/extensions/ 。

自定義倉儲

在.Domain領域層中建立倉儲接口，IPostRepository、ICategoryRepository、ITagRepository、IPostTagRepository、IFriendLinkRepository，這裏直接所有繼承 IRepository<TEntity, TKey> 以使用已有的通用倉儲功能。

能夠轉到IRepository<TEntity, TKey>接口定義看一下

看看abp對於倉儲的介紹，以下：

IRepository<TEntity, TKey> 接口擴展了標準 IQueryable<TEntity> 你能夠使用標準LINQ方法自由查詢。可是，某些ORM提供程序或數據庫系統可能不支持IQueryable接口。

ABP提供了 IBasicRepository<TEntity, TPrimaryKey> 和 IBasicRepository<TEntity> 接口來支持這樣的場景。

你能夠擴展這些接口（並可選擇性地從BasicRepositoryBase派生）爲你的實體建立自定義存儲庫。

依賴於 IBasicRepository 而不是依賴 IRepository 有一個優勢, 即便它們不支持 IQueryable 也能夠使用全部的數據源, 但主要的供應商, 像 Entity Framework, NHibernate 或 MongoDb 已經支持了 IQueryable。

所以, 使用 IRepository 是典型應用程序的 建議方法。可是可重用的模塊開發人員可能會考慮使用 IBasicRepository 來支持普遍的數據源。

對於想要使用只讀倉儲提供了IReadOnlyRepository<TEntity, TKey> 與 IReadOnlyBasicRepository<Tentity, TKey>接口。

倉儲接口類以下：

//IPostRepository.cs
using Volo.Abp.Domain.Repositories;

namespace Meowv.Blog.Domain.Blog.Repositories
{
    /// <summary>
    /// IPostRepository
    /// </summary>
    public interface IPostRepository : IRepository<Post, int>
    {
    }
}

//ICategoryRepository.cs
using Volo.Abp.Domain.Repositories;

namespace Meowv.Blog.Domain.Blog.Repositories
{
    /// <summary>
    /// ICategoryRepository
    /// </summary>
    public interface ICategoryRepository : IRepository<Category, int>
    {
    }
}

//ITagRepository.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using Volo.Abp.Domain.Repositories;

namespace Meowv.Blog.Domain.Blog.Repositories
{
    /// <summary>
    /// ITagRepository
    /// </summary>
    public interface ITagRepository : IRepository<Tag, int>
    {
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="tags"></param>
        /// <returns></returns>
        Task BulkInsertAsync(IEnumerable<Tag> tags);
    }
}

//IPostTagRepository.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using Volo.Abp.Domain.Repositories;

namespace Meowv.Blog.Domain.Blog.Repositories
{
    /// <summary>
    /// IPostTagRepository
    /// </summary>
    public interface IPostTagRepository : IRepository<PostTag, int>
    {
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="postTags"></param>
        /// <returns></returns>
        Task BulkInsertAsync(IEnumerable<PostTag> postTags);
    }
}

//IFriendLinkRepository.cs
using Volo.Abp.Domain.Repositories;

namespace Meowv.Blog.Domain.Blog.Repositories
{
    /// <summary>
    /// IFriendLinkRepository
    /// </summary>
    public interface IFriendLinkRepository : IRepository<FriendLink, int>
    {
    }
}

在ITagRepository和IPostTagRepository倉儲接口中，咱們添加了批量插入的方法。相對於的在咱們的.EntityFrameworkCore層實現這些接口。

建立Repositories/Blog 文件夾，添加實現類：PostRepository、CategoryRepository、TagRepository、PostTagRepository、FriendLinkRepository。

不知道你們發現沒有，咱們的倉儲接口以及實現，都是以Repository結尾的，這和咱們的.Application應用服務層都以Service結尾是一個道理。

在自定義倉儲的實現中，咱們能夠使用任意你想使用的數據訪問工具，咱們這裏仍是繼續用Entity Framework Core，須要繼承EfCoreRepository<TDbContext, TEntity, TKey>，和咱們的倉儲接口IXxxRepository。

EfCoreRepository默認實現了許多默認的方法，而後就能夠直接使用 DbContext 來執行操做了。

倉儲接口實現類以下：

//PostRepository.cs
using Meowv.Blog.Domain.Blog;
using Meowv.Blog.Domain.Blog.Repositories;
using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore;

namespace Meowv.Blog.EntityFrameworkCore.Repositories.Blog
{
    /// <summary>
    /// PostRepository
    /// </summary>
    public class PostRepository : EfCoreRepository<MeowvBlogDbContext, Post, int>, IPostRepository
    {
        public PostRepository(IDbContextProvider<MeowvBlogDbContext> dbContextProvider) : base(dbContextProvider)
        {
        }
    }
}

//CategoryRepository.cs
using Meowv.Blog.Domain.Blog;
using Meowv.Blog.Domain.Blog.Repositories;
using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore;
namespace Meowv.Blog.EntityFrameworkCore.Repositories.Blog
{
    /// <summary>
    /// CategoryRepository
    /// </summary>
    public class CategoryRepository : EfCoreRepository<MeowvBlogDbContext, Category, int>, ICategoryRepository
    {
        public CategoryRepository(IDbContextProvider<MeowvBlogDbContext> dbContextProvider) : base(dbContextProvider)
        {
        }
    }
}

//TagRepository.cs
using Meowv.Blog.Domain.Blog;
using Meowv.Blog.Domain.Blog.Repositories;
using System.Collections.Generic;
using System.Threading.Tasks;
using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore;

namespace Meowv.Blog.EntityFrameworkCore.Repositories.Blog
{
    /// <summary>
    /// TagRepository
    /// </summary>
    public class TagRepository : EfCoreRepository<MeowvBlogDbContext, Tag, int>, ITagRepository
    {
        public TagRepository(IDbContextProvider<MeowvBlogDbContext> dbContextProvider) : base(dbContextProvider)
        {
        }

        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="tags"></param>
        /// <returns></returns>
        public async Task BulkInsertAsync(IEnumerable<Tag> tags)
        {
            await DbContext.Set<Tag>().AddRangeAsync(tags);
            await DbContext.SaveChangesAsync();
        }
    }
}

//PostTagRepository.cs
using Meowv.Blog.Domain.Blog;
using Meowv.Blog.Domain.Blog.Repositories;
using System.Collections.Generic;
using System.Threading.Tasks;
using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore;

namespace Meowv.Blog.EntityFrameworkCore.Repositories.Blog
{
    /// <summary>
    /// PostTagRepository
    /// </summary>
    public class PostTagRepository : EfCoreRepository<MeowvBlogDbContext, PostTag, int>, IPostTagRepository
    {
        public PostTagRepository(IDbContextProvider<MeowvBlogDbContext> dbContextProvider) : base(dbContextProvider)
        {
        }

        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="postTags"></param>
        /// <returns></returns>
        public async Task BulkInsertAsync(IEnumerable<PostTag> postTags)
        {
            await DbContext.Set<PostTag>().AddRangeAsync(postTags);
            await DbContext.SaveChangesAsync();
        }
    }
}

//FriendLinkRepository.cs
using Meowv.Blog.Domain.Blog;
using Meowv.Blog.Domain.Blog.Repositories;
using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore;

namespace Meowv.Blog.EntityFrameworkCore.Repositories.Blog
{
    /// <summary>
    /// PostTagRepository
    /// </summary>
    public class FriendLinkRepository : EfCoreRepository<MeowvBlogDbContext, FriendLink, int>, IFriendLinkRepository
    {
        public FriendLinkRepository(IDbContextProvider<MeowvBlogDbContext> dbContextProvider) : base(dbContextProvider)
        {
        }
    }
}

在TagRepository和PostTagRepository倉儲接口的實現中，由於數據量不大，能夠直接用了EF Core自帶的AddRangeAsync批量保存數據。

到這裏，關於博客的自定義倉儲便完成了，此時項目層級目錄圖，以下：

增刪改查

接下來在就能夠在.Application服務層愉快的玩耍了，寫服務以前，咱們要分析咱們的項目，要有哪些功能業務。因爲是博客項目，無非就是一些增刪改查。今天先不寫博客業務，先完成對數據庫文章表meowv_posts的一個簡單CRUD。

在.Application層新建Blog文件夾，添加一個IBlogService.cs博客接口服務類，分別添加增刪改查四個方法。

這時就要用到咱們的數據傳輸對象(DTO)了，簡單理解，DTO就是從咱們的領域模型中抽離出來的對象，它是很純粹的只包含咱們拿到的數據，不參雜任何行爲邏輯。

在.Application.Contracts層新建Blog文件夾，同時新建一個PostDto.cs類，與.Domain層中的Post.cs與之對應，他們很類似，可是不同。

因而IBlogService.cs接口服務類的CRUD爲：

//IBlogService.cs
using Meowv.Blog.Application.Contracts.Blog;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Blog
{
    public interface IBlogService
    {
        Task<bool> InsertPostAsync(PostDto dto);

        Task<bool> DeletePostAsync(int id);

        Task<bool> UpdatePostAsync(int id, PostDto dto);

        Task<PostDto> GetPostAsync(int id);
    }
}

接口寫好了，少不了實現方式，直接在Blog文件夾新建Impl文件夾，用來存放咱們的接口實現類BlogService.cs，注意：都是以Service結尾的噢~

實現服務接口除了要繼承咱們的IBlogService外，不要忘了還需依賴咱們的ServiceBase類。因爲咱們以前直接接入了Autofac，能夠直接使用構造函數依賴注入的方式。

//BlogService.cs
using Meowv.Blog.Application.Contracts.Blog;
using Meowv.Blog.Domain.Blog.Repositories;
using System;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Blog.Impl
{
    public class BlogService : ServiceBase, IBlogService
    {
        private readonly IPostRepository _postRepository;

        public BlogService(IPostRepository postRepository)
        {
            _postRepository = postRepository;
        }
        ...
    }
}

如今就能夠實現咱們寫的IBlogService接口了。

先寫添加，這裏實現方式全採用異步的方法，先構建一個Post實體對象，具體內容參數都從PostDto中獲取，因爲主鍵以前設置了自增，這裏就不用管它了。而後調用 await _postRepository.InsertAsync(entity);，正好它返回了一個建立成功的Post對象，那麼咱們就能夠判斷對象是否爲空，從而肯定文章是否添加成功。

代碼以下：

...
        public async Task<bool> InsertPostAsync(PostDto dto)
        {
            var entity = new Post
            {
                Title = dto.Title,
                Author = dto.Author,
                Url = dto.Url,
                Html = dto.Html,
                Markdown = dto.Markdown,
                CategoryId = dto.CategoryId,
                CreationTime = dto.CreationTime
            };

            var post = await _postRepository.InsertAsync(entity);
            return post != null;
        }
...

而後在.HttpApi層和以前添加HelloWorldController同樣，添加BlogController。調用寫的InsertPostAsync方法，以下：

//BlogController.cs
using Meowv.Blog.Application.Blog;
using Meowv.Blog.Application.Contracts.Blog;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using Volo.Abp.AspNetCore.Mvc;

namespace Meowv.Blog.HttpApi.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class BlogController : AbpController
    {
        private readonly IBlogService _blogService;

        public BlogController(IBlogService blogService)
        {
            _blogService = blogService;
        }

        /// <summary>
        /// 添加博客
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<bool> InsertPostAsync([FromBody] PostDto dto)
        {
            return await _blogService.InsertPostAsync(dto);
        }
    }
}

添加博客操做，咱們將其設置爲[HttpPost]方式來提交，由於如今開發接口api，都要遵循RESTful方式，因此就不用給他指定路由了，[FromBody]的意思是在請求正文中以JSON的方式來提交參數。

完成上述操做，打開咱們的Swagger文檔看看， .../swagger/index.html ，已經出現咱們的接口了。

隨手就試一下這個接口，可否成功建立文章。

能夠看到數據庫已經躺着咱們剛剛添加數據內容。

將剩下的三個接口一一實現，相信你們確定都知道怎麼寫了。就不逐一嘮叨了，代碼以下：

...
        public async Task<bool> DeletePostAsync(int id)
        {
            await _postRepository.DeleteAsync(id);

            return true;
        }

        public async Task<bool> UpdatePostAsync(int id, PostDto dto)
        {
            var post = await _postRepository.GetAsync(id);

            post.Title = dto.Title;
            post.Author = dto.Author;
            post.Url = dto.Url;
            post.Html = dto.Html;
            post.Markdown = dto.Markdown;
            post.CategoryId = dto.CategoryId;
            post.CreationTime = dto.CreationTime;

            await _postRepository.UpdateAsync(post);

            return true;
        }

        public async Task<PostDto> GetPostAsync(int id)
        {
            var post = await _postRepository.GetAsync(id);

            return new PostDto
            {
                Title = post.Title,
                Author = post.Author,
                Url = post.Url,
                Html = post.Html,
                Markdown = post.Markdown,
                CategoryId = post.CategoryId,
                CreationTime = post.CreationTime
            };
        }
...

在這裏先暫時不作參數校驗，我們默認都是正常操做，若是執行操做成功，直接返回true。你們會發現，當咱們使用了DTO後，寫了大量對象的轉換，在這裏暫不作優化，將在後續業務開始後使用AutoMapper處理對象映射。若是你們感興趣能夠本身先試一下。

在Controller中調用，代碼以下：

...
        /// <summary>
        /// 刪除博客
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete]
        public async Task<bool> DeletePostAsync([Required] int id)
        {
            return await _blogService.DeletePostAsync(id);
        }

        /// <summary>
        /// 更新博客
        /// </summary>
        /// <param name="id"></param>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPut]
        public async Task<bool> UpdatePostAsync([Required] int id, [FromBody] PostDto dto)
        {
            return await _blogService.UpdatePostAsync(id, dto);
        }

        /// <summary>
        /// 查詢博客
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<PostDto> GetPostAsync([Required] int id)
        {
            return await _blogService.GetPostAsync(id);
        }
...

DeletePostAsync：指定了請求方式[HttpDelete]，參數id爲必填項

UpdatePostAsync：指定了請求方式[HttpPut]，參數id爲必填項而且爲url的一部分，要更新的具體內容和添加博客的方法InsertPostAsync的同樣的

GetPostAsync：指定了請求方式[HttpGet]，參數id爲必填項

ok，打開Swagger文檔看看效果，並試試咱們的接口是否好使吧，反正我試了是沒有問題的。

作到這一步的項目層級目錄以下:

本篇使用自定義倉儲的方式完成了對博客(meowv_posts)的增刪改查，你學會了嗎？😁😁😁

開源地址：https://github.com/Meowv/Blog/tree/blog_tutorial