前言

.net core已经出来一段时间了，相信大家对.net core的概念已经很清楚了，这里就不再赘述。笔者目前也用.net core做过一些项目，并且将以前framework下的一些经验移植到了.net core下，并结合.net core本身的一些特性整理成此框架，以供学习参考。如有不足之处，欢迎指正。

 先睹为快，演示地址：http://cloud.eggtwo.com/main/index

框架介绍

先来一张整体分层结构图

基础层

1.Cloud.Core项目是核心项目，主要实现缓存的操作、dapper操作、EF Repository、PageList、日志等操作

2.Cloud.Utility属于帮助类

领域层

3.Cloud.Entity实体对象，存放数据库映射实体、Fluent API配置、枚举字典、DbContext等

4.Cloud.UnitOfWork，操作数据库的网关，里面封装了对仓储的操作、dapper的操作、事务等

服务层

5.Cloud.Service 业务逻辑的实现

6.Cloud.Dto 数据传输对象，实体对象不直接和表现层接触，通过dto互转

表现层

7.Cloud.Framework，表现层框架，封装了超类controller，全局授权过滤器，全局异常过滤器，ActionFilter,HtmlHelper等操作

8.Cloud.Boss 启动项目

使用的技术

基于.net core 2.0的asp.net core mvc

基于.net core 2.0的ef

dapper

mysql

前端框架aceAdmin

技术要点

1.实体基类定义

 2.泛型仓储的封装

2.1仓储接口的定义，泛型约束T必须是BaseEntity类型

  1. public interface IRepository<T> where T : BaseEntity
  2.     {
  3.         DatabaseFacade Database { get; }
  4.         IQueryable<T> Entities { get; }
  5.         int SaveChanges();
  6.         Task<int> SaveChangesAsync();
  7.         void Disposed();
  8.  
  9.         bool Delete(List<T> entitys, bool isSaveChange = true);
  10.         bool Delete(T entity, bool isSaveChange = true);
  11.         Task<bool> DeleteAsync(List<T> entitys, bool isSaveChange = true);
  12.         Task<bool> DeleteAsync(T entity, bool isSaveChange = true);
  13.  
  14.         Task<T> GetAsync(Expression<Func<T, bool>> predicate = null);
  15.         Task<List<T>> GetListAsync(Expression<Func<T, bool>> predicate = null);
  16.         T Get(object id);
  17.         T Get(Expression<Func<T, bool>> predicate = null);
  18.         Task<T> GetAsync(object id);
  19.         Task<IQueryable<T>> LoadAsync(Expression<Func<T, bool>> predicate = null);
  20.  
  21.         bool Insert(List<T> entitys, bool isSaveChange = true);
  22.         bool Insert(T entity, bool isSaveChange = true);
  23.         Task<bool> InsertAsync(List<T> entitys, bool isSaveChange = true);
  24.         Task<bool> InsertAsync(T entity, bool isSaveChange = true);
  25.  
  26.         bool Update(List<T> entitys, bool isSaveChange = true);
  27.         bool Update(T entity, bool isSaveChange = true, List<string> updatePropertyList = null);
  28.         Task<bool> UpdateAsync(List<T> entitys, bool isSaveChange = true);
  29.         Task<bool> UpdateAsync(T entity, bool isSaveChange = true, List<string> updatePropertyList = null);
  30.  
  31.     }

　　

