DDD领域驱动设计——基础设施层

前言

源码地址：
https://github.com/SkylerSkr/Skr3D

看过前面文章的同学应该已经发现了。领域层就像个霸道总裁，什么都不管什么都不问，反正你就给我处理好。真是苦出了声来。
这一章就是基础设施层，我们在这里将领域对象持久化到数据库。细心的同学应该已经发现了。
领域实体和数据库实体相差十万八千里，根本没办法直接持久化到数据库。
难道要一个个转换，然后在持久化到数据库嘛，那也太麻烦了！
那怎么可能嘛，我们使用了EFCore的CodeFirst，用它的Fluent表达式来设置领域对象如何序列化。
这里分享一下讲Fluent的文章大家可以看一下。
https://www.cnblogs.com/wyy1234/archive/2018/09/18/9670529.html

Mapping

    /// <summary>
    /// 订单map类
    /// </summary>
    public class OrderMap : IEntityTypeConfiguration<Order>
    {
        /// <summary>
        /// 实体属性配置
        /// </summary>
        /// <param name="builder"></param>
        public void Configure(EntityTypeBuilder<Order> builder)
        {
            //实体属性Maps
            builder.Property(c => c.Id)
                .HasColumnName("Id");

            builder.Property(c => c.Name)
                .HasColumnType("varchar(100)")
                .HasMaxLength(100)
                .IsRequired();

            //子订单
            builder.HasMany(c=>c.OrderItem);

            //值类型
            builder.OwnsOne(x=>x.Address);

        }
    }

    /// <summary>
    /// 子订单map类
    /// </summary>
    public class OrderItemMap : IEntityTypeConfiguration<OrderItem>
    {
        /// <summary>
        /// 实体属性配置
        /// </summary>
        /// <param name="builder"></param>
        public void Configure(EntityTypeBuilder<OrderItem> builder)
        {
            //实体属性Maps
            builder.Property(c => c.Id)
                .HasColumnName("Id");

            builder.Property(c => c.Name)
                .HasColumnType("varchar(100)")
                .HasMaxLength(100)
                .IsRequired();

            //外键
            builder.HasOne(c => c.Order);
        }
    }

这样我们就设置好了领域实体如何持久化到数据库了
PS：值对象要以OwnsOne的方式配置
生成的表结构如下:

DbContext

有了实体映射文件，接着就是设置一下上下文类，并将Mapping配置进DbContext。

    public class OrderContext : DbContext
    {
        public DbSet<Order> Orders { get; set; }
        public DbSet<OrderItem> OrderItems { get; set; }

        /// <summary>
        /// 重写自定义Map配置
        /// </summary>
        /// <param name="modelBuilder"></param>
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            //对 StudentMap 进行配置
            modelBuilder.ApplyConfiguration(new OrderMap());

            base.OnModelCreating(modelBuilder);
        }

        /// <summary>
        /// 重写连接数据库
        /// </summary>
        /// <param name="optionsBuilder"></param>
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            // 从 appsetting.json 中获取配置信息
            var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json")
                .Build();

            // 定义要使用的数据库
            //我是读取的文件内容，为了数据安全
            optionsBuilder.UseSqlServer(DbConfig.InitConn(config.GetConnectionString("DefaultConnection_file"), config.GetConnectionString("DefaultConnection")));
        }
    }

Repository

大家还记得上一章里，我们在领域层声明了持久化接口嘛。这里我们实现一下。

    /// <summary>
    /// 泛型仓储，实现泛型仓储接口
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
    {
        protected readonly OrderContext Db;
        protected readonly DbSet<TEntity> DbSet;

        public Repository(OrderContext context)
        {
            Db = context;
            DbSet = Db.Set<TEntity>();
        }

        public virtual void Add(TEntity obj)
        {
            DbSet.Add(obj);
        }

        public virtual TEntity GetById(Guid id)
        {
            return DbSet.Find(id);
        }

        public virtual IQueryable<TEntity> GetAll()
        {
            return DbSet;
        }

        public virtual void Update(TEntity obj)
        {
            DbSet.Update(obj);
        }

        public virtual void Remove(Guid id)
        {
            DbSet.Remove(DbSet.Find(id));
        }

        public int SaveChanges()
        {
            return Db.SaveChanges();
        }

        public void Dispose()
        {
            Db.Dispose();
            GC.SuppressFinalize(this);
        }
    }

    public class OrderRepository : Repository<Order>, IOrderRepository
    {
        public OrderRepository(OrderContext context)
          : base(context)
        {

        }
        public Order GetByName(string name)
        {
            throw new NotImplementedException();
        }
    }

到这里为止，我们就把领域层扔过来的问题解决了，这一层只关心如何将领域对象持久化。