欧博电脑版:基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查

admin 1个月前 (09-24) 科技 63 2

|上一篇文章(https://www.cNBlogs.com/meowv/p/12913676.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领域层中建立仓储接口,IPostRepositoryICategoryRepositoryITagRepositoryIPostTagRepositoryIFriendLinkRepository,这里直接所有继续 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>
    {
    }
}

ITagRepositoryIPostTagRepository仓储接口中,我们添加了批量插入的方式。相对于的在我们的.EntityFrameworkCore层实现这些接口。

建立Repositories/Blog 文件夹,添加实现类:PostRepositoryCategoryRepositoryTagRepositoryPostTagRepositoryFriendLinkRepository

不知道人人发现没有,我们的仓储接口以及实现,都是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)
        {
        }
    }
}

TagRepositoryPostTagRepository仓储接口的实现中,由于数据量不大,可以直接用了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 ,已经泛起我们的接口了。

欧博电脑版:基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查  第1张

随手就试一下这个接口,能否乐成建立文章。

欧博电脑版:基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查  第2张

可以看到数据库已经躺着我们刚刚添加数据内容。

将剩下的三个接口逐一实现,信赖人人肯定都知道怎么写了。就不逐一唠叨了,代码如下:

...
        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文档看看效果,并试试我们的接口是否好使吧,横竖我试了是没有问题的。

欧博电脑版:基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查  第3张

做到这一步的项目层级目录如下:

欧博电脑版:基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查  第4张

本篇使用自界说仓储的方式完成了对博客(meowv_posts)的增删改查,你学会了吗?

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

,

Sunbet

Sunbet www.monetary-reproduction.com Sunbet仅需短短几秒,全天24小时无休止无限制免费注册,sunbet欢迎您的光临!

皇冠APP下载声明:该文看法仅代表作者自己,与本平台无关。转载请注明:欧博电脑版:基于 abp vNext 和 .NET Core 开发博客项目 - 自定义仓储之增删改查

网友评论

  • (*)

最新评论

  • 环球UG网址 2020-07-14 00:15:18 回复

    Allbet Gmaing代理欢迎进入Allbet Gmaing代理(www.aLLbetgame.us):www.aLLbetgame.us,欧博官网是欧博集团的官方网站。欧博官网开放Allbet注册、Allbe代理、Allbet电脑客户端、Allbet手机版下载等业务。可以日更吗

    1
  • 环球UG官方网 2020-09-24 00:04:22 回复

    联博统计www.326681.com采用以太坊区块链高度哈希值作为统计数据,联博以太坊统计数据开源、公平、无任何作弊可能性。联博统计免费提供API接口,支持多语言接入。我要废寝忘食了

    2

文章归档