2.2仓储接口的实现

  1.   public class Repository<T> : IRepository<T> where T : BaseEntity
  2.     {
  3.         DbContext _dbContext;
  4.         public Repository(DbContext dbContext)
  5.         {
  6.             _dbContext = dbContext;
  7.         }
  8.         public int SaveChanges()
  9.         {
  10.             return _dbContext.SaveChanges();
  11.         }
  12.         public async Task<int> SaveChangesAsync()
  13.         {
  14.             return await _dbContext.SaveChangesAsync();
  15.         }
  16.         public void Disposed()
  17.         {
  18.             throw new Exception("不允许在这里释放上下文，请在UnitOfWork中操作");
  19.             _dbContext.Dispose();
  20.         }
  21.         #region 插入数据
  22.         public bool Insert(T entity, bool isSaveChange = true)
  23.         {
  24.             _dbContext.Set<T>().Add(entity);
  25.             if (isSaveChange)
  26.             {
  27.                 return SaveChanges() > 0;
  28.             }
  29.             return false;
  30.         }
  31.         public async Task<bool> InsertAsync(T entity, bool isSaveChange = true)
  32.         {
  33.             _dbContext.Set<T>().Add(entity);
  34.             if (isSaveChange)
  35.             {
  36.                 return await SaveChangesAsync() > 0;
  37.             }
  38.             return false;
  39.         }
  40.         public bool Insert(List<T> entitys, bool isSaveChange = true)
  41.         {
  42.             _dbContext.Set<T>().AddRange(entitys);
  43.             if (isSaveChange)
  44.             {
  45.                 return SaveChanges() > 0;
  46.             }
  47.             return false;
  48.         }
  49.         public async Task<bool> InsertAsync(List<T> entitys, bool isSaveChange = true)
  50.         {
  51.             _dbContext.Set<T>().AddRange(entitys);
  52.             if (isSaveChange)
  53.             {
  54.                 return await SaveChangesAsync() > 0;
  55.             }
  56.             return false;
  57.         }
  58.         #endregion
  59.  
  60.         #region 更新数据
  61.         public bool Update(T entity, bool isSaveChange = true, List<string> updatePropertyList = null)
  62.         {
  63.             if (entity==null)
  64.             {
  65.                 return false;
  66.             }
  67.             _dbContext.Set<T>().Attach(entity);
  68.             if (updatePropertyList==null)
  69.             {
  70.                 _dbContext.Entry<T>(entity).State = EntityState.Modified;//全字段更新
  71.  
  72.             }
  73.             else
  74.             {
  75.                 updatePropertyList.ForEach(c => {
  76.                     _dbContext.Entry(entity).Property(c).IsModified = true; //部分字段更新的写法
  77.  
  78.                 });
  79.  
  80.             }
  81.             if (isSaveChange)
  82.             {
  83.                 return SaveChanges() > 0;
  84.             }
  85.             return false;
  86.         }
  87.         public bool Update(List<T> entitys, bool isSaveChange = true)
  88.         {
  89.             if (entitys==null||entitys.Count==0)
  90.             {
  91.                 return false;
  92.             }
  93.             entitys.ForEach(c => {
  94.                 Update(c, false);
  95.             });
  96.             if (isSaveChange)
  97.             {
  98.                 return SaveChanges() > 0;
  99.             }
  100.             return false;
  101.         }
  102.         public async Task<bool> UpdateAsync(T entity, bool isSaveChange = true, List<string> updatePropertyList = null)
  103.         {
  104.             if (entity == null)
  105.             {
  106.                 return false;
  107.             }
  108.             _dbContext.Set<T>().Attach(entity);
  109.             if (updatePropertyList == null)
  110.             {
  111.                 _dbContext.Entry<T>(entity).State = EntityState.Modified;//全字段更新
  112.  
  113.             }
  114.             else
  115.             {
  116.                 updatePropertyList.ForEach(c => {
  117.                     _dbContext.Entry(entity).Property(c).IsModified = true; //部分字段更新的写法
  118.  
  119.                 });
  120.  
  121.             }
  122.             if (isSaveChange)
  123.             {
  124.                 return await SaveChangesAsync() > 0;
  125.             }
  126.             return false;
  127.         }
  128.         public async Task<bool> UpdateAsync(List<T> entitys, bool isSaveChange = true)
  129.         {
  130.             if (entitys == null || entitys.Count == 0)
  131.             {
  132.                 return false;
  133.             }
  134.             entitys.ForEach(c => {
  135.                 _dbContext.Set<T>().Attach(c);
  136.                 _dbContext.Entry<T>(c).State = EntityState.Modified;
  137.             });
  138.             if (isSaveChange)
  139.             {
  140.                 return await SaveChangesAsync() > 0;
  141.             }
  142.             return false;
  143.         }
  144.         #endregion
  145.  
  146.         #region 删除
  147.         public bool Delete(T entity, bool isSaveChange = true)
  148.         {
  149.             _dbContext.Set<T>().Attach(entity);
  150.             _dbContext.Set<T>().Remove(entity);
  151.             return isSaveChange ? SaveChanges() > 0 : false;
  152.         }
  153.         public bool Delete(List<T> entitys, bool isSaveChange = true)
  154.         {
  155.             entitys.ForEach(entity =>
  156.             {
  157.                 _dbContext.Set<T>().Attach(entity);
  158.                 _dbContext.Set<T>().Remove(entity);
  159.             });
  160.             return isSaveChange ? SaveChanges() > 0 : false;
  161.         }
  162.  
  163.         public virtual async Task<bool> DeleteAsync(T entity, bool isSaveChange = true)
  164.         {
  165.  
  166.             _dbContext.Set<T>().Attach(entity);
  167.             _dbContext.Set<T>().Remove(entity);
  168.             return isSaveChange ? await SaveChangesAsync() > 0 : false;
  169.         }
  170.         public virtual async Task<bool> DeleteAsync(List<T> entitys, bool isSaveChange = true)
  171.         {
  172.             entitys.ForEach(entity =>
  173.             {
  174.                 _dbContext.Set<T>().Attach(entity);
  175.                 _dbContext.Set<T>().Remove(entity);
  176.             });
  177.             return isSaveChange ? await SaveChangesAsync() > 0 : false;
  178.         }
  179.         #endregion
  180.  
  181.         public IQueryable<T> Entities => _dbContext.Set<T>().AsQueryable().AsNoTracking();
  182.         //public async Task<IQueryable<T>> EntitiesAsync => Task.Run(()=> _dbContext.Set<T>().AsQueryable().AsNoTracking()); 
  183.  
  184.         public DatabaseFacade Database => _dbContext.Database;
  185.         #region 查找
  186.         public T Get(object id)
  187.         {
  188.             return _dbContext.Set<T>().Find(id);
  189.         }
  190.         public T Get(Expression<Func<T, bool>> predicate = null)
  191.         {
  192.             return _dbContext.Set<T>().Where(predicate).AsNoTracking().FirstOrDefault();
  193.         }
  194.         public async Task<T> GetAsync(object id)
  195.         {
  196.             return await _dbContext.Set<T>().FindAsync(id);
  197.         }
  198.         public async Task<T> GetAsync(Expression<Func<T, bool>> predicate = null)
  199.         {
  200.             return await _dbContext.Set<T>().Where(predicate).AsNoTracking().FirstOrDefaultAsync();
  201.         }
  202.         public async Task<List<T>> GetListAsync(Expression<Func<T, bool>> predicate = null)
  203.         {
  204.             return await _dbContext.Set<T>().Where(predicate).AsNoTracking().ToListAsync();
  205.         }
  206.         public async Task<IQueryable<T>> LoadAsync(Expression<Func<T, bool>> predicate = null)
  207.         {
  208.             if (predicate == null)
  209.             {
  210.                 predicate = c => true;
  211.             }
  212.             return await Task.Run(() => _dbContext.Set<T>().Where(predicate).AsNoTracking());
  213.         }
  214.  
  215.         public void Dispose()
  216.         {
  217.             throw new NotImplementedException();
  218.         }
  219.         #endregion
  220.  
  221.     }

　　

