经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » 编程经验 » 查看文章
2.简单的搭建后端，一步一步从基础开始
来源：cnblogs　　作者：尝尝手指　　时间：2023/9/19 8:38:22　　对本文有异议

上传Git的忽略文件下载

千万不能忘记配置忽略文件，不然可能会搞得你一个项目10多个G，很烦人

先梳理下我们需要新建的项目如下。接口层一般I(i)开头，实现层不需要。后面还会增加扩展类或者其他的。

API程序层：FastEasyAPI

服务接口层：IFastEasy.Service

服务实现层：FastEasy.Service

仓储接口层：IFastEasy.Repository

仓储实现层：FastEasy.Repository

实体层：FastEasy.Model

 仓储模式的介绍很多大佬都有博客可以了解，我不会说什么太专业的词汇表达，我也记不得，我会按照我自己的理解来形容

首先，仓储层(接口+实现)，服务层(接口+实现)，API程序层。这算是三层的结构，如果熟练或者精通了，不用建这么多类库，接口实现层可以合并或者使用泛型仓储…让项目短小精悍，不过目前我还理解不够，所以搭建最基础的仓储模式。

接下来应该去添加访问数据库的对象

 这个就有很多选择了。Ado，ef，Sqlsugar等等。我刚出来工作的时候学的ado和ef，现在的话……唉，正如前文所说，一路cv过来的，现在都忘的差不多了。所以我选择Sqlsugar！推荐！很棒！反正公司老项目就用他们封装好的ef或者ado，如果有新项目需求，我都用sqlsugar，真的好用一批~特别是多租户事务之类的，我很喜欢~（有点跑题了，继续……）

原本我打算直接用来着，后来突然想起来，咱们都core了，怎么可以不用依赖注入呢？所以嘞，这里先穿插一下Autofac的使用，因为之前我单独写过autofac的教程，所以可能我会粘贴之前的文章内容，不懂的话可以留言或者百度，面向百度编程，是你最好的选择！

Autofac的使用  Sqlsugar的注入使用

 在api程序层引入autofac的包：Autofac.Extensions.DependencyInjection（内置依赖包含了autofac的基础包）

这里说下经验之谈，也不是我自己的经验，就是随着项目越来越大，Programs里面的服务注册会越来越多，所有我要在程序下面新建一个文件夹Filter，里面放我的各个模块的注册类，例如我要注入Sqlsugar，那我会在filter文件夹下新建一个类，起名：SqlsugarModule。然后关于Sqlsugar的注入配置都写在此处，然后Programs里直接注入这个类就行，这样后期不会因为注入很多东西导致Programs过于臃肿。

引入Sqlsugar 的包：SqlSugarCore。第一次接触的话推荐大家去官网学习

  1.   Services.AddSingleton<ISqlSugarClient>(s =>
  2.         {
  3.             SqlSugarScope db = new(new ConnectionConfig()
  4.             {
  5.                 DbType = SqlSugar.DbType.Sqlite,
  6.                 ConnectionString = "DataSource=sqlsugar-dev.db",
  7.                 IsAutoCloseConnection = true,
  8.             });
  9.             return db;
  10.         });

 

scope单例注入，client非单例注入。官网的介绍是scope线程安全，排查问题方便，client非单例模式，性能比scope高5%左右。我是觉得性能差不多，scope可以让我省心很多，嘿嘿嘿。

到这里的话，sqlsugar其实已经注入完成了，就是这么简单，操作比ef方便很多啊，不过这种东西都是唯手熟尔，哪个你用着6就用哪个

创建基础Base基类

写到这儿发现前面的autofac说早了。抱歉各位。因为sqlsugar实在是很简单，所以完全不需要用到autofac（笑死），不过都这样了，就没办法了，反正下面肯定会再说autofac的使用的。

上面注入了Sqlsuar的服务，代表着我们可以访问数据库了。

众所周知，所有的功能需求到最后无非都是对数据库的增删改查，我们先不讨论你业务逻辑怎么搞，到最后你无非都是要搞一个实体，对数据库新增，或者修改，或者搞一个id对着数据库删除数据。因此，无论你操作哪个表，都离不开这些增删改查，所以这个Base基层，就是所有基础的增删改查，分页查询等。

