.net core webapi +ddd(领域驱动)+nlog配置+swagger配置 学习笔记（2）
DDD领域驱动模型设计
什么是DDD
软件开发不是一蹴而就的事情，我们不可能在不了解产品（或行业领域）的前提下进行软件开发，在开发前，通常需要进行大量的业务知识梳理，而后到达软件设计的层面，最后才是开发。而在业务知识梳理的过程中，我们必然会形成某个领域知识，根据领域知识来一步步驱动软件设计，就是领域驱动设计的基本概念。
听起来这和传统意义的软件开发没啥区别，只是换了点新鲜的名词而已，其实不然。
该架构分成了Interfaces、Applications和Domain三层以及包含各类基础设施的Infrastructure。下图简略描述了它们之间的关系：
图1：领域驱动设计风格的架构草图(来自于DDDSample官网）
下图是详细架构：
图2：领域驱动设计参考架构
- Interface
负责向用户展现信息，并且会解析用户行为，即常说的展现层。
- Application
应用层没有任何的业务逻辑代码，它很简单，它主要为程序提供任务处理。
- Domain
这一层包含有关领域的信息，是业务的核心，领域模型的状态都直接或间接（持久化至数据库）存储在这一层。
- Infrastructure
为其他层提供底层依赖操作。
层结构的划分是很有必要的，只有清晰的结构，那么最终的领域设计才宜用，比如用户要预定航班，向Application的service发起请求，而后Domain从Infrastructure获取领域对象，校验通过后会更新用户状态，最后再次通过Infratructure持久化到数据库中。
那么根据这些我们就可以设计出自己得项目。当然需要灵活运用。
在此之前 我们先添加一些基础类库，然后分开层次。
目前我得项目大体是这样分层得。至于列出12345 是为了更加整齐，做程序员别的事情可以拖沓，但是写代码拖沓得真的不是一个好习惯。
Domain里面 我放入两个2文件夹，其中Entity是数据实体类，IOModel意思得Input Output得意思，专门处理传入传出得实体类。
Entity中 可以写入一些基类，比如我得
/// <summary>
/// 实体标准基类
/// </summary>
public abstract class StandardBaseEntity : ReadonlyBaseEntity
{
protected StandardBaseEntity(int userId):base(userId)
{
SetAddUserIdAndTime(userId);
}
/// <summary>
/// 最后更新操作人ID
/// </summary>
public int LastUpdateUserId { get; set; }
/// <summary>
/// 最后更新时间
/// </summary>
public DateTime LastUpdateTime { get; set; }
/// <summary>
/// 行版本 （时间戳处理并发）
/// </summary>
public byte[] DataTimestamp { get; set; }
/// <summary>
/// 填写添加时的标准信息
/// </summary>
/// <param name="userId"></param>
public new void SetAddUserIdAndTime(int userId)
{
base.SetAddUserIdAndTime(userId);
LastUpdateUserId = userId;
LastUpdateTime = DateTime.Now;
}
/// <summary>
/// 填写更新时的标准信息
/// </summary>
/// <param name="userId"></param>
public void SetUpdateUserIdAndTime(int userId)
{
LastUpdateUserId = userId;
LastUpdateTime = DateTime.Now;
}
}
/// <summary>
/// 实体简化基类
/// </summary>
public abstract class ReadonlyBaseEntity
{
protected ReadonlyBaseEntity() { }
protected ReadonlyBaseEntity(int userId)
{
SetAddUserIdAndTime(userId);
}
public virtual MethodResultFull<bool> Validate()
{
if (_validator == null)
{
throw new NullReferenceException(nameof(_validator));
}
ValidationResult validateResult = _validator.Validate(this).FirstOrDefault();
MethodResultFull<bool> result = new MethodResultFull<bool>();
if (validateResult == null)
{
result.Content = true;
}
else
{
result.ResultNo = validateResult.ErrorMessage;
}
return result;
}
/// <summary>
/// 创建操作人ID
/// </summary>
public int CreateUserId { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreateTime { get; set; }
/// <summary>
/// 填写添加时的标准信息
/// </summary>
/// <param name="userId"></param>
public void SetAddUserIdAndTime(int userId)
{
CreateUserId = userId;
CreateTime = DateTime.Now;
}
private static IValidator _validator = new DataAnnotationsValidator();
public static void SetValidator(IValidator valiator)
{
_validator = valiator;
}
这个看自己得需求，我得基类主要要处理一些公用得字段，公用方法，对实体类得某些字段加入自定义特性得验证规则验证。特性真得是一个非常有用得东西，至于怎么使用，自己去翻资料。
这个是Repository类内得一些文件。因为使用得是EntityFrameworkCore ，所以需要添加nugut引用。
这里面需要注意得有几块
- 第一 DataBaseContext，主要是数据库链接，这个就需要前面在webapi中依赖注入。
appsettings.json 添加数据库连接
- 第二 DatabaseFactory 和 UnitOfWork，为什么需要这个，其中DatabaseFactory是一个 DataBaseContext 简单工厂，为 UnitOfWork 和 Repository 提供 DataBaseContext 上下文，其中UnitOfWork是工作单元主要处理，对数据最后得操作，这个是很有必要得。 使每一个HTTP请求只用一个DataBaseContext上下文，不需要重复的打开数据库连接，减轻数据库压力
在DataBaseContext 中 跟之前还有点区别得。
public interface IDatabaseFactory
{
DataBaseContext Get();
}
/// <summary>
/// 主要用于同一个DataBaseContext 上下文
/// </summary>
public class DatabaseFactory: Disposable, IDatabaseFactory
{
private DataBaseContext dataContext;
private static readonly string connection = ConfigurationManager.AppSettings["SqlConnection"];
private static readonly DbContextOptions<DataBaseContext> dbContextOption = new DbContextOptions<DataBaseContext>();
private static readonly DbContextOptionsBuilder<DataBaseContext> dbContextOptionBuilder = new DbContextOptionsBuilder<DataBaseContext>(dbContextOption);
public DataBaseContext Get()
{
return dataContext ?? (dataContext = new DataBaseContext(dbContextOptionBuilder.UseSqlServer(connection).Options));
}
protected override void DisposeCore()
{
if (dataContext != null)
dataContext.Dispose();
}
}
因为dataContext 没有得话就需要New 一个新得，所以写得稍微有点复杂。没想到更好得解决办法。有好得解决办法希望提出来
IIRepository 代码如下，基本上够用了。
public interface IRepository<T> where T : class
{
//增
void Add(T entity);
void AddAll(IEnumerable<T> entities);
//改
void Update(T entity);
void Update(IEnumerable<T> entities);
//删
void Delete(T entity);
void Delete(Expression<Func<T, bool>> where);
void DeleteAll(IEnumerable<T> entities);
void Clear();
//查
T GetById(long Id);
T GetById(string Id);
T Get(Expression<Func<T, bool>> where);
IEnumerable<T> GetAll();
IQueryable<T> GetMany(Expression<Func<T, bool>> where);
IQueryable<T> GetAllLazy();
DbSet<T> GetDbLazy();
}
public abstract class RepositoryBase<T> where T:class
{
private DataBaseContext dataContext;
private readonly DbSet<T> dbset;
protected IDatabaseFactory DatabaseFactory
{
get;
private set;
}
protected DataBaseContext DataContext
{
get { return dataContext ?? (dataContext = DatabaseFactory.Get()); }
}
protected RepositoryBase(IDatabaseFactory databaseFactory)
{
DatabaseFactory = databaseFactory;
dbset = DataContext.Set<T>();
}
#region 增删查改
/// <summary>
/// 添加单条记录
/// </summary>
/// <param name="entity">实体类</param>
public void Add(T entity)
{
dbset.Add(entity);
}
/// <summary>
/// 添加多条
/// </summary>
/// <param name="entities"></param>
public virtual void AddAll(IEnumerable<T> entities)
{
dbset.AddRange(entities);
}
/// <summary>
/// 更新一条
/// </summary>
/// <param name="entity"></param>
public virtual void Update(T entity)
{
//Attach要附加的实体。
dbset.Attach(entity);
DataContext.Entry(entity).State = EntityState.Modified;
}
/// <summary>
/// 更新多条
/// </summary>
/// <param name="entities"></param>
public virtual void Update(IEnumerable<T> entities)
{
foreach (var item in entities)
{
dbset.Attach(item);
DataContext.Entry(item).State = EntityState.Modified;
}
}
/// <summary>
/// 删除单条
/// </summary>
/// <param name="entity"></param>
public virtual void Delete(T entity)
{
dbset.Remove(entity);
}
/// <summary>
/// 按条件删除
/// </summary>
/// <param name="where"></param>
public virtual void Delete(Expression<Func<T, bool>> where)
{
IEnumerable<T> objects = dbset.Where<T>(where).AsEnumerable();
dbset.RemoveRange(objects);
}
/// <summary>
/// 删除多条
/// </summary>
/// <param name="entities"></param>
public virtual void DeleteAll(IEnumerable<T> entities)
{
dbset.RemoveRange(entities);
}
public virtual void Clear()
{
throw new NotImplementedException();
}
/// <summary>
/// 根据Id得到实体
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual T GetById(long id)
{
return dbset.Find(id);
}
/// <summary>
/// 根据Id得到实体
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual T GetById(string id)
{
return dbset.Find(id);
}
/// <summary>
/// 得到所有实体
/// </summary>
/// <returns></returns>
public virtual IEnumerable<T> GetAll()
{
return dbset.ToList();
}
/// <summary>
/// 按条件得到多条实体
/// </summary>
/// <param name="where"></param>
/// <returns></returns>
public virtual IQueryable<T> GetMany(Expression<Func<T, bool>> where)
{
return dbset.Where(where);
}
/// <summary>
/// 按条件得到单条实体
/// </summary>
/// <param name="where"></param>
/// <returns></returns>
public T Get(Expression<Func<T, bool>> where)
{
return dbset.Where(where).FirstOrDefault<T>();
}
public virtual IQueryable<T> GetAllLazy()
{
return dbset;
}
public virtual DbSet<T> GetDbLazy()
{
return dbset;
}
#endregion
}
UnitOfWork代码如下
public interface IUnitOfWork
{
void Commit();
void CommitAsync();
IEnumerable<T> ExecuteQuery<T>(string sqlQuery, params object[] parameters) where T : class;
int ExecuteCommand(string sqlCommand, params object[] parameters);
}
public class UnitOfWork : Disposable, IUnitOfWork
{
private DataBaseContext dataContext;
protected IDatabaseFactory DatabaseFactory
{
get;
private set;
}
protected DataBaseContext DataContext
{
get { return dataContext ?? (dataContext = DatabaseFactory.Get()); }
}
public UnitOfWork(IDatabaseFactory databaseFactory)
{
DatabaseFactory = databaseFactory;
}
/// <summary>
/// 同步完成
/// </summary>
public void Commit()
{
DataContext.SaveChanges();
}
/// <summary>
/// 异步完成
/// </summary>
public void CommitAsync()
{
DataContext.SaveChangesAsync();
}
/// <summary>
/// 执行Sql 返回实体
/// </summary>
/// <param name="sqlQuery"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public virtual IEnumerable<T> ExecuteQuery<T>(string sqlQuery, params object[] parameters) where T:class
{
return DataContext.Set<T>().FromSql(sqlQuery, parameters);
}
/// <summary>
/// 执行Sql 返回执行个数
/// </summary>
/// <param name="sqlCommand"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public virtual int ExecuteCommand(string sqlCommand, params object[] parameters)
{
return DataContext.Database.ExecuteSqlCommand(sqlCommand, parameters);
}
protected override void DisposeCore()
{
if (dataContext != null)
dataContext.Dispose();
}
}
其中 ExecuteQuery ExecuteCommand是对Reposotry得补充，EF因为体量大，所以有些地方需要手写Sql语句。可以看出，对于Repository里面得数据CURD，最终处理结果都交给工作单元来实现，Commit方法。一个事务中只需调用一次。
EFCore得映射也有变化，以前是直接引用基类EntityTypeConfiguration 就可以了，现在是手动实现，代码如下。
public interface IEntityMappingConfiguration
{
void Map(ModelBuilder b);
}
public interface IEntityMappingConfiguration<T> : IEntityMappingConfiguration where T : class
{
void Map(EntityTypeBuilder<T> builder);
}
public abstract class EntityMappingConfiguration<T> : IEntityMappingConfiguration<T> where T : class
{
public abstract void Map(EntityTypeBuilder<T> b);
public void Map(ModelBuilder b)
{
Map(b.Entity<T>());
}
}
public static class ModelBuilderExtenions
{
private static IEnumerable<Type> GetMappingTypes(this Assembly assembly, Type mappingInterface)
{
return assembly.GetTypes().Where(x => !x.IsAbstract && x.GetInterfaces().Any(y => y.GetTypeInfo().IsGenericType && y.GetGenericTypeDefinition() == mappingInterface));
}
public static void AddEntityConfigurationsFromAssembly(this ModelBuilder modelBuilder, Assembly assembly)
{
var mappingTypes = assembly.GetMappingTypes(typeof(IEntityMappingConfiguration<>));
var typesToRegister = Assembly.GetExecutingAssembly().GetTypes()
.Where(type => !string.IsNullOrEmpty(type.Namespace))
.Where(type => type.BaseType != null && type.BaseType.IsGenericType && (
type.BaseType.GetGenericTypeDefinition() == typeof(ReadonlyBaseMap<>) ||
type.BaseType.GetGenericTypeDefinition() == typeof(IEntityMappingConfiguration<>) ||
type.BaseType.GetGenericTypeDefinition() == typeof(StandardBaseMap<>)) && type.Name != "StandardBaseMap`1" && type.Name != "ReadonlyBaseMap`1");
foreach (var config in typesToRegister.Select(Activator.CreateInstance).Cast<IEntityMappingConfiguration>())
{
config.Map(modelBuilder);
}
}
}
在ReadonlyBaseMap中 引用基类
public class ReadonlyBaseMap<T> : EntityMappingConfiguration<T> where T : ReadonlyBaseEntity
{
public override void Map(EntityTypeBuilder<T> builder)
{
builder.Property(e => e.CreateTime).IsRequired();
}
}
在StandardBaseMap 如下
public class StandardBaseMap<T> : ReadonlyBaseMap<T> where T : StandardBaseEntity
{
public override void Map(EntityTypeBuilder<T> builder)
{
builder.Property(e => e.CreateUserId).IsRequired();
builder.Property(e => e.LastUpdateUserId).IsRequired();
builder.Property(e => e.LastUpdateTime).IsRequired();
builder.Property(e => e.DataTimestamp).IsRowVersion();
}
}
这样我们就可以用一个方法处理映射关系，不需要重复添加各个实体类得映射 在DataBaseContext
之后就是对外得Application了，这个就是一个IService 和 Service 其中注入IRepostory 实现业务逻辑。
当然其中少不了 依赖注入这个了，虽然.net core 提供了内置依赖注入方式。但是我用得是第三方Autofac,一个比较成熟的插件。
DDD 就到这吧。
心之所向,无往不知至