3.表部分字段更新实现

EF默认的更新方式是一个实体对应的表全部字段更新，那么我们想更新表的部分字段怎么处理？

首先定义需要更新的字段：

  1.    public class PropertyExpression<T> where T : BaseEntity
  2.     {
  3.         private PropertyExpression() { }
  4.         private static List<string> propertyList = new List<string>();
  5.         public static PropertyExpression<T> Init
  6.         {
  7.             get
  8.             {
  9.                 propertyList.Clear();
  10.                 return new PropertyExpression<T>();
  11.             }
  12.         }
  13.  
  14.         public PropertyExpression<T> Property(Expression<Func<T, object>> expr)
  15.         {
  16.             var rtn = "";
  17.             if (expr.Body is UnaryExpression)
  18.             {
  19.                 rtn = ((MemberExpression)((UnaryExpression)expr.Body).Operand).Member.Name;
  20.             }
  21.             else if (expr.Body is MemberExpression)
  22.             {
  23.                 rtn = ((MemberExpression)expr.Body).Member.Name;
  24.  
  25.             }
  26.             else if (expr.Body is ParameterExpression)
  27.             {
  28.                 rtn = ((ParameterExpression)expr.Body).Type.Name;
  29.             }
  30.             propertyList.Add(rtn);
  31.             return this;
  32.         }
  33.         public List<string> ToList()
  34.         {
  35.             return propertyList;
  36.         }
  37.  
  38.     }