简单梳理下结构，首先我们有仓储层，服务层，应用程序层。仓储层和服务层都各有一个接口层和实现层。最基本的要新增4个类：IBaseRepository，BaseRepository。IBaseService，BaseRepository。因为对数据访问在仓储层，所以我们从Repository开始新建起：先接口后实现。（Base基层的仓储层和服务层基本上一模一样，其方法也只是满足基本的增删改查需求，若是复杂逻辑还需将基类定义为虚方法，在每张表独立的仓储层和服务层去重写方法）

基础方法囊括：单条增删改查，批量增删改查，分页查询

 这是仓储层的Base基类接口

  1.     /// <summary>
  2.     /// 1条新增
  3.     /// </summary>
  4.     /// <param name="entity">要创建的实体对象</param>
  5.     /// <returns>如果成功创建实体记录，则返回 true；否则返回 false。</returns>
  6.     Task<bool> CreateEntityAsync(T entity);
  8.     /// <summary>
  9.     /// 批量新增
  10.     /// </summary>
  11.     /// <param name="entities">要新增的实体对象集合</param>
  12.     /// <returns>新增操作影响的记录条数</returns>
  13.     Task<int> CreateEntitysAsync(List<T> entitys);
  15.     /// <summary>
  16.     /// 1条修改
  17.     /// </summary>
  18.     /// <param name="entity">要修改的实体对象</param>
  19.     /// <returns>如果成功修改实体记录，则返回 true；否则返回 false。</returns>
  20.     Task<bool> UpdateEntityAsync(T entity);
  22.     /// <summary>
  23.     /// 批量修改
  24.     /// </summary>
  25.     /// <param name="entities">要修改的实体对象集合</param>
  26.     /// <returns>受影响的记录数</returns>
  28.     Task<int> UpdateEntitysAsync(List<T> entitys);
  30.     /// <summary>
  31.     /// 1条删除
  32.     /// </summary>
  33.     /// <param name="id">要删除的记录的主键ID。</param>
  34.     /// <returns>删除操作影响的记录数。</returns>
  35.     Task<bool> DeleteEntityByIdAsync(int id);
  37.     /// <summary>
  38.     /// 根据条件批量删除
  39.     /// </summary>
  40.     /// <param name="expression">条件</param>
  41.     /// <returns>返回受影响条数</returns>
  42.     Task<int> DeleteEntitysByWhereAsync(Expression<Func<T, bool>> expression);
  44.     /// <summary>
  45.     /// 查询所有
  46.     /// </summary>
  47.     /// <returns>返回实体集合</returns>
  48.     Task<List<T>> GetEntitysAsync();
  50.     /// <summary>
  51.     /// 根据ID单条查询
  52.     /// </summary>
  53.     /// <param name="id">主键ID</param>
  54.     /// <returns>查询到的实体</returns>
  55.     Task<T> GetEntityByIdAsync(int id);
  57.     /// <summary>
  58.     /// 根据条件批量查询。
  59.     /// </summary>
  60.     /// <param name="expression">条件表达式</param>
  61.     /// <returns>符合条件的实体集合</returns>
  62.     Task<List<T>> GetEntitysByWhereAsync(Expression<Func<T, bool>> expression);
  64.     /// <summary>
  65.     /// 分页查询
  66.     /// </summary>
  67.     /// <param name="pageNumber">页码，从1开始</param>
  68.     /// <param name="pageSize">每页条数</param>
  69.     /// <param name="totalCount">总记录数</param>
  70.     /// <returns>查询到的实体集合</returns>
  71.     Task<List<T>> GetEntitysToPageAsync(int pageNumber, int pageSize, ref int totalCount);
