精华内容
下载资源
问答
  • 解决步骤如下: 1.新建同名数据库,文件位置与原数据文件mdf文件位置一样,ldf文件可随便放置哪里,不跟...再在数据库里看刚刚新建的数据库发现会有(恢复)的标识6.执行下面代码alter database 数据库名 set em...

    解决步骤如下:

     

    1.新建同名数据库,文件位置与原数据文件mdf文件位置一样,ldf文件可随便放置哪里,不跟原路径放一起就好。(做此步前需将原mdf文件重命名)
    2.停止数据库服务
    3.建好后找到文件路径,将新建的同名mdf文件重命名,原来的文件改回原名称
    4.开启数据库服务
    5.再在数据库里看刚刚新建的数据库发现会有(恢复)的标识
    6.执行下面代码
    alter database 数据库名 set emergency
    alter database 数据库名 set single_user with rollback immediate
    alter database 数据库名 rebuild log on (name=数据库日志文件名(加ldf后缀), filename='生成数据库日志文件名的路径+数据库日志文件名(加ldf后缀)')
    ALTER DATABASE 数据库名 SET MULTI_USER with rollback immediate

    7.执行后我这边提示数据库日志文件已重新生成,即刷新再看时新建数据库已没有任何标识,可正常查询数据

    转载于:https://www.cnblogs.com/morpheusliu/p/9485604.html

    展开全文
  • 就是 架构四 的基础上将数据库做读写分离,之前博主Linux服务器搭建过主从环境,搭建这个环境也不是很困难,这会一时半会找不到写哪里,后面会把主从的搭建也整理成博客,这种可以很好的减轻数据库写的压力,...

    1.简要说明

    就是在 架构四 的基础上将数据库做读写分离,之前博主在Linux服务器搭建过主从环境,搭建这个环境也不是很困难,这会一时半会找不到写哪里,后面会把主从的搭建也整理成博客,这种可以很好的减轻数据库写的压力,想象一下地铁站里面,挤地铁大家都知道人多了,搞不好人都挤怀孕了。但是地铁站的出入口就类似我们的数据库读写,出口就是数据库(读),入口就是数据库(写),可谓是泾渭分明,减轻乘坐人员的进出压力。

    2.流程图

    在这里插入图片描述

    3.存在的问题

    1. 主从的方式固然好,但是我自己操作过,数据库里面主从同步的数据是不能删除的,删除以后会导致主从数据同步失败;
    2. 因为不能随便删除数据,会导致大量的无用数据,浪费服务器硬盘空间,也会导致查询数据量大,而影响数据查询性能。

    这是我记忆中出现的问题,如果后面再碰到会继续补充。

    展开全文
  • SQL Server专家联盟的董事会中服务了5年,为很多SQL Server杂志供过稿,也讨论SQL Server数据库编程的国际会议上发过言。  Louis Davidson,作为企业数据库开发人员和架构师,他拥有超过15年的工作经验。目前...
  • SQL Server专家联盟的董事会中服务了5年,为很多SQL Server杂志供过稿,也讨论SQL Server数据库编程的国际会议上发过言。  Louis Davidson,作为企业数据库开发人员和架构师,他拥有超过15年的工作经验。目前...
  • 本文非原创,原创不知道在哪里了,要是侵权了,可以私信我。只做自身知识点记录和自身总结。有需要的朋友可以参考,不足之处欢迎下方留言~ 这个功能接口需求如下:前端展示一个数据集合,在每条数据后面有一个...

    本文非原创,原创不知道在哪里了,要是侵权了,可以私信我。只做自身知识点记录和自身总结。有需要的朋友可以参考,不足之处欢迎下方留言~ 

     

    这个功能接口需求如下:前端展示一个数据集合,在每条数据后面有一个导出功能,导出的时候传给后台一个id,后台接收到参数,就与数据库进行匹配,查到的数据放进集合,将数据生产EXCEL文件流,在返给前端。由于前后端分离开发,前段代码就不贴出来了。

     


    public void generateSheet(List<FamilyInfoBean> dataList, HttpServletResponse response)throws Exception {
    
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Calendar calendar = new GregorianCalendar(1900,0,-1);
            Date date = calendar.getTime();
            //创建工作薄
            HSSFWorkbook wb = new HSSFWorkbook();
            //创建工作表
            HSSFSheet sheet = wb.createSheet();
            //创建样式和字体
            HSSFCellStyle curStyle = wb.createCellStyle();
            HSSFFont curFont = wb.createFont();
            //创建行列
            HSSFRow nRow = sheet.createRow(0);
            HSSFCell nCell = nRow.createCell(0);
            //设置列的样式(具体实现在后面......)
            nCell.setCellStyle(this.mainTitleStyle(curStyle, curFont));
            //控制行号列号
            int rowNo = 0;
            int colNo = 0;
            //列标题
            String[] title;
            title = new String[]{"id","姓名","地址"};
            //设置标题到第一行的列中
            nRow = sheet.createRow(rowNo++);
            for (int i = 0; i < title.length; i++) {
                nCell = nRow.createCell(i);
                nCell.setCellValue(title[i]);
                nCell.setCellStyle(this.textStyle(curStyle, curFont));
            }
            //创建样式和字体(为什么又new,因为下面是正文部分了)
            curStyle = wb.createCellStyle();
        for (FamilyInfoBean dto :dataList){
                colNo = 0;//控制列号
                //每遍历一次创建一行
                nRow = sheet.createRow(rowNo++);
                //id(先查询出,再将值设置到列中)
                nCell = nRow.createCell(colNo++);
                nCell.setCellValue(dto.getCommunity_name());
                nCell.setCellStyle(this.textStyle( curStyle, curFont));
    
                //姓名
                nCell = nRow.createCell(colNo++);
                nCell.setCellValue(dto.getHouse_number_plate());
                nCell.setCellStyle(this.textStyle( curStyle, curFont));
    
                //地址
                nCell = nRow.createCell(colNo++);
                nCell.setCellValue(dto.getPerson_address());
                nCell.setCellStyle(this.textStyle( curStyle, curFont));
    
                //到这里,excel就已经生成了,然后就需要通过流来写出去
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                //将excel写入流
                wb.write(byteArrayOutputStream);
                //设置文件标题
                String dateTime = DateFormatUtils.format(new Date(), "yyyyMMddHHmm");
                String outFile =dateTime + ".xls";
                //设置返回的文件类型
                response.setContentType("application/vnd.ms-excel;charset=utf-8");
                //对文件编码
                outFile = response.encodeURL(new String(outFile.getBytes("gb2312"), "iso8859-1"));
                //使用Servlet实现文件下载的时候,避免浏览器自动打开文件
                response.addHeader("Content-Disposition", "attachment;filename=" + outFile);
                //设置文件大小
                response.setContentLength(byteArrayOutputStream.size());
                //创建Cookie并添加到response中
                Cookie cookie = new Cookie("fileDownload", "true");
                cookie.setPath("/");
                response.addCookie(cookie);
                //将流写进response输出流中
                ServletOutputStream outputstream = response.getOutputStream();
                byteArrayOutputStream.writeTo(outputstream);
    
                byteArrayOutputStream.close();
                outputstream.flush();
    
                //下面这个注释的代码,是测试是否能保存到本地,是否乱码,格式是否正确,如果没问题,前端可以直接请求接口
            /*FileOutputStream fileOutputStream = new FileOutputStream(new File("E:\\excel\\1.xls"));
                wb.write(fileOutputStream);
                wb.close();
                fileOutputStream.close();*/
            }
    }
    private HSSFCellStyle mainTitleStyle( HSSFCellStyle curStyle, HSSFFont curFont) {
            curStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);	//水平居中
            curStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);//垂直居中
            curFont.setFontName("宋体");	//字体
            curFont.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD); // 加粗
            curFont.setFontHeightInPoints((short) 16);//字体大小
            curStyle.setFont(curFont); // 绑定关系
            return curStyle;
        }
     private HSSFCellStyle textStyle(HSSFCellStyle curStyle, HSSFFont curFont) {
            curStyle.setAlignment(HSSFCellStyle.ALIGN_LEFT);//左对齐
            curStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);//垂直居中
            curStyle.setWrapText(true); // 自动换行
            curStyle.setBorderTop(HSSFCellStyle.BORDER_THIN); // 实线
            curStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN); // 实线
            curStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN); // 实线
            curStyle.setBorderRight(HSSFCellStyle.BORDER_THIN); // 实线
            curFont.setFontName("Times New Roman");//字体
            curFont.setFontHeightInPoints((short) 10);//字体大小
            curStyle.setFont(curFont); // 绑定关系
            return curStyle;
        }

     

    展开全文
  • 1、使用的时候,特别是更新数据的时候,如果不知道哪里有问题,可以查看数据库 和 实体类 的字段,是否大小写一致,比如 name 和 Name 2、使用Sqlsugar 的 CodeFirst的时候,记得要先重建一个空的数据库,不然...

    前言

    1、在使用的时候,特别是更新数据的时候,如果不知道哪里有问题,可以查看数据库 和 实体类 的字段,是否大小写一致,比如 name 和 Name

    2、在使用Sqlsugar 的 CodeFirst的时候,记得要先重建一个空的数据库,不然会提示错误。

    注意:Sqlsugar 5.x 版本已经支持自动创建数据库了,如果你用了最新的版本,可以不用手动创建(加上一行代码 db.DbMaintenance.CreateDatabase(); ,反之需要;

     

    3、要学会使用数据库监控分析器

     

     

      书接上文:《从壹开始前后端分离【 .NET Core2.0 Api + Vue 2.0 + AOP + 分布式】框架之六 || API项目整体搭建 6.1 仓储》,我们简单的对整体项目进行搭建,用到了项目中常见的仓储模式+面向接口编程,核心的一共是六层,当然你也可以根据自己的需求进行扩展,比如我在其他的项目中会用到Common层,当然我们这个项目接下来也会有,或者我还会添加Task层,主要是作为定时项目使用,我之前用的是Task Schedule,基本能满足需求。

     

      在上一节中,我们最后提出了两个问题,不知道大家是否还记得,这里还重新说明一下:

    1、如果每个仓储文件都需要把一个一个写出来,至少是四遍,会不会太麻烦,而且无法复用,失去了面向接口编程的意义;

    2、每次接口调用的时候,需要引入很多命名空间,比如Blog.Core.IServices;Blog.Core.Services;Blog.Core.Repository等等

      对就是这两个问题,相信聪明的大家也都能看懂,或许还能给出相应的解决办法,比如泛型仓储,比如依赖注入,当然,如果你有更好的办法,欢迎留言,我会把你的想法写下了,让大家一起进步。这里先简单说下问题1中为什么要四遍,仓储模式的基本就是如何将持久化动作和对象获取方式以及领域模型Domain Model结合起来,进一步:如何更加统一我们的语言(Ubiquitous Language),一个整合持久化技术的好办法是仓储Repositories。明白了这个问题,你就知道,定义仓储,首先需要定义IRepository接口(1),然后再Repository中实现(2),接着在IService层中引用这些接口,同时也可以自定义扩展业务逻辑接口(3),最后在Service层中去实现(4),这就是四层。

      问题明白了,我们就要动手做起来,思考了下,如果干巴巴直接写泛型仓储,会比较干涩,所以我考虑今天先把数据持久化做出来,一个轻量级的ORM框架——SqlSugar。

     

    零、今天完成的蓝色部分

     

     

    0、创建实体模型与数据库

     

    1、实体模型

    在上篇文章中,我们说到了仓储模式,所谓仓储,就是对数据的管理,因此,我们就必须要有实体模型,下文说到了 Advertisement ,那就先创建它的实体模型,其他的相关模型,大家自行下载代码即可:

       public class Advertisement 
        {
            /// <summary>
            /// ID
            /// </summary>public int Id { get; set; }
    
            /// <summary>
            /// 广告图片
            /// </summary>public string ImgUrl { get; set; }
    
            /// <summary>
            /// 广告标题
            /// </summary>public string Title { get; set; }
    
            /// <summary>
            /// 广告链接
            /// </summary>public string Url { get; set; }
    
            /// <summary>
            /// 备注
            /// </summary>public string Remark { get; set; }
    
            /// <summary>
            /// 创建时间
            /// </summary>
            public DateTime Createdate { get; set; } = DateTime.Now;
        }

     

    2、创建数据库

    既然要操作数据库,肯定得先有一个数据库,这里提供了两种方式:

    1、Sql语句生成(目前已经不更新,如果一定想要,去群文件下载)

    2、通过我的项目,code first 生成,并且里边可以直接 seed data,这样就能生成一个完整的带数据的Database。

    具体如何操作可以查看文章——《支持多种数据库 & 快速数据库生成》,如果你感觉麻烦,就自己根据上边的实体模型,自己创建一个数据库。

     

     

    一、在 IRepository 层设计接口

      还记得昨天我们实现的Sum接口么,今天在仓储接口 IAdvertisementRepository.cs 添加CURD四个接口,首先需要将Model层添加引用,这个应该都会,以后不再细说,如下:

     

    namespace Blog.Core.IRepository
    {
        public interface IAdvertisementRepository
        {
            int Sum(int i, int j);
    
            int Add(Advertisement model);
            bool Delete(Advertisement model);
            bool Update(Advertisement model);
            List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression);
    
        }
    }

    编译项目,提示错误,别慌!很正常,因为我们现在只是添加了接口,还没有实现接口。

     

    二、在 Repository 层实现相应接口

    当然,我们还是在AdvertisementRepository.cs文件中操作,这里我有一个小技巧,不知道大家是否用到过,因为我比较喜欢写接口,这样不仅可以不暴露核心代码,而且也可以让用户调用的时候,直接看到简单的接口方法列表,而不去管具体的实现过程,这样的设计思路还是比较提倡的,如下图:

     

     你先看到了继承的接口有红色的波浪线,证明有错误,然后右键该接口,点击 Quick Actions and Refactorings...,也就是 快速操作和重构 ,你就会看到VS的智能提示,双击左侧的Implement interface,也就是实现接口,如下图:

    Visual Studio真是宇宙第一IDE,没的说 [手动点赞],然后就创建成功了,你就可以去掉throw处理,自定义代码编写了,当然,如果你不习惯或者害怕出错,那就手动写吧,也是很快的。

    namespace Blog.Core.Repository
    {
        public class AdvertisementRepository : IAdvertisementRepository
        {
            public int Add(Advertisement model)
            {
                throw new NotImplementedException();
            }
    
            public bool Delete(Advertisement model)
            {
                throw new NotImplementedException();
            }
    
            public List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression)
            {
                throw new NotImplementedException();
            }
    
            public int Sum(int i, int j)
            {
                return i + j;
            }
    
            public bool Update(Advertisement model)
            {
                throw new NotImplementedException();
            }
        }
    }

    这个时候我们重新编译项目,嗯!意料之中,没有错误,但是具体的数据持久化如何写呢?

     

    三、引用轻量级的ORM框架——SqlSugar

    首先什么是ORM, 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说,ORM是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到关系数据库中。这些概念我就不细说了,自从开发这些年,一直在讨论的问题就是用ADO.NET还是用ORM框架,还记得前几年面试的时候,有一个经理问:

    如果一个项目,你是用三层架构ADO,还是用ORM中的EF?

     大家可以自由留言,我表示各有千秋吧,一个产品的存在即有合理性,我平时项目中也有ADO,也有EF,不过本系列教程中基于面向对象思想,面向接口思想,当然还有以后的面向切面编程(AOP),还是使用ORM框架,不过是一个轻量级的,EF比较重,我在我其他的项目中用到了.Net MVC 6.0 + EF Code First 的项目,如果大家需要,我也开源出去,放在Github上,请文末留言吧~

      关于ORM有一些常见的框架,如SqlSugar、Dapper、EF、NHeberneit等等,这些我都或多或少的了解过,使用过,至于你要问我为啥用SqlSugar,只要一个原因,作者是中国人,嗯!没错,这里给他打个广告,本系列中的前端框架Vue,也是我们中国的,Vue作者尤雨溪,这里也祝福大家都能有自己的成绩,为国人争光!

    扯远了,开始动手引入框架:

    开始,我们需要先向 Repository 层中引入SqlSugar,如下:

    1)直接在类库中通过Nuget引入 sqlSugarCore,一定是Core版本的!,我个人采用这个办法,因为项目已经比较成型

    2)Github下载源码,然后项目引用(点击跳转到Github下载页)

    注意:为什么要单独在仓储层来引入ORM持久化接口,是因为,降低耦合,如果以后想要换成EF或者Deper,只需要修改Repository就行了,其他都不需要修改,达到很好的解耦效果

     

    编译一切正常,继续

    首先呢,你需要了解下sqlsugar的具体使用方法,http://www.codeisbug.com/Doc/8,你先自己在控制台可以简单试一试,这里就不细说了,如果大家有需要,我可以单开一个文章,重点讲解SqlSugar这一块。

    1、在Blog.Core.Repository新建一个sugar文件夹,然后添加两个配置文件,BaseDBConfig.cs 和  DbContext.cs ,这个你如果看了上边的文档,那这两个应该就不是问题。

    namespace Blog.Core.Repository
    {
        public class BaseDBConfig
        {
            public static string ConnectionString = File.ReadAllText(@"D:\my-file\dbCountPsw1.txt").Trim();
    
            //正常格式是
    
            //public static string ConnectionString = "server=.;uid=sa;pwd=sa;database=BlogDB"; 
    
            //原谅我用配置文件的形式,因为我直接调用的是我的服务器账号和密码,安全起见
    
        }
    }

     

     //DbContext.cs,一个详细的上下文类,看不懂没关系,以后我会详细讲解

    namespace Blog.Core.Repository
    {
        public class DbContext
        {
    
            private static string _connectionString;
            private static DbType _dbType;
            private SqlSugarClient _db;
    
            /// <summary>
            /// 连接字符串 
            /// Blog.Core
            /// </summary>
            public static string ConnectionString
            {
                get { return _connectionString; }
                set { _connectionString = value; }
            }
            /// <summary>
            /// 数据库类型 
            /// Blog.Core 
            /// </summary>
            public static DbType DbType
            {
                get { return _dbType; }
                set { _dbType = value; }
            }
            /// <summary>
            /// 数据连接对象 
            /// Blog.Core 
            /// </summary>
            public SqlSugarClient Db
            {
                get { return _db; }
                private set { _db = value; }
            }
    
            /// <summary>
            /// 数据库上下文实例(自动关闭连接)
            /// Blog.Core 
            /// </summary>
            public static DbContext Context
            {
                get
                {
                    return new DbContext();
                }
    
            }
    
    
            /// <summary>
            /// 功能描述:构造函数
            /// 作  者:Blog.Core
            /// </summary>
            private DbContext()
            {
                if (string.IsNullOrEmpty(_connectionString))
                    throw new ArgumentNullException("数据库连接字符串为空");
                _db = new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = _connectionString,
                    DbType = _dbType,
                    IsAutoCloseConnection = true,
                    IsShardSameThread = true,
                    ConfigureExternalServices = new ConfigureExternalServices()
                    {
                        //DataInfoCacheService = new HttpRuntimeCache()
                    },
                    MoreSettings = new ConnMoreSettings()
                    {
                        //IsWithNoLockQuery = true,
                        IsAutoRemoveDataCache = true
                    }
                });
            }
    
            /// <summary>
            /// 功能描述:构造函数
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="blnIsAutoCloseConnection">是否自动关闭连接</param>
            private DbContext(bool blnIsAutoCloseConnection)
            {
                if (string.IsNullOrEmpty(_connectionString))
                    throw new ArgumentNullException("数据库连接字符串为空");
                _db = new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = _connectionString,
                    DbType = _dbType,
                    IsAutoCloseConnection = blnIsAutoCloseConnection,
                    IsShardSameThread = true,
                    ConfigureExternalServices = new ConfigureExternalServices()
                    {
                        //DataInfoCacheService = new HttpRuntimeCache()
                    },
                    MoreSettings = new ConnMoreSettings()
                    {
                        //IsWithNoLockQuery = true,
                        IsAutoRemoveDataCache = true
                    }
                });
            }
    
            #region 实例方法
            /// <summary>
            /// 功能描述:获取数据库处理对象
            /// 作  者:Blog.Core
            /// </summary>
            /// <returns>返回值</returns>
            public SimpleClient<T> GetEntityDB<T>() where T : class, new()
            {
                return new SimpleClient<T>(_db);
            }
            /// <summary>
            /// 功能描述:获取数据库处理对象
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="db">db</param>
            /// <returns>返回值</returns>
            public SimpleClient<T> GetEntityDB<T>(SqlSugarClient db) where T : class, new()
            {
                return new SimpleClient<T>(db);
            }
    
            #region 根据数据库表生产实体类
            /// <summary>
            /// 功能描述:根据数据库表生产实体类
            /// 作  者:Blog.Core
            /// </summary>       
            /// <param name="strPath">实体类存放路径</param>
            public void CreateClassFileByDBTalbe(string strPath)
            {
                CreateClassFileByDBTalbe(strPath, "Km.PosZC");
            }
            /// <summary>
            /// 功能描述:根据数据库表生产实体类
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="strPath">实体类存放路径</param>
            /// <param name="strNameSpace">命名空间</param>
            public void CreateClassFileByDBTalbe(string strPath, string strNameSpace)
            {
                CreateClassFileByDBTalbe(strPath, strNameSpace, null);
            }
    
            /// <summary>
            /// 功能描述:根据数据库表生产实体类
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="strPath">实体类存放路径</param>
            /// <param name="strNameSpace">命名空间</param>
            /// <param name="lstTableNames">生产指定的表</param>
            public void CreateClassFileByDBTalbe(
                string strPath,
                string strNameSpace,
                string[] lstTableNames)
            {
                CreateClassFileByDBTalbe(strPath, strNameSpace, lstTableNames, string.Empty);
            }
    
            /// <summary>
            /// 功能描述:根据数据库表生产实体类
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="strPath">实体类存放路径</param>
            /// <param name="strNameSpace">命名空间</param>
            /// <param name="lstTableNames">生产指定的表</param>
            /// <param name="strInterface">实现接口</param>
            public void CreateClassFileByDBTalbe(
              string strPath,
              string strNameSpace,
              string[] lstTableNames,
              string strInterface,
              bool blnSerializable = false)
            {
                if (lstTableNames != null && lstTableNames.Length > 0)
                {
                    _db.DbFirst.Where(lstTableNames).IsCreateDefaultValue().IsCreateAttribute()
                        .SettingClassTemplate(p => p = @"
    {using}
    
    namespace {Namespace}
    {
        {ClassDescription}{SugarTable}" + (blnSerializable ? "[Serializable]" : "") + @"
        public partial class {ClassName}" + (string.IsNullOrEmpty(strInterface) ? "" : (" : " + strInterface)) + @"
        {
            public {ClassName}()
            {
    {Constructor}
            }
    {PropertyName}
        }
    }
    ")
                        .SettingPropertyTemplate(p => p = @"
                {SugarColumn}
                public {PropertyType} {PropertyName}
                {
                    get
                    {
                        return _{PropertyName};
                    }
                    set
                    {
                        if(_{PropertyName}!=value)
                        {
                            base.SetValueCall(" + "\"{PropertyName}\",_{PropertyName}" + @");
                        }
                        _{PropertyName}=value;
                    }
                }")
                        .SettingPropertyDescriptionTemplate(p => p = "          private {PropertyType} _{PropertyName};\r\n" + p)
                        .SettingConstructorTemplate(p => p = "              this._{PropertyName} ={DefaultValue};")
                        .CreateClassFile(strPath, strNameSpace);
                }
                else
                {
                    _db.DbFirst.IsCreateAttribute().IsCreateDefaultValue()
                        .SettingClassTemplate(p => p = @"
    {using}
    
    namespace {Namespace}
    {
        {ClassDescription}{SugarTable}" + (blnSerializable ? "[Serializable]" : "") + @"
        public partial class {ClassName}" + (string.IsNullOrEmpty(strInterface) ? "" : (" : " + strInterface)) + @"
        {
            public {ClassName}()
            {
    {Constructor}
            }
    {PropertyName}
        }
    }
    ")
                        .SettingPropertyTemplate(p => p = @"
                {SugarColumn}
                public {PropertyType} {PropertyName}
                {
                    get
                    {
                        return _{PropertyName};
                    }
                    set
                    {
                        if(_{PropertyName}!=value)
                        {
                            base.SetValueCall(" + "\"{PropertyName}\",_{PropertyName}" + @");
                        }
                        _{PropertyName}=value;
                    }
                }")
                        .SettingPropertyDescriptionTemplate(p => p = "          private {PropertyType} _{PropertyName};\r\n" + p)
                        .SettingConstructorTemplate(p => p = "              this._{PropertyName} ={DefaultValue};")
                        .CreateClassFile(strPath, strNameSpace);
                }
            }
            #endregion
    
            #region 根据实体类生成数据库表
            /// <summary>
            /// 功能描述:根据实体类生成数据库表
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="blnBackupTable">是否备份表</param>
            /// <param name="lstEntitys">指定的实体</param>
            public void CreateTableByEntity<T>(bool blnBackupTable, params T[] lstEntitys) where T : class, new()
            {
                Type[] lstTypes = null;
                if (lstEntitys != null)
                {
                    lstTypes = new Type[lstEntitys.Length];
                    for (int i = 0; i < lstEntitys.Length; i++)
                    {
                        T t = lstEntitys[i];
                        lstTypes[i] = typeof(T);
                    }
                }
                CreateTableByEntity(blnBackupTable, lstTypes);
            }
    
            /// <summary>
            /// 功能描述:根据实体类生成数据库表
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="blnBackupTable">是否备份表</param>
            /// <param name="lstEntitys">指定的实体</param>
            public void CreateTableByEntity(bool blnBackupTable, params Type[] lstEntitys)
            {
                if (blnBackupTable)
                {
                    _db.CodeFirst.BackupTable().InitTables(lstEntitys); //change entity backupTable            
                }
                else
                {
                    _db.CodeFirst.InitTables(lstEntitys);
                }
            }
            #endregion
    
            #endregion
    
            #region 静态方法
    
            /// <summary>
            /// 功能描述:获得一个DbContext
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="blnIsAutoCloseConnection">是否自动关闭连接(如果为false,则使用接受时需要手动关闭Db)</param>
            /// <returns>返回值</returns>
            public static DbContext GetDbContext(bool blnIsAutoCloseConnection = true)
            {
                return new DbContext(blnIsAutoCloseConnection);
            }
    
            /// <summary>
            /// 功能描述:设置初始化参数
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="strConnectionString">连接字符串</param>
            /// <param name="enmDbType">数据库类型</param>
            public static void Init(string strConnectionString, DbType enmDbType = SqlSugar.DbType.SqlServer)
            {
                _connectionString = strConnectionString;
                _dbType = enmDbType;
            }
    
            /// <summary>
            /// 功能描述:创建一个链接配置
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="blnIsAutoCloseConnection">是否自动关闭连接</param>
            /// <param name="blnIsShardSameThread">是否夸类事务</param>
            /// <returns>ConnectionConfig</returns>
            public static ConnectionConfig GetConnectionConfig(bool blnIsAutoCloseConnection = true, bool blnIsShardSameThread = false)
            {
                ConnectionConfig config = new ConnectionConfig()
                {
                    ConnectionString = _connectionString,
                    DbType = _dbType,
                    IsAutoCloseConnection = blnIsAutoCloseConnection,
                    ConfigureExternalServices = new ConfigureExternalServices()
                    {
                        //DataInfoCacheService = new HttpRuntimeCache()
                    },
                    IsShardSameThread = blnIsShardSameThread
                };
                return config;
            }
    
            /// <summary>
            /// 功能描述:获取一个自定义的DB
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="config">config</param>
            /// <returns>返回值</returns>
            public static SqlSugarClient GetCustomDB(ConnectionConfig config)
            {
                return new SqlSugarClient(config);
            }
            /// <summary>
            /// 功能描述:获取一个自定义的数据库处理对象
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="sugarClient">sugarClient</param>
            /// <returns>返回值</returns>
            public static SimpleClient<T> GetCustomEntityDB<T>(SqlSugarClient sugarClient) where T : class, new()
            {
                return new SimpleClient<T>(sugarClient);
            }
            /// <summary>
            /// 功能描述:获取一个自定义的数据库处理对象
            /// 作  者:Blog.Core
            /// </summary>
            /// <param name="config">config</param>
            /// <returns>返回值</returns>
            public static SimpleClient<T> GetCustomEntityDB<T>(ConnectionConfig config) where T : class, new()
            {
                SqlSugarClient sugarClient = GetCustomDB(config);
                return GetCustomEntityDB<T>(sugarClient);
            }
            #endregion
        }
    }
    View Code

     

     

     

    2、然后在刚刚我们实现那四个方法的AdvertisementRepository.cs中,重写构造函数,编辑统一Sqlsugar实例方法,用到了私有属性,为以后的单列模式做准备。

         private DbContext context;
            private SqlSugarClient db;
            private SimpleClient<Advertisement> entityDB;
    
            internal SqlSugarClient Db
            {
                get { return db; }
                private set { db = value; }
            }
            public DbContext Context
            {
                get { return context; }
                set { context = value; }
            }
            public AdvertisementRepository() {
                DbContext.Init(BaseDBConfig.ConnectionString);
                context = DbContext.GetDbContext();
           db = context.Db; entityDB
    = context.GetEntityDB<Advertisement>(db); }

     

    3、正式开始写持久化逻辑代码(注意:我在Model层中,添加了全局的数据类型转换方法,UtilConvert,这样就不用每次都Convert,而且也解决了为空转换异常的bug)

        public static class UtilConvert
        {
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <returns></returns>
            public static int ObjToInt(this object thisValue)
            {
                int reval = 0;
                if (thisValue == null) return 0;
                if (thisValue != null && thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return reval;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <param name="errorValue"></param>
            /// <returns></returns>
            public static int ObjToInt(this object thisValue, int errorValue)
            {
                int reval = 0;
                if (thisValue != null && thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return errorValue;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <returns></returns>
            public static double ObjToMoney(this object thisValue)
            {
                double reval = 0;
                if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return 0;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <param name="errorValue"></param>
            /// <returns></returns>
            public static double ObjToMoney(this object thisValue, double errorValue)
            {
                double reval = 0;
                if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return errorValue;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <returns></returns>
            public static string ObjToString(this object thisValue)
            {
                if (thisValue != null) return thisValue.ToString().Trim();
                return "";
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <param name="errorValue"></param>
            /// <returns></returns>
            public static string ObjToString(this object thisValue, string errorValue)
            {
                if (thisValue != null) return thisValue.ToString().Trim();
                return errorValue;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <returns></returns>
            public static Decimal ObjToDecimal(this object thisValue)
            {
                Decimal reval = 0;
                if (thisValue != null && thisValue != DBNull.Value && decimal.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return 0;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <param name="errorValue"></param>
            /// <returns></returns>
            public static Decimal ObjToDecimal(this object thisValue, decimal errorValue)
            {
                Decimal reval = 0;
                if (thisValue != null && thisValue != DBNull.Value && decimal.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return errorValue;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <returns></returns>
            public static DateTime ObjToDate(this object thisValue)
            {
                DateTime reval = DateTime.MinValue;
                if (thisValue != null && thisValue != DBNull.Value && DateTime.TryParse(thisValue.ToString(), out reval))
                {
                    reval = Convert.ToDateTime(thisValue);
                }
                return reval;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <param name="errorValue"></param>
            /// <returns></returns>
            public static DateTime ObjToDate(this object thisValue, DateTime errorValue)
            {
                DateTime reval = DateTime.MinValue;
                if (thisValue != null && thisValue != DBNull.Value && DateTime.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return errorValue;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="thisValue"></param>
            /// <returns></returns>
            public static bool ObjToBool(this object thisValue)
            {
                bool reval = false;
                if (thisValue != null && thisValue != DBNull.Value && bool.TryParse(thisValue.ToString(), out reval))
                {
                    return reval;
                }
                return reval;
            }
        }
    View Code

    最终的仓储持久化是:

        public class AdvertisementRepository : IAdvertisementRepository
        {
    
            private DbContext context;
            private SqlSugarClient db;
            private SimpleClient<Advertisement> entityDB;
    
            internal SqlSugarClient Db
            {
                get { return db; }
                private set { db = value; }
            }
            public DbContext Context
            {
                get { return context; }
                set { context = value; }
            }
            public AdvertisementRepository() {
                DbContext.Init(BaseDBConfig.ConnectionString);
                context = DbContext.GetDbContext();
           db = context.Db; entityDB
    = context.GetEntityDB<Advertisement>(db); } public int Add(Advertisement model) { //返回的i是long类型,这里你可以根据你的业务需要进行处理 var i = db.Insertable(model).ExecuteReturnBigIdentity(); return i.ObjToInt(); } public bool Delete(Advertisement model) { var i = db.Deleteable(model).ExecuteCommand(); return i > 0; } public List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression) { return entityDB.GetList(whereExpression); } public int Sum(int i, int j) { return i + j; } public bool Update(Advertisement model) { //这种方式会以主键为条件 var i = db.Updateable(model).ExecuteCommand(); return i > 0; } }

     

    四、在 IServices 层设计服务接口,并 Service 层实现

    这里不细说,记得添加引用,最终的代码是:

    namespace Blog.Core.IServices
    {
        public interface IAdvertisementServices 
        {
            int Sum(int i, int j);
            int Add(Advertisement model);
            bool Delete(Advertisement model);
            bool Update(Advertisement model);
            List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression);
        }
    }
    namespace Blog.Core.Services
    {
        public class AdvertisementServices : IAdvertisementServices
        {
            public IAdvertisementRepository dal = new AdvertisementRepository();
            public int Sum(int i, int j)
            {
                return dal.Sum(i, j);
    
            }
    
    
            public int Add(Advertisement model)
            {
                return dal.Add(model);
            }
    
            public bool Delete(Advertisement model)
            {
                return dal.Delete(model);
            }
    
            public List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression)
            {
                return dal.Query(whereExpression);
    
            }
    
            public bool Update(Advertisement model)
            {
                return dal.Update(model);
            }
    
        }
    }

    都是很简单,如果昨天的Sum方法你会了,这个肯定都会。

     

    五、Controller测试接口

      实现工作,根据id获取数据

      这里为了调试方便,我把权限验证暂时注释掉

      //[Authorize(Policy ="Admin")]

     

    然后修改我们的其中一个Get方法,根据id获取信息

           // GET: api/Blog/5
            /// <summary>
            /// 
            /// </summary>
            /// <param name="id"></param>
            /// <returns></returns>
            [HttpGet("{id}", Name = "Get")]
            public List<Advertisement> Get(int id)
            {
                IAdvertisementServices advertisementServices = new AdvertisementServices();
    
                return advertisementServices.Query(d => d.Id == id);
            }
            

    接下来运行调试,在我们接口文档中,直接点击调试

     

     得到的结果是如果,虽然是空的,但是返回结果http代码是200,因为表中没数据嘛

     

    六、结语

      好啦,今天的讲解就到这里,你简单的了解了什么是ORM,以及其中的SqlSugar,然后呢,仓储模式的具体使用,最后还有真正的连接数据库,获取到数据,下一节中,我们继续来解决两大问题,来实现泛型仓储。

     

    七、CODE

     https://github.com/anjoy8/Blog.Core.git

    https://gitee.com/laozhangIsPhi/Blog.Core

    转载于:https://www.cnblogs.com/laozhang-is-phi/p/9523148.html

    展开全文
  • 前端mongo聚合笔记

    2019-06-12 01:07:14
    自从前后端分离后就一直有争辩,前后端分离的界限在哪里,前端仅仅是写页面吗?需要学习服务器数据库等后端的知识吗? 我认为是非常有必要的,假如就笼统以浏览器和服务器区分前后端,如何解释浏览器的 indexedDB 的...
  • 5.8.1 SQL Server Management Studio中删除数据库 145 5.8.2 用Drop database语句删除数据库 146 5.9 收缩数据库 146 5.9.1 自动收缩数据库 147 5.9.2 手动收缩数据库 147 5.9.3 手动收缩数据库文件 149 ...
  • 5.8.1 SQL Server Management Studio中删除数据库 145 5.8.2 用Drop database语句删除数据库 146 5.9 收缩数据库 146 5.9.1 自动收缩数据库 147 5.9.2 手动收缩数据库 147 5.9.3 手动收缩数据库文件 149 ...
  • 我做一个vue+spring cloud的前后端分离项目里...这下尴尬了,百般尝试下总算可以不删除数据的情况下,设置主键自增从哪里开始 ALTER TABLE USER AUTO_INCREMENT 8; 里面的USER是表名 8是你要设置成的自增数字 ...
  • ado.net技术内幕(高清PDF中文版)

    热门讨论 2011-06-08 18:58:06
    11.1.1 提交更新获取为时间戳列新生成的值 11.1.2 提交更新使用成批查询获取数据 11.1.3 用输出参数获取新数据 11.1.4 提交更新之后用DataAdapter对象的RowUpdated事件获取数据 11.1.5 时间戳示例应用程序...
  • 与ECJia到家APP相比 ECJia到家H5的优势在哪里? ECJia到家APP,必需要进行下载安装才能使用,为保证效果对设备性能有要求,而ECJia到家H5的终端资源及性能占用少,对设备的性能要求不高,部署灵活方便,无需下载...
  • 43.try {}里有一个return语句,那么紧跟这个try的finally {}里的code会不会被执行,什么时候被执行,return前还是? 答:会执行,return前执行。 44.两个对象值相同(x.equals(y) == true),但却可有不同...
  • ECJia到家(H5微商城)

    2017-02-24 16:49:24
    与ECJia到家APP相比 ECJia到家H5的优势在哪里? ECJia到家APP,必需要进行下载安装才能使用,为保证效果对设备性能有要求,而ECJia到家H5的终端资源及性能占用少,对设备的性能要求不高,部署灵活方便,无需下载...
  • 1. 前后端职责分离,架构清晰:前端进行交互逻辑,后端负责数据处理。 2. 前后端单独开发、单独测试。 3. 良好的交互体验,前端进行的是局部渲染。避免了不必要的跳转和重复渲染。 当然&#...
  • Android程序设计基础

    热门讨论 2013-08-03 16:28:04
    因此,我在书中特意注明在哪里可以找到你所关心的内容。  本书每章最后都有一个“快速阅读指南”,告诉无序阅读本书的读者接下来应该阅读哪些内容。读者还可以在其中发现一些指向相关资源(如图书和在线文档)的...
  • php高级开发教程说明

    2008-11-27 11:39:22
    后在适当的地方加以例外处理,当写一个应用程序时,应该知道你的代码从事的是什么工作, 能够快速地从一点转到另一点—但其他人可能认为这并不容易。如果你从开发组的某个人手 中获得一个源文件并需要添加一些特征,...
  • 最近发现有很多同学问我项目中有一些依赖的jar包在哪里,比如redis cache, swagger等,这些都在我的Github主页中有。 查看 http://cxytiandi.com/blog/detail/20517 看看怎么启动整个项目。 作者 尹吉欢 ...
  • 单一工程模型下的业务关系,总的来说就是:你中有我,我中有你,相互依赖,无法分离。如下图: 4.2 项目组件化结构 主工程: 除了一些全局配置和主 Activity 之外,不包含任何业务代码。有的也叫做空壳app ...
  • 正则表达式

    2014-12-03 14:51:39
    \ 做为转意,即通常"\"后面的字符不按原来意义解释,如/b/匹配字符"b",当b前面加了反斜杆/\b/,转意为匹配一个单词的边界。 -或- 对正则表达式功能字符的还原,如"*"匹配它前面元字符0次或多次,/a*/将匹配a,...
  • powerbuilder

    2013-11-21 17:11:48
    当应用程序需要使用更多的字体时,可以使用了某个字体号输出内容使用PrintDefineFont()函数将该字体号对应的字体更换为其它字体。 -----------------------------------------------------------------------...
  • Git权威指南PDF完整版

    千次下载 热门讨论 2012-12-25 17:53:55
    14.1 对象和引用哪里去了/ 187 14.2 暂存区操作引入的临时对象/ 189 14.3 重置操作引入的对象/ 191 14.4 Git管家:git-gc/ 193 14.5 Git管家的自动执行/ 196 第3篇 Git和声 第15章 Git协议与工作协同/ 200 15.1 Git ...
  • ssm框架demo遇到的问题

    2020-02-19 11:53:10
    所以从javaweb开始就尝试前后端分离学习ssm框架时,讲师用的都是jsp,我以为只要把springmvc的视图解析器中suffix配置成.html就行了,事情却没那么简单,项目一运行就报404,按理应该默认去找index.html,但是却...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

数据库分离后在哪里