七色花基本权限系统（10）- 数据接口的实现

为什么要设计数据接口

首先来看一下3层的主要逻辑：数据层 => 业务层 => 应用层。作为通用的项目模板，其中最可能按需而大变的就是数据层，因为不同的项目，使用的数据库、数据驱动技术，是很有可能不同的。项目A，MsSql+EF（就像我正在演示的），项目B，也用这套模板，但变成了MySql+ADO.NET，那么就要尽可能地维持项目的整洁，减少需要修改的代码的量和范围。最佳的做法自然就是“数据层暴露出接口，业务层不关心数据实现”。

要设计哪些接口

凡是数据实现层要暴露给业务逻辑层使用的，都需要设计接口。比如仓储实现、数据库初始化实现。

实现数据接口

新建类库项目，名称S.Framework.DataInterface。

数据实现层中需要暴露的有：

基本仓储实现类BaseRepository

数据库初始化实现类MasterDatabaseInitializer

各实体仓储实现类

接下来就是为以上3种实现写对应的接口。

先说一句，数据实现层中，用一级文件夹EntityFramework进行了不同数据驱动的划分，但数据接口层中则不需要这样，因为只是定义规范，不需要关心实现。

创建目录结构及接口如下图：

作为BaseRepository的接口，IBaseRepository并不需要包含所有已实现的方法。接口只是定义通用的规范，一定要注意通用性。比如BaseRepository中的Query方法，是返回数据查询器对象的，是EF特有的，那就不用定义在接口规范中。把常规的Find、Add、Update、Delete等通用方法定义在接口中即可，如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace S.Framework.DataInterface
{
    /// <summary>
    /// 仓储基本接口
    /// </summary>
    /// <typeparam name="TEntity">实体类型</typeparam>
    public interface IBaseRepository<TEntity> where TEntity : class
    {
        /// <summary>
        /// 主键查询
        /// </summary>
        /// <param name="keyValues">键值</param>
        /// <returns>实体</returns>
        TEntity Find(IEnumerable<object> keyValues);

        /// <summary>
        /// 主键查询
        /// </summary>
        /// <param name="keyValues">键值</param>
        /// <returns>实体</returns>
        TEntity Find(params object[] keyValues);

        /// <summary>
        /// 添加实体
        /// </summary>
        /// <param name="entity">实体</param>
        void Add(TEntity entity);

        /// <summary>
        /// 批量添加实体
        /// </summary>
        /// <param name="entities">实体集合</param>
        void AddRange(IEnumerable<TEntity> entities);

        /// <summary>
        /// 更改实体
        /// </summary>
        /// <param name="entity">实体对象</param>
        void Update(TEntity entity);

        /// <summary>
        /// 批量更改实体
        /// </summary>
        /// <param name="entities">实体集合</param>
        void UpdateRange(IEnumerable<TEntity> entities);

        /// <summary>
        /// 主键删除实体
        /// </summary>
        /// <param name="key">键值</param>
        void Delete(object key);

        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="entity">实体</param>
        void Delete(TEntity entity);

        /// <summary>
        /// 批量删除实体
        /// </summary>
        /// <param name="entities">实体集合</param>
        void DeleteRange(IEnumerable<TEntity> entities);
    }
}

数据库初始化实现，其实有EF独特的地方（比如合并），假设数据驱动换成dapper或者ADO.NET，也是没办法实现部分初始化功能的。因此在接口IDatabaseInitializer中，只要关注“数据库的数据初始化”就行。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace S.Framework.DataInterface.Initializes
{
    public interface IDatabaseInitializer
    {
        /// <summary>
        /// 设置数据库初始化策略
        /// </summary>
        /// <param name="migrate">是否合并（自动迁移）。若是，则会检查数据库是否存在，若不存在则创建，若存在则进行自动迁移。若否，则不进行初始化操作（这样能避开EF访问sys.databases检测数据库是否存在，项目稳定后可将参数设置为false。）。</param>
        void Initialize(bool migrate);
    }
}

实体仓储接口的实现，跟实体仓储一样，也可以通过T4模板来自动生成部分类。

先让数据接口层引用数据实体层，因为T4中需要反射实体类。

仓储接口模板：