View Code

 

 这是仓储层Base基类实现。实现的是上面定义的Base基类接口

  1. public class BaseRepository<T> : IBaseRepository<T> where T : class, new()
  2. {
  3.     #region 构造
  4.  
  5.     public BaseRepository(ISqlSugarClient _db)
  6.     {
  7.         db = _db;
  8.     }
  10.     #endregion 构造
  11.  
  12.     protected readonly ISqlSugarClient db;
  14.     public virtual async Task<bool> CreateEntityAsync(T entity)
  15.     {
  16.         try
  17.         {
  18.             return await db.Insertable<T>(entity).ExecuteCommandAsync() > 0;
  19.         }
  20.         catch (Exception)
  21.         {
  22.             return false;
  23.         }
  24.     }
  26.     public virtual async Task<int> CreateEntitysAsync(List<T> entitys)
  27.     {
  28.         try
  29.         {
  30.             return await db.Insertable<T>(entitys).ExecuteCommandAsync();
  31.         }
  32.         catch (Exception)
  33.         {
  34.             return 0;
  35.         }
  36.     }
  38.     public virtual async Task<bool> DeleteEntityByIdAsync(int id)
  39.     {
  40.         try
  41.         {
  42.             return await db.Deleteable<T>().In(id).ExecuteCommandAsync() > 0;
  43.         }
  44.         catch (Exception)
  45.         {
  46.             return false;
  47.         }
  48.     }
  50.     public virtual async Task<int> DeleteEntitysByWhereAsync(Expression<Func<T, bool>> expression)
  51.     {
  52.         try
  53.         {
  54.             return await db.Deleteable<T>().Where(expression).ExecuteCommandAsync();
  55.         }
  56.         catch (Exception)
  57.         {
  58.             return 0;
  59.         }
  60.     }
  62.     public virtual async Task<T> GetEntityByIdAsync(int id)
  63.     {
  64.         try
  65.         {
  66.             return await db.Queryable<T>().InSingleAsync(id);
  67.         }
  68.         catch (Exception)
  69.         {
  70.             return null;
  71.         }
  72.     }
  74.     public virtual async Task<List<T>> GetEntitysAsync()
  75.     {
  76.         try
  77.         {
  78.             return await db.Queryable<T>().ToListAsync();
  79.         }
  80.         catch (Exception)
  81.         {
  82.             return null;
  83.         }
  84.     }
  86.     public virtual async Task<List<T>> GetEntitysByWhereAsync(Expression<Func<T, bool>> expression)
  87.     {
  88.         try
  89.         {
  90.             return await db.Queryable<T>().Where(expression).ToListAsync();
  91.         }
  92.         catch (Exception)
  93.         {
  94.             return null;
  95.         }
  96.     }
  98.     public virtual List<T> GetEntitysToPage(int pageNumber, int pageSize, ref int totalCount)
  99.     {
  100.         try
  101.         {
  102.             return db.Queryable<T>().ToPageList(pageNumber, pageSize, ref totalCount);
  103.         }
  104.         catch (Exception)
  105.         {
  106.             return null;
  107.         }
  108.     }
  110.     public virtual async Task<bool> UpdateEntityAsync(T entity)
  111.     {
  112.         try
  113.         {
  114.             return await db.Updateable<T>(entity).ExecuteCommandAsync() > 0;
  115.         }
  116.         catch (Exception)
  117.         {
  118.             return false;
  119.         }
  120.     }
  122.     public virtual async Task<int> UpdateEntitysAsync(List<T> entitys)
  123.     {
  124.         try
  125.         {
  126.             return await db.Updateable<T>(entitys).ExecuteCommandAsync();
  127.         }
  128.         catch (Exception)
  129.         {
  130.             return 0;
  131.         }
  132.     }
  133. }
View Code

 

 基础的增删改差不多就这么多了。写的时候发现个小问题。就是根据id的增删改查，其实也没必要专门搞个方法，使用条件查询方法就可以了，不过一开始没考虑到，我觉得代码复用性高一点说明写的好，不过我这个并没什么太大影响。继续~~

服务层的Base基类接口，这个完全可以复制仓储层的base基类接口，不能说毫无关系，只能说完全一样，所以这里不写咯。