　　EF更新的处理

  1.  public bool Update(T entity, bool isSaveChange = true, List<string> updatePropertyList = null)
  2.         {
  3.             if (entity==null)
  4.             {
  5.                 return false;
  6.             }
  7.             _dbContext.Set<T>().Attach(entity);
  8.             if (updatePropertyList==null)
  9.             {
  10.                 _dbContext.Entry<T>(entity).State = EntityState.Modified;//全字段更新
  11.  
  12.             }
  13.             else
  14.             {
  15.                 updatePropertyList.ForEach(c => {
  16.                     _dbContext.Entry(entity).Property(c).IsModified = true; //部分字段更新的写法
  17.  
  18.                 });
  19.  
  20.             }
  21.             if (isSaveChange)
  22.             {
  23.                 return SaveChanges() > 0;
  24.             }
  25.             return false;
  26.         }

　　使用

  1.  var entity = _unitOfWork.SysRoleRep.Get(model.RoleId);
  2.                     if (entity == null)
  3.                     {
  4.                         throw new Exception("要查找的对象不存在");
  5.                     }
  6.                     entity.Name = model.RoleName;
  7.                     var updatedPropertyList = PropertyExpression<Sys_Role>.Init.Property(c => c.Name).ToList();
  8.                     _unitOfWork.SysRoleRep.Update(entity, true, updatedPropertyList);

　　

4.动态加载实体到DbContext

  1.  public class EntityTypeConfiguration<T> : IEntityTypeConfiguration<T> where T : class
  2.     {
  3.         public void Configure(EntityTypeBuilder<T> builder)
  4.         {
  5.             RelyConfigure(builder);
  6.         }
  7.         public virtual void RelyConfigure(EntityTypeBuilder<T> builder)
  8.         {
  9.  
  10.         }
  11.     }

　　

  1. public class Sys_Error_LogConfiguration : EntityTypeConfiguration<Sys_Error_Log>
  2.     {
  3.         public override void RelyConfigure(EntityTypeBuilder<Sys_Error_Log> builder)
  4.         {
  5.             builder.ToTable("sys_error_log");
  6.             builder.HasKey(x => x.Id);
  7.             base.RelyConfigure(builder);
  8.         }
  9.  
  10.     }

　　

  1.   public class EfDbContext : DbContext
  2.     {
  3.         public EfDbContext(DbContextOptions<EfDbContext> options) : base(options)
  4.         {
  5.  
  6.         }
  7.         //配置数据库连接
  8.         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  9.         {
  10.            // optionsBuilder.UseSqlServer("xxxx connection string");
  11.             base.OnConfiguring(optionsBuilder);
  12.         }
  13.  
  14.         //第一次使用EF功能时执行一次，以后不再执行
  15.         protected override void OnModelCreating(ModelBuilder modelBuilder)
  16.         {
  17.             //获取当前程序集中有基类并且基类是泛型的类
  18.             var typesToRegister = Assembly.GetExecutingAssembly().GetTypes().Where(c => c.BaseType != null && c.BaseType.IsGenericType).ToList();
  19.             foreach (var type in typesToRegister)
  20.             {
  21.                 //泛型定义相同
  22.                 if (type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>))
  23.                 {
  24.                     dynamic configurationInstance = Activator.CreateInstance(type);
  25.                     modelBuilder.ApplyConfiguration(configurationInstance);
  26.                 }
  27.  
  28.             }
  29.  
  30.            base.OnModelCreating(modelBuilder);
  31.         }
  32.     }

　　

5.工作单元

工作单元是对仓储和事务的封装

