回顾

上一讲我们创建了一个实体Poet，采用EF与数据库中的表进行关联，在控制台应用中通过仓储对象访问数据。按照DDD的理论，仓储接口的定义是在领域层，而实现依赖于具体的技术，比如，在本例中采用的是EF技术，这是依赖反转的一个实例。ABP定义了仓储接口，并根据相应的实体动态生成仓储对象，这个功能使我们不需要针对每个实体都创建一个仓储类，避免了大量的相似代码的存在。上一讲为了说明问题，简化起见，我们在客户端直接调用仓储对象获得领域对象，而在实际项目中，是不可以这样做的，客户端应该通过应用层进行交互，而不是直接访问领域层，客户端与应用层交互的数据是DTO（数据传输对象），而不是领域对象。这一讲，创建其它几个实体，并建立实体之间的关系。

创建实体

我们还需要创建Poem、Category和PoemCategory实体。

Poem实体：

using Abp.Domain.Entities;
using System.Collections.Generic;

namespace ZL.Poem.Core.Poems
{
    /// <summary>
    /// 诗
    /// Volumn和Num是全唐诗中的卷和序号，
    /// </summary>
    public class Poem : Entity
    {
        /// <summary>
        /// 标题
        /// </summary>
        public virtual string Title { get; set; }

        /// <summary>
        /// 内容
        /// </summary>
        public virtual string Content { get; set; }

        /// <summary>
        /// 点评
        /// </summary>
        public virtual string Comments { get; set; }

        /// <summary>
        /// 卷（全唐诗）
        /// </summary>
        public virtual string Volumn { get; set; }

        /// <summary>
        /// 序号
        /// </summary>
        public virtual string Num { get; set; }

        /// <summary>
        /// 诗人id
        /// </summary>
        public virtual int PoetID { get; set; }

        /// <summary>
        /// 作者
        /// </summary>
        public virtual Poet Author { get; set; }


        /// <summary>
        /// 分类
        /// </summary>
        public virtual ICollection<CategoryPoem> PoemCategories { get; set; }
    }
}

Category实体：

using Abp.Domain.Entities;
using System.Collections.Generic;

namespace ZL.Poem.Core.Poems
{
    /// <summary>
    /// 诗的分类
    /// </summary>
    public class Category : Entity
    {
        /// <summary>
        /// 分类名称
        /// </summary>
        public virtual string CategoryName { get; set; }

        /// <summary>
        /// 该分类中包含的诗
        /// </summary>
        public virtual ICollection<CategoryPoem> CategoryPoems { get; set; }
    }
}

CategoryPoem实体：

using Abp.Domain.Entities;

namespace ZL.Poem.Core.Poems
{
    public class CategoryPoem : Entity
    {
        public virtual int CategoryId { get; set; }

        public virtual int PoemId { get; set; }

        public virtual Category Category { get; set; }

        public virtual Poem Poem { get; set; }
    }
}

然后修改Poet实体，增加与Poem之间的关系:

using Abp.Domain.Entities;
using System.Collections.Generic;

namespace ZL.Poem.Core.Poems
{
    /// <summary>
    /// 诗人，从ABP Entity派生
    /// </summary>
    public class Poet : Entity
    {
        /// <summary>
        /// 姓名
        /// </summary>
        public virtual string Name { get; set; }

        /// <summary>
        /// 介绍
        /// </summary>
        public virtual string Description { get; set; }

        /// <summary>
        /// 写的诗
        /// </summary>
        public virtual ICollection<Poem> Poems { get; set; }

    }
}

在DbContext中定义数据之间的关系：

首先，我们要在DbContext中增加新增实体的DbSet:

        public virtual DbSet<Core.Poems.Poem> Poems { get; set; }

        public virtual DbSet<Category> Categories { get; set; }

        public virtual DbSet<CategoryPoem> CategoryPoems { get; set; }

然后，我们要增加这些实体之间的关系。先回顾一下数据模型：

image

我们需要定义实体之间的关系，我们采用Fluent Api在DbContext的OnModelCreating中定义。

流式接口（fluent interface）是软件工程中面向对象API的一种实现方式，以提供更为可读的源代码。最早由Eric Evans与Martin Fowler于2005年提出。

 protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            //映射Poet到数据库表
            modelBuilder.Entity<Poet>().ToTable("Poet");

            //映射实体与数据库中的字段，将Id映射到数据库表的PoetID字段
            modelBuilder.Entity<Poet>()
                    .Property(p => p.Id)
                    .HasColumnName("PoetID");

            //Poem映射
            modelBuilder.Entity<Core.Poems.Poem>().ToTable("Poem");
            modelBuilder.Entity<Core.Poems.Poem>()
                    .Property(p => p.Id)
                    .HasColumnName("PoemId");

            //定义Poem与Poet之间的一对多关系
            modelBuilder.Entity<Core.Poems.Poem>().HasOne<Poet>(s => s.Author)
                    .WithMany(s => s.Poems)
                    .HasForeignKey(s => s.PoetID);

            //Category映射
            modelBuilder.Entity<Category>().ToTable("Category");
            modelBuilder.Entity<Category>().
               Property(p => p.Id)
               .HasColumnName("CategoryId");

            ///CategoryPoem映射
            modelBuilder.Entity<CategoryPoem>().ToTable("CategoryPoem");
            modelBuilder.Entity<CategoryPoem>().
               Property(p => p.Id)
               .HasColumnName("CategoryPoemId");

            //定义多对多关系
            modelBuilder.Entity<CategoryPoem>()
                        .HasKey(t => new { t.CategoryId, t.PoemId });

            modelBuilder.Entity<CategoryPoem>()
                .HasOne(pt => pt.Poem)
                .WithMany(p => p.PoemCategories)
                .HasForeignKey(pt => pt.PoemId);

            modelBuilder.Entity<CategoryPoem>()
                .HasOne(pt => pt.Category)
                .WithMany(t => t.CategoryPoems)
                .HasForeignKey(pt => pt.CategoryId);
        }

现在，我们完善了领域层，并且使用EF实现了与数据库的映射。下一步就可以开发应用层了。

本文同步发布在我的个人网站 http://www.jiagoushi.cn