服务层的Base基类实现，也差不多一样，不同的是仓储层是使用db访问数据库，而服务层是通过构造函数注入仓储层的Base基类接口，通过调用接口方法来进行调用。

  1. public class BaseService<T> : IBaseService<T> where T : class, new()
  2. {
  3.     #region 构造
  4.  
  5.     public BaseService(IBaseRepository<T> _baseRepository)
  6.     {
  7.         baseRepository = _baseRepository;
  8.     }
  10.     #endregion 构造
  11.  
  12.     protected readonly IBaseRepository<T> baseRepository;
  14.     public Task<bool> CreateEntityAsync(T entity)
  15.     {
  16.         return baseRepository.CreateEntityAsync(entity);
  17.     }
  19.     public Task<int> CreateEntitysAsync(List<T> entitys)
  20.     {
  21.         return baseRepository.CreateEntitysAsync(entitys);
  22.     }
  24.     public Task<bool> DeleteEntityByIdAsync(int id)
  25.     {
  26.         return baseRepository.DeleteEntityByIdAsync(id);
  27.     }
  29.     public Task<int> DeleteEntitysByWhereAsync(Expression<Func<T, bool>> expression)
  30.     {
  31.         return baseRepository.DeleteEntitysByWhereAsync(expression);
  32.     }
  34.     public Task<T> GetEntityByIdAsync(int id)
  35.     {
  36.         return baseRepository.GetEntityByIdAsync(id);
  37.     }
  39.     public Task<List<T>> GetEntitysAsync()
  40.     {
  41.         return baseRepository.GetEntitysAsync();
  42.     }
  44.     public Task<List<T>> GetEntitysByWhereAsync(Expression<Func<T, bool>> expression)
  45.     {
  46.         return baseRepository.GetEntitysByWhereAsync(expression);
  47.     }
  49.     public List<T> GetEntitysToPage(int pageNumber, int pageSize, ref int totalCount)
  50.     {
  51.         return baseRepository.GetEntitysToPage(pageNumber, pageSize, ref totalCount);
  52.     }
  54.     public Task<bool> UpdateEntityAsync(T entity)
  55.     {
  56.         return baseRepository.UpdateEntityAsync(entity);
  57.     }
  59.     public Task<int> UpdateEntitysAsync(List<T> entitys)
  60.     {
  61.         return baseRepository.UpdateEntitysAsync(entitys);
  62.     }
  63. }
View Code

 

看到这里的话，基本的仓储模式已经搭建完成了，是的没错，就是这么简单。但是还没有真正的去添加数据库，所以只有基层，像这种普通的仓储模式有个很麻烦的地方就是每一个表结构至少要在项目里添加4个类，所以还是比较麻烦的，所以最近在研究代码生成，网上有很多现成的代码生成器，不过我还是想自己研究研究，为了我这个开源项目的目标！我要搞个适配我这个项目的代码生成器，毕竟自己写的代码我心里有数~

都要一起加油哟~ 掰掰~

 

原文链接：https://www.cnblogs.com/zhang-3/p/17709227.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

编程经验热门文章

  • Prometheus监控之SNMP Exporter介绍和数据展现
  • Intel 82599网卡异常挂死原因
  • 腾讯防水墙的分析识别与破解
  • 桌面应用自动化WinAppDriver入门
  • 文档在线预览（三）使用js前端实现word、excel、pdf、ppt 在线预览
  • 「教程」如何下载AcFun网站上的视频、A站视频下载工具
  • 基于Hi3559AV100的SVP(NNIE)开发整体流程
  • GBDT(梯度提升树)scikit-klearn中的参数说明及简汇
  • antd之RangePicker设置默认值方式
  • 决胜经典算法之插入排序

    • 编程经验推荐文章

  • wifi基础(一)：无线电波与WIFI信号干扰、衰减
  • 甲方扔给两个存在包名与类名均相同的Jar包，要在工程中同时使用怎么办？
  • 《花100块做个摸鱼小网站! 》第三篇—热搜表结构设计和热搜数据存储
  • Fluent Editor：一个基于 Quill 2.0 的富文本编辑器，功能强大、开箱即用！
  • 方法的三种调用形式
  • 《花100块做个摸鱼小网站! 》第二篇—后端应用搭建和完成第一个爬虫
  • 《熬夜整理》保姆级系列教程-玩转Wireshark抓包神器教程(4)-再识Wireshark - 北京-宏哥
  • 《软件性能测试分析与调优实践之路》(第2版) 读书笔记（二）总体介绍（下）-真正从性能分析与调优来看性能测试
  • 架构知识点（三）
  • 《花100块做个摸鱼小网站! 》第一篇—买云服务器和初始化环境

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号