原理参考：https://docs.microsoft.com/zh-cn/aspnet/mvc/overview/older-versions/getting-started-with-ef-5-using-mvc-4/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application

  1.    public class EfUnitOfWork : IUnitOfWork
  2.     {
  3.         private EfDbContext _dbContext;//每次请求上下文只会创建一个
  4.         public EfUnitOfWork(EfDbContext context)
  5.         {
  6.             this._dbContext = context;
  7.         }
  8.         public int SaveChanges()
  9.         {
  10.  
  11.             return _dbContext.SaveChanges();
  12.         }
  13.         public async Task<int> SaveChangesAsync()
  14.         {
  15.             return await _dbContext.SaveChangesAsync();
  16.         }
  17.         private bool disposed = false;
  18.  
  19.         protected virtual void Dispose(bool disposing)
  20.         {
  21.             if (!this.disposed)
  22.             {
  23.                 if (disposing)
  24.                 {
  25.                     _dbContext.Dispose();//随着工作单元的销毁而销毁
  26.                 }
  27.             }
  28.             this.disposed = true;
  29.         }
  30.  
  31.         public void Dispose()
  32.         {
  33.             Dispose(true);
  34.             GC.SuppressFinalize(this);
  35.         }
  36.         public IDbContextTransaction BeginTransaction()
  37.         {
  38.             var scope = _dbContext.Database.BeginTransaction();
  39.             return scope;
  40.         }
  41.  
  42.         public List<T> SqlQuery<T>(string sql, object param = null) where T : class
  43.         {
  44.             var con= _dbContext.Database.GetDbConnection();
  45.             if (con.State!= ConnectionState.Open)
  46.             {
  47.                 con.Open();
  48.             }
  49.             var list= MysqlDapperReader.SqlQuery<T>(con, sql, param);
  50.             return list;
  51.             //throw new NotImplementedException();
  52.         }
  53.  
  54.         public Task<List<T>> SqlQueryAsync<T>(string sql, object param = null) where T : class
  55.         {
  56.             throw new NotImplementedException();
  57.         }
  58.  
  59.         #region Sys Repository
  60.         private IRepository<Sys_User> _sysUserRep;
  61.         public IRepository<Sys_User> SysUserRep
  62.         {
  63.             get
  64.             {
  65.                 if (_sysUserRep == null)
  66.                 {
  67.                     //var s= HttpContext.Current.Items["currentUser"];
  68.                     //var s = HttpContext.Current.RequestServices.GetService<IRepository<Sys_User>>();
  69.                     //HttpContext.RequestServices.GetService<IRepository<Sys_User>>();
  70.                     _sysUserRep = new Repository<Sys_User>(_dbContext);
  71.                 }
  72.                 return _sysUserRep;
  73.             }
  74.         }
  75.         private IRepository<Sys_Role> _sysRoleRep;
  76.         public IRepository<Sys_Role> SysRoleRep
  77.         {
  78.             get
  79.             {
  80.                 if (_sysRoleRep == null)
  81.                 {
  82.                     _sysRoleRep = new Repository<Sys_Role>(_dbContext);
  83.                 }
  84.                 return _sysRoleRep;
  85.             }
  86.         }
  87.         private IRepository<Sys_Role_User> _sysRoleUserRep;
  88.         public IRepository<Sys_Role_User> SysRoleUserRep
  89.         {
  90.             get
  91.             {
  92.                 if (_sysRoleUserRep == null)
  93.                 {
  94.                     _sysRoleUserRep = new Repository<Sys_Role_User>(_dbContext);
  95.                 }
  96.                 return _sysRoleUserRep;
  97.             }
  98.         }
  99.  
  100.         private IRepository<Sys_Permission> _sysPermissionRep;
  101.         public IRepository<Sys_Permission> SysPermissionRep
  102.         {
  103.             get
  104.             {
  105.                 if (_sysPermissionRep == null)
  106.                 {
  107.                     _sysPermissionRep = new Repository<Sys_Permission>(_dbContext);
  108.                 }
  109.                 return _sysPermissionRep;
  110.             }
  111.         }
  112.         private IRepository<Sys_Module> _sysModuleRep;
  113.         public IRepository<Sys_Module> SysModuleRep
  114.         {
  115.             get
  116.             {
  117.                 if (_sysModuleRep == null)
  118.                 {
  119.                     _sysModuleRep = new Repository<Sys_Module>(_dbContext);
  120.                 }
  121.                 return _sysModuleRep;
  122.             }
  123.         }
  124.  
  125.         private IRepository<Sys_Error_Log> _sysErrorLogRep;
  126.         public IRepository<Sys_Error_Log> SysErrorLogRep
  127.         {
  128.             get
  129.             {
  130.                 if (_sysErrorLogRep == null)
  131.                 {
  132.                     _sysErrorLogRep = new Repository<Sys_Error_Log>(_dbContext);
  133.                 }
  134.                 return _sysErrorLogRep;
  135.             }
  136.         }
  137.  
  138.         private IRepository<Sys_Operation_Log> _sysOperationLogRep;
  139.         public IRepository<Sys_Operation_Log> SysOperationLogRep
  140.         {
  141.             get
  142.             {
  143.                 if (_sysOperationLogRep == null)
  144.                 {
  145.                     _sysOperationLogRep = new Repository<Sys_Operation_Log>(_dbContext);
  146.                 }
  147.                 return _sysOperationLogRep;
  148.             }
  149.         }
  150.         #endregion
  151.  
  152.     }