<#+
// <copyright file="IRepository.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class IRepository : CSharpTemplate
{
    private string _modelName;
    private string _prefixName;

    public IRepository(string modelName, string prefixName)
    {
        _modelName = modelName;
        _prefixName = prefixName;
    }

	public override string TransformText()
	{
		base.TransformText();
#>
using System;

using S.Framework.Entity.<#= _prefixName #>;

namespace S.Framework.DataInterface.IRepositories.<#= _prefixName #>
{
	/// <summary>
    /// 仓储接口
    /// </summary>
    public partial interface I<#= _modelName #>Repository : IBaseRepository<<#= _modelName #>>
    {

    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

执行器文件：

<#@ template language="C#" debug="True" #>
<#@ assembly name="System.Core" #>
<#@ output extension="cs" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ include file="T4Toolbox.tt" #>
<#@ include file="IRepository.tt" #>
<#

    string coreName = "S.Framework", projectName = coreName + ".DataInterface", entityProjectName = coreName + ".Entity";
    string entityBaseModelName = entityProjectName + ".EntityBaseModel";
    string entityBaseModelNameForReflection = entityProjectName + ".EntityModelBaseForReflection";
    //当前完整路径
    string currentPath = Path.GetDirectoryName(Host.TemplateFile);
    //T4文件夹的父级文件夹路径
    string projectPath = currentPath.Substring(0, currentPath.IndexOf(@"T4"));
    //解决方案路径
    string solutionFolderPath = currentPath.Substring(0, currentPath.IndexOf(@"" + projectName));

    //加载数据实体.dll
    string entityFilePath = string.Concat(solutionFolderPath, ("\"+ entityProjectName +"\bin\Debug\" + entityProjectName + ".dll"));
    byte[] fileData = File.ReadAllBytes(entityFilePath);
    Assembly assembly = Assembly.Load(fileData);
    //反射出实体类，不知道为啥此处不能成功判定“是否继承EntityModelBaseForReflection类”
    //因此只能通过名称比较的方式来判定
    IEnumerable<Type> modelTypes = assembly.GetTypes().Where(m => m.IsClass && !m.IsAbstract && (m.BaseType.FullName.Equals(entityBaseModelName) || m.BaseType.FullName.Equals(entityBaseModelNameForReflection)));

    //循环实体类
    Dictionary<string, List<Type>> prefixModelTypes = new Dictionary<string, List<Type>>();//存储[数据库标识名称]和[实体类型集合]
    foreach (Type item in modelTypes)
    {
        //找 实体文件夹 名称
        string tempNamespace= item.Namespace, nameSpaceWithoutProjectName = tempNamespace.Substring(entityProjectName.Length);
        if(nameSpaceWithoutProjectName.IndexOf(".") != 0 || nameSpaceWithoutProjectName.LastIndexOf(".") > 0)
        { continue; }

        //是否直接继承实体基本类
        bool purity = item.BaseType.FullName.Equals(entityBaseModelNameForReflection);
        //实体所在的数据库标识名称
        string targetName = nameSpaceWithoutProjectName.Substring(1);
        List<Type> temp;
        if(prefixModelTypes.TryGetValue(targetName, out temp))
        {
            temp.Add(item);
        }
        else
        {
            temp = new List<Type>{ item };
            prefixModelTypes.Add(targetName, temp);
        }

        //目标文件的路径和名称（嵌套Generate文件夹是为了标识T4生成的类文件）
        string fileName= targetName + @"GenerateI" + item.Name + "Repository.cs";
        //仓储文件
        string folderName= @"IRepositories";
        IRepository irepository = new IRepository(item.Name, targetName);
        irepository.Output.Encoding = Encoding.UTF8;
        string path = projectPath + folderName + fileName;
        irepository.RenderToFile(path);
    }

#>

运行T4之后，数据接口层文档结构目录如下：

最后，让数据实现层引用数据接口层，再调整对接口的继承。

先让BaseRepository继承IBaseRepository接口，如下图：

public abstract class BaseRepository<TEntity> : IBaseRepository<TEntity> where TEntity : class, new()

由于数据库初始化类和实体仓储实现都是T4自动生成的，因此想让生成的文件继承接口，需要调整相应的T4模板。

调整DatabaseInitializer模板，最终代码如下：

<#+
// <copyright file="DatabaseInitializer.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class DatabaseInitializer : CSharpTemplate
{
    private string _prefixName;

    public DatabaseInitializer(string prefixName)
    {
        this._prefixName = prefixName;
    }

	public override string TransformText()
	{
		base.TransformText();
#>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;

using S.Framework.DataCore.EntityFramework.EntityContexts;
using S.Framework.DataInterface.Initializes;

namespace S.Framework.DataAchieve.EntityFramework.Initializes
{
	/// <summary>
    /// <#= _prefixName #> 数据库初始化操作类
    /// </summary>
    public class <#= _prefixName #>DatabaseInitializer : IDatabaseInitializer
    {
        /// <summary>
        /// 设置数据库初始化策略
        /// </summary>
        /// <param name="migrate">是否合并（自动迁移）。若是，则会检查数据库是否存在，若不存在则创建，若存在则进行自动迁移。若否，则不进行初始化操作（这样能避开EF访问sys.databases检测数据库是否存在，项目稳定后可将参数设置为false）。</param>
        public void Initialize(bool migrate)
        {
            if (!migrate)
            {
                System.Data.Entity.Database.SetInitializer<<#= _prefixName #>EntityContext>(null);
            }
            else
            {
                System.Data.Entity.Database.SetInitializer(new MigrateDatabaseToLatestVersion<<#= _prefixName #>EntityContext, <#= _prefixName #>MigrateConfiguration>(true));
            }
        }
    }
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

调整Repository模板，实体仓储除了需要继承BaseRepository类，还需要继承数据接口层中相应的实体仓储接口，最终代码如下：

<#+
// <copyright file="Repository.tt" company="">
//  Copyright © . All Rights Reserved.
// </copyright>

public class Repository : CSharpTemplate
{
    private string _modelName;
    private string _prefixName;

    public Repository(string modelName, string prefixName)
    {
        this._modelName = modelName;
        this._prefixName = prefixName;
    }
	public override string TransformText()
	{
		base.TransformText();
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using S.Framework.Entity.<#= _prefixName #>;
using S.Framework.DataInterface.IRepositories.<#= _prefixName #>;

namespace S.Framework.DataAchieve.EntityFramework.Repositories.<#= _prefixName #>
{
	/// <summary>
    /// 实体仓储
    /// </summary>
    public partial class <#= _modelName #>Repository : BaseRepository<<#= _modelName #>>, I<#= _modelName #>Repository
	{

	}
}
<#+
        return this.GenerationEnvironment.ToString();
	}
}
#>

另外，由于在WebUI层中的Global.asax里调用了数据库初始化方法（该方法继承于接口），因此也需要让WebUI层引用数据接口层，才能正常运行项目。

下一章节，将演示仓储与工作单元的设计和实现，是非常核心的内容。

截止本章节，项目源码下载：点击下载（存在百度云盘中）