6.业务的实现方式

　以前我是service中直接创建仓储然后用仓储操作数据库，方式如下：

这种方式比较繁琐，后来我将创建仓储统一放在工作单元中进行，在service中直接创建UnitOfWork，方式如下：

7.Service的动态注册

  1. public static class AutoIocRegister
  2.     {
  3.         /// <summary>
  4.         /// 动态注入IOC，注意类和接口的命名规则，接口在类名前面加"I"
  5.         /// </summary>
  6.         /// <param name="services"></param>
  7.         /// <param name="assemblyName">程序集名称</param>
  8.         public static void BatchAddScoped(this IServiceCollection services, string assemblyName)
  9.         {
  10.             var libs = DependencyContext.Default.CompileLibraries;
  11.             var serviceLib = libs.Where(c => c.Name.Contains(assemblyName)).FirstOrDefault();
  12.             var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(serviceLib.Name));
  13.             var serviceClassList = assembly.GetTypes().Where(c => c.IsClass).ToList();
  14.             foreach (var item in serviceClassList)
  15.             {
  16.                 var interfaceName = "I" + item.Name;
  17.                 var interfaceType = assembly.GetTypes().Where(c => c.IsInterface && c.Name == interfaceName).FirstOrDefault();
  18.                 if (interfaceType == null) continue;
  19.                 services.AddScoped(interfaceType, item);
  20.             }
  21.         }
  22.     }　

调用：

  1.  services.BatchAddScoped("Cloud.Service");

8.日志记录：

日志分操作日志和错误日志，可以设置在数据库和文本中同时记录：

通过全局过滤器GlobalExceptionFilter和GlobalAuthorizeFilter处理

　

9.前端的封装（分页、弹出层、ajax等）

先放几张图吧，详细的以后再介绍

 演示地址：http://cloud.eggtwo.com/main/index

基于.net core 2.0+mysql+AceAdmin搭建一套快速开发框架的更多相关文章

  1. 基于springboot+bootstrap+mysql+redis搭建一套完整的权限架构【六】【引入bootstrap前端框架】

    https://blog.csdn.net/linzhefeng89/article/details/78752658 基于springboot+bootstrap+mysql+redis搭建一套完整 ...

  2. 一个基于 .NET Core 2.0 开发的简单易用的快速开发框架 - LinFx

    LinFx 一个基于 .NET Core 2.0 开发的简单易用的快速开发框架,遵循领域驱动设计(DDD)规范约束,提供实现事件驱动.事件回溯.响应式等特性的基础设施.让开发者享受到正真意义的面向对象 ...

  3. 基于.Net Core 5.0 Worker Service 的 Quart 服务

    前言 看过我之前博客的人应该都知道,我负责了相当久的部门数据同步相关的工作.其中的艰辛不赘述了. 随着需求的越来越复杂,最近windows的计划任务已经越发的不能满足我了,而且计划任务毕竟太弱智,总是 ...

  4. .Net Core 2.0 的 ConsoleApp 搭建 Quartz（xml配置）windows服务

    零.创建一个.Net Core 2.0 的ConsoleApp 应用,建完就是这个样子了. 添加Log4Net 的引用,(不想看可以不看,个人习惯)Install-Package log4net添加C ...

  5. win10下ASP.NET Core 2.0部署环境搭建（转）

    此文用于记录在win10环境下,新建的Asp.net Core 2.0 Web应用项目如何运行在IIS上 一.运行环境 操作系统: Window10 家庭中文版 版本 10.0.15063 版本 15 ...

  6. SpringCloud微服务实战——搭建企业级开发框架（四十六）：【移动开发】整合uni-app搭建移动端快速开发框架-环境搭建

      近年来uni-app发展势头迅猛,只要会vue.js,就可以开发一套代码,发布移动应用到iOS.Android.Web(响应式).以及各种小程序(微信/支付宝/百度/头条/飞书/QQ/快手/钉钉/ ...

  7. 基于.NetCore的Redis5.0.3（最新版）快速入门、源码解析、集群搭建与SDK使用【原创】

    1.[基础]redis能带给我们什么福利 Redis(Remote Dictionary Server)官网:https://redis.io/ Redis命令:https://redis.io/co ...

  8. Skywalking入门介绍，skywalking6.5.0 +mysql (windows) 搭建

    一. 介绍 1. 基本信息 SkyWalking 创建于2015年,提供分布式追踪功能.从5.x开始,项目进化为一个完成功能的Application Performance Monitoring系统. ...

  9. 基于.Net Core的API框架的搭建（1）

    目标 我们的目标是要搭建一个API控制器的项目,API控制器提供业务服务. 一.开发框架搭建 1.开发前准备 开发前,我们需要下载如下软件,安装过程略: (1) 开发工具:VS2017 (2) 数据库 ...

随机推荐

  1. SQL0419N 十进制除法运算无效，因为结果将有一个负小数位。 SQLSTATE=42911

    select case when sum(qty_sold*u.um03/u.um08) <> 0 then decimal(coalesce(sum(d.amt_sold_with_ta ...

  2. Python3创建项目时创建了一个叫做“keyword"的包，运行项目时报ImportError: cannot import name 'iskeyword'错误

    导致该问题的原因为在Python3中keyword是python的关键字包,所以在给包命名时应避免使用关键字进行命名.解决方法,将keword包名称修改为'keywords'就可以了.

  3. Mysql常用命令 详细整理版

    Mysql常用命令 show databases; 显示数据库 create database name; 创建数据库 use databasename; 选择数据库 drop database na ...

  4. 【机器学习】异常检测算法(I)

    在给定的数据集,我们假设数据是正常的 ,现在需要知道新给的数据Xtest中不属于该组数据的几率p(X). 异常检测主要用来识别欺骗,例如通过之前的数据来识别新一次的数据是否存在异常,比如根据一个用户以 ...

  5. eclipse中修改maven本地仓库方式

    1.安装maven,教程可参考:https://jingyan.baidu.com/article/4f7d5712a1306c1a21192746.html 2.安装成功后,可以打开eclipse新 ...

  6. spring深入学习(二)-----bean的生命周期、IOC容器bean装配

    bean的生命周期 1.实例化Bean对于BeanFactory容器,当客户向容器请求一个尚未初始化的bean时,或初始化bean的时候需要注入另一个尚未初始化的依赖时,容器就会调用createBea ...

  7. 关于Bell数的一道题目

      考虑 T3+1  {1,2,3,4} T3是3个元素的划分,如果在里面加入子集{4},   4被标成特殊元素,  就形成了T4一类的划分(里面的子集的并集是{1,2,3,4}) T2是2个元素的划 ...

  8. Unity自动切割动画

    最近在开发项目时,需要处理大量的动画,于是就网上查找资料,然后写了这么编辑器工具: 就是在模型导入时,根据配置文件自动切割动画. 首先我们需要封装两个类:一个模型类和一个动画类 public clas ...

  9. 公用表表达式 (CTE)、递归、所有子节点、sqlserver

    指定临时命名的结果集,这些结果集称为公用表表达式 (CTE).公用表表达式可以包括对自身的引用.这种表达式称为递归公用表表达式. 对于递归公用表达式来说,实现原理也是相同的,同样需要在语句中定义两部分 ...

  10. 下划线“_”在oracle中不是单纯的表示下划线的意思，而是表示匹配单一任何字符！

    [解决办法]1.使用 escape() 函数escape关键字经常用于使某些特殊字符,如通配符:'%','_'转义为它们原来的字符的意义,被定义的转义字符通常使用'\',但是也可以使用其他的符号.例如 ...