『Spring.NET+NHibernate+泛型』框架搭建之DAO（三）★

  本节内容介绍Nhibernate所封装的数据库訪问层。只是我增加了泛型进行封装。大概思路：首先，我们有一个接口层，另一个相应的实现层。在接口层中我们先定义一个父接口，父接口中定义每个接口都可能会用到的方法，然后其它接口继承此父接口即可。假设子接口须要使用特殊的方法，能够单独定义在子接口中；在接口实现层中也是类似的，定义一个父类，里面写好实现了接口层父接口的方法。其它实现层相同继承父接口和实现层父类，接口层中定义的特殊方法也在相应的实现类中进行实现。这样做能够有效的把相似的反复代码（反复的增删改查）尽可能的降低。而且这样设计比較灵活，反复的写一次即可了，特殊的单独写。维护起来也比較方便。这样描写叙述可能不是非常明确，以下具体介绍实现步骤。

一、数据库訪问接口层IDAO

  1. 在解决方式上右键新建一个类库，命名为IDAO，用来存放Nhibernae数据库訪问接口层代码，并加入引用上一节所讲的实体层Model；

  2. 在类库中加入一个父接口，命名为IDAO，并定义经常使用的方法，代码例如以下：

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

namespace IDAO
{
    public interface IDAO<T>
    {
        /// <summary>
        /// 加入实体
        /// </summary>
        /// <param name="entity"></param>
        int Add(T entity);

        /// <summary>
        /// 改动实体
        /// </summary>
        /// <param name="entity"></param>
        void Update(T entity);

        /// <summary>
        /// 保存或改动实体
        /// </summary>
        /// <param name="customer"></param>
        void SaveOrUpdate(IList<T> list);

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

        /// <summary>
        /// 按条件删除
        /// </summary>
        /// <param name="sqlWhere">删除条件</param>
        void Delete(string sqlWhere);

        /// <summary>
        /// 依据ID得到实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        T Get(int id);

        /// <summary>
        /// 依据ID得到实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
       T Load(int id);

        /// <summary>
        /// 得到全部实体
        /// </summary>
        /// <returns></returns>
       IList<T> LoadAll();

       /// <summary>
       /// 按条件排序得到前N条记录
       /// </summary>
       /// <param name="top">获取条数</param>
       /// <param name="field">排序字段</param>
       /// <param order="field">排序方式，升序asc,降序desc</param>
       /// <returns></returns>
       IList<T> QueryTop(int top, string field, string order);

        /// <summary>
        /// 依据条件得到实体
        /// </summary>
        /// <param name="sqlWhere">查询条件</param>
        /// <returns></returns>
        IList<T> Where(string sqlWhere);

        /// <summary>
        /// 得到统计数量
        /// </summary>
        /// <param name="strWhere">查询条件</param>
        /// <returns></returns>
        int GetRecordCount(string strWhere);

        /// <summary>
        /// 分页获取数据列表
        /// </summary>
        /// <param name="PageSize">每页获取数据条数</param>
        /// <param name="PageIndex">当前页是第几页</param>
        /// <param name="strWhere">查询条件</param>
        /// <returns></returns>
        IList<T> GetPageList(int PageSize, int PageIndex, string strWhere);

        /// <summary>
        /// 依据数据字典父编码和编码获取名称
        /// </summary>
        /// <param name="parentNumber">父编码</param>
        /// <param name="number">编码</param>
        /// <returns></returns>
        string GetName(string parentNumber, string number);

        /// <summary>
        /// 获取该父编码下最大编码
        /// </summary>
        /// <param name="parentNumber">父编码</param>
        /// <returns></returns>
        int GetMaxNumber(string parentNumber);
    }
}

  3.定义好了父接口，以下定义子接口，还是以IT_RoleDAO为例。代码例如以下：

using System;
using Model;

namespace IDAO
{
    public interface IT_RoleDAO : IDAO<T_Role>
    {
    }
}

  这样。IT_RoleDAO就拥有了IDAO定义了的方法，假设IT_RoleDAO有特殊方法。直接加入在IT_RoleDAO里面就可以。以IT_AreaDAO为例，代码例如以下：

using System;
using Model;

namespace IDAO
{
    public interface IT_AreaDAO : IDAO<T_Area>
    {
        /// <summary>
        /// 获取
        /// </summary>
        /// <param name="parentNumber"></param>
        /// <returns></returns>
        int GenerateAreaNumber(string parentNumber);
    }
}

  最后，我们看一下IDAO层的文件文件夹：

二、NHibernate数据库訪问实现层NHibernateDAO（核心）

  1. 在解决方式上右键新建一个类库。命名为NHibernateDAO，用来存放Nhibernae数据库訪问实现层代码，并加入引用上一节所讲的实体层Model和接口层IDAO；

  2. 右键点击引用，选择“管理NuGet程序包”，选择“联机”，搜索“Spring.NET”,在搜索结果中选择“Spring.Net NHibernate 4 support”安装。该安装包含了一个NHibernate，可是还不够，相同的方法搜索NHibernate，并安装，加入Nhibernate就不上图了。加入Spring.NET的界面图例如以下：

  3.加入数据库訪问层父类NHibernateDAO。NHibernateDAO类中的SessionFactory属性的GetCurrentSession方法能够实例化ISession，实例化ISession后的对象能够调用NHibernate下的数据库操作方法。详细他们之间怎么实例化，先上代码。后面再来解释。

  NHibernateDAO代码例如以下，继承INHibernateSessionFactory和实现IDAO父接口：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Model;
using IDAO;
using NHibernate;
using NHibernate.Criterion;
using NHibernate.Linq;
using Spring.Data.NHibernate.Support;
using NHibernate.Cfg;
using System.Text;

namespace NHibernateDAO
{
    [Spring.Stereotype.Repository]
    public class NHibernateDAO<T> : IDAO<T>
    {
        public ISessionFactory SessionFactory { get; set; }
        /// <summary>
        /// 获取Session
        /// </summary>
        public ISession Session
        {
            get
            {
                return SessionFactory.GetCurrentSession();
            }
        }

        /// <summary>
        /// 当前实体相应的表名
        /// </summary>
        public string TableName
        {
            get { return typeof(T).ToString().Substring(typeof(T).ToString().LastIndexOf('.') + 1); }
        }
        /// <summary>
        /// 加入实体
        /// </summary>
        /// <param name="entity"></param>
        public int Add(T entity)
        {
                using (ITransaction transaction = Session.BeginTransaction())
                {
                    try
                    {
                        int id = (int)Session.Save(entity);
                        Session.Flush();
                        transaction.Commit();
                        return id;
                    }
                    catch (HibernateException)
                    {
                        transaction.Rollback();
                        throw;
                    }
            }
        }

        /// <summary>
        /// 改动实体
        /// </summary>
        /// <param name="entity"></param>
        public void Update(T entity)
        {
                using (ITransaction transaction = Session.BeginTransaction())
                {
                    try
                    {
                        Session.Update(entity);
                        Session.Flush();
                        transaction.Commit();
                    }
                    catch (HibernateException)
                    {
                        transaction.Rollback();
                        throw;
                    }
            }
        }
        /// <summary>
        /// 保存或改动实体
        /// </summary>
        /// <param name="customer"></param>
        public void SaveOrUpdate(IList<T> list)
        {
                using (ITransaction transaction = Session.BeginTransaction())
                {
                    try
                    {
                        foreach (var entity in list)
                        {
                            Session.SaveOrUpdate(entity);
                        }
                        Session.Flush();
                        transaction.Commit();
                    }
                    catch (HibernateException)
                    {
                        transaction.Rollback();
                        throw;
                    }
            }
        }

        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="entity"></param>
        public void Delete(T entity)
        {
                using (ITransaction transaction = Session.BeginTransaction())
                {
                    try
                    {
                        Session.Delete(entity);
                        Session.Flush();
                        transaction.Commit();
                    }
                    catch (HibernateException)
                    {
                        transaction.Rollback();
                        throw;
                    }
                }
        }

        /// <summary>
        /// 按条件删除
        /// </summary>
        /// <param name="sqlWhere">删除条件</param>
        public void Delete(string sqlWhere)
        {
                using (ITransaction transaction = Session.BeginTransaction())
                {
                    try
                    {
                        Session.Delete(string.Format("from {0} Where {1}", TableName, sqlWhere));
                        Session.Flush();
                        transaction.Commit();
                    }
                    catch (HibernateException)
                    {
                        transaction.Rollback();
                        throw;
                    }
            }
        }

        /// <summary>
        /// 依据ID得到实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Get(int id)
        {
            return Session.Get<T>(id);
        }
        /// <summary>
        /// 依据ID得到实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Load(int id)
        {
            return Session.Load<T>(id);
        }
        /// <summary>
        /// 得到全部实体
        /// </summary>
        /// <returns></returns>
        public IList<T> LoadAll()
        {
            return Session.Query<T>().ToList();
        }

        /// <summary>
        /// 按条件排序得到前N条记录
        /// </summary>
        /// <param name="top">获取条数</param>
        /// <param name="field">排序字段</param>
        /// <param order="field">排序方式。升序asc,降序desc</param>
        /// <returns></returns>
        public IList<T> QueryTop(int top, string field, string order)
        {
            if (order == "asc")
            {
                return Session.CreateCriteria(typeof(T)).SetMaxResults(top).AddOrder(Order.Asc(field)).List<T>();
            }
            else
            {
                return Session.CreateCriteria(typeof(T)).SetMaxResults(top).AddOrder(Order.Desc(field)).List<T>();
            }
        }

        /// <summary>
        /// 依据条件得到实体
        /// </summary>
        /// <param name="sqlWhere">查询条件</param>
        /// <returns></returns>
        public IList<T> Where(string sqlWhere)
        {
            StringBuilder strSql = new StringBuilder(string.Format("from {0} c", TableName));
            if (!string.IsNullOrEmpty(sqlWhere))
            {
                strSql.Append(string.Format(" where {0}", sqlWhere));
            }
            return Session.CreateQuery(strSql.ToString()).List<T>();
        }

        /// <summary>
        /// 得到统计数量
        /// </summary>
        /// <param name="strWhere">查询条件</param>
        /// <returns></returns>
        public int GetRecordCount(string sqlWhere)
        {
            StringBuilder strSql = new StringBuilder(string.Format("select count(1) from {0} c", TableName));
            if (!string.IsNullOrEmpty(sqlWhere))
            {
                strSql.Append(string.Format(" where {0}", sqlWhere));
            }
            return (int)Session.CreateSQLQuery(strSql.ToString()).UniqueResult();
        }

        /// <summary>
        /// 分页获取数据列表
        /// </summary>
        /// <param name="PageSize">每页获取数据条数</param>
        /// <param name="PageIndex">当前页是第几页</param>
        /// <param name="strWhere">查询条件</param>
        /// <returns></returns>
        public IList<T> GetPageList(int PageSize, int PageIndex, string sqlWhere)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append(string.Format("select top {0} * from {1} where ID not in(select top  ", PageSize,
                TableName));
            strSql.Append(PageSize * (PageIndex - 1));
            strSql.Append(string.Format(" ID from {0}", TableName));
            if (!string.IsNullOrEmpty(sqlWhere))
            {
                strSql.Append(string.Format(" where {0} ) and {0}", sqlWhere));
            }
            else
            {
                strSql.Append(")");
            }
            return Session.CreateSQLQuery(strSql.ToString()).AddEntity(typeof(T)).List<T>();
        }

        /// <summary>
        /// 依据数据字典父编码和编码获取名称
        /// </summary>
        /// <param name="parentNumber">父编码</param>
        /// <param name="number">编码</param>
        /// <returns></returns>
        public string GetName(string parentNumber, string number)
        {
            string[] num = number.Split(',');
            List<string> list = new List<string>();
            list.AddRange(num);
            IQueryable<string> name = from q in Session.Query<T_Dictionary>()
                                      where q.ParentNumber == parentNumber && list.Contains(q.Number)   orderby q.Number
                                      select q.Name;
            string nameStr = "";
            foreach (string n in name)
            {
                nameStr += n + ",";
            }
            return nameStr.Contains(",") ? nameStr.Substring(0, nameStr.Length - 1) : nameStr;
        }

        /// <summary>
        /// 获取该父编码下最大编码
        /// </summary>
        /// <param name="parentNumber">父编码</param>
        /// <returns></returns>
        public int GetMaxNumber(string parentNumber)
        {
            string strSql =
                string.Format(
                    "select case when MAX(cast(substring(Number,len(Number)-3,4) as int)) is null then 0 else MAX(cast(substring(Number,len(Number)-3,4) as int)) end  from {0} where ParentNumber='{1}'",
                    TableName, parentNumber);
            return ++Session.CreateQuery(strSql).List<int>()[0];
        }

    }
}

  4. 加入一个数据库訪问层实现类，以T_RoleDAO为例：

using System;
using System.Collections;
using IDAO;
using Model;

namespace NHibernateDAO
{
    public class T_RoleDAO : NHibernateDAO<T_Role>, IT_RoleDAO
    {
        
    }
}

  相同滴。继承NHibernateDAO并实现IT_RoleDAO接口。他便拥有了他们定义好的方法。假设有特殊方法代码例如以下：

using System;
using System.Collections;
using Model;
using IDAO;
using System.Text;
using System.Collections.Generic;

using NHibernate;

namespace NHibernateDAO
{
    public class T_AreaDAO : NHibernateDAO<T_Area>,IT_AreaDAO
    {
        public int GenerateAreaNumber(string parentNumber)
        {
            string sqlStr = string.Format(@"select case when MAX(cast(Number as int)) is null  then 0
		                    else MAX(cast(Number as int)) end
                            from {0}
                            where ParentNumber={1}", TableName, parentNumber);
            return ++Session.CreateQuery(sqlStr).List<int>()[0];
        }
    }
}

  5. 以下，就来解释一下他们都是怎么实例化的。

这里就用到Spring.NET依赖注入的方式实现，先看配置文件。在NHibernateDAO类库下加入目录Config，用来存放配置文件，然后加入一个命名为objects.xml的xml。这里必须定义每个数据库訪问层对象，不能说他们都继承NHibernateDAO，仅仅定义NHibernateDAO，这种话会报错，由于后面BLL层要调用DAO层，他们之间是一一相应的。这里先简单提一下，后面讲到就明确了。代码例如以下：

<?
xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net">
  
  <!--T_AreaDAO,管理T_Area的对象-->
  <object id="T_AreaDAO" type="NHibernateDAO.T_AreaDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_AssessmentCoefficientDAO,管理T_AssessmentCoefficient的对象-->
  <object id="T_AssessmentCoefficientDAO" type="NHibernateDAO.T_AssessmentCoefficientDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_AuthorityDAO,管理T_Authority的对象-->
  <object id="T_AuthorityDAO" type="NHibernateDAO.T_AuthorityDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_ClientDAO,管理T_Client的对象-->
  <object id="T_ClientDAO" type="NHibernateDAO.T_ClientDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_DictionaryDAO,管理T_Dictionary的对象-->
  <object id="T_DictionaryDAO" type="NHibernateDAO.T_DictionaryDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_DrugDAO,管理T_Drug的对象-->
  <object id="T_DrugDAO" type="NHibernateDAO.T_DrugDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_InvoicingCollectDetailDAO,管理T_InvoicingCollectDetail的对象-->
  <object id="T_InvoicingCollectDetailDAO" type="NHibernateDAO.T_InvoicingCollectDetailDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_InvoicingDetailDAO,管理T_InvoicingDetail的对象-->
  <object id="T_InvoicingDetailDAO" type="NHibernateDAO.T_InvoicingDetailDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_LogDAO,管理T_Log的对象-->
  <object id="T_LogDAO" type="NHibernateDAO.T_LogDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_MenuDAO,管理T_Menu的对象-->
  <object id="T_MenuDAO" type="NHibernateDAO.T_MenuDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_OpHistoryDAO,管理T_OpHistory的对象-->
  <object id="T_OpHistoryDAO" type="NHibernateDAO.T_OpHistoryDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_RoleDAO,管理T_Role的对象-->
  <object id="T_RoleDAO" type="NHibernateDAO.T_RoleDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--T_UserDAO,管理T_User的对象-->
  <object id="T_UserDAO" type="NHibernateDAO.T_UserDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--V_InvoicingCollectDetailDAO,管理V_InvoicingCollectDetail的对象-->
  <object id="V_InvoicingCollectDetailDAO" type="NHibernateDAO.V_InvoicingCollectDetailDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--V_InvoicingDetailDAO,管理V_InvoicingDetail的对象-->
  <object id="V_InvoicingDetailDAO" type="NHibernateDAO.V_InvoicingDetailDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--V_TrackDAO,管理V_Track的对象-->
  <object id="V_TrackDAO" type="NHibernateDAO.V_TrackDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>

  <!--V_CoverageRateDAO,管理V_CoverageRate的对象-->
  <object id="V_CoverageRateDAO" type="NHibernateDAO.V_CoverageRateDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>
  
  <!--V_AssessDAO,管理V_Assess的对象-->
  <object id="V_AssessDAO" type="NHibernateDAO.V_AssessDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>
  
  <!--T_BuyDetailDAO,管理T_BuyDetail的对象-->
  <object id="T_BuyDetailDAO" type="NHibernateDAO.T_BuyDetailDAO,NHibernateDAO">
    <property name="SessionFactory" ref="NHibernateSessionFactory"/>
  </object>
  
</objects>

  格式如上述代码，先定义一个objects根节点，然后再objects中定义每个数据库訪层，type指定“命名空间.类名,命名空间”，property指定属性，name必须与NHibernateDAO中的SessionFactory同样，因为每个数据库訪问层都继承了NHibernateDAO，全部他们就拥有了NHibernateDAO的属性SessionFactory，ref指定SessionFactory实例化的对象，NHibernateSessionFactory是NHibernate框架封装的数据库訪问类。所以，我们看到我们没有在代码中实实例化SessionFactory。仅仅是定义了一个属性，而是通过Spring.NET的配置文件来把SessionFactory实例化的，这就是所谓的依赖注入，也交控制反转。

  6. 细心的撸友能够发现了，数据库操作的类和方法我们定义好了，可是数据訪问的连接字符串还没有，以下就来配置数据库訪问文件。相同在NHibernateDAO的Config中加入DataAccess.xml，代码例如以下：

<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net"
         xmlns:db="http://www.springframework.net/database"
         xmlns:tx="http://www.springframework.net/tx"
         >
  <!--描写叙述-->
  <description>
    数据訪问的配置信息
    包括：DbProvider
    NHibernate
  </description>

  <!-- 通过主应用程序的上下文配置文件引用 -->
  <object type="Spring.Objects.Factory.Config.PropertyPlaceholderConfigurer, Spring.Core">
    <property name="ConfigSections" value="spring/databaseSettings"/>
  </object>

  <!-- 数据库的配置 -->
  <db:provider id="DbProvider"
                   provider="SqlServer-2.0"
                   connectionString="Data Source=${db.server};Database=${db.database};User ID=${db.userid} ;PassWord=${db.password}"
               />

  <!-- NHibernate 配置 -->

  <!-- 能够通过 name 为其指定别名 name="SessionFactory" -->
  <object id="NHibernateSessionFactory"
          type="Spring.Data.NHibernate.LocalSessionFactoryObject,Spring.Data.NHibernate4"
          >

    <!-- 关于数据库连接的配置，直接使用 DbProvider 中的设置，这样，不须要为 Hibernate 再提供连接串和驱动 -->
    <property name="DbProvider" ref="DbProvider"/>

    <!-- 包括有映射文件的程序集，须要分析的hbm程序集名称 -->
    <property name="MappingAssemblies">
      <list>
        <value>Model</value>
      </list>
    </property>

    <!-- 其它的參数 -->
    <property name="HibernateProperties">
      <dictionary>
        <!-- 方言 -->
        <entry key="dialect" value="NHibernate.Dialect.MsSql2008Dialect"/>
        <entry key="use_proxy_validator" value="false" />
        <entry key="show_sql" value="true"/>

      </dictionary>
    </property>

    <!-- 必须添加此项说明，与 Spring 的声明式事务集成 -->
    <property name="ExposeTransactionAwareSessionFactory" value="true" />

  </object>

</objects>

  当中connectionString="Data Source=${db.server};Database=${db.database};User ID=${db.userid} ;PassWord=${db.password}中，我并没有明白指定他们訪问地址、数据库等。

这是一种类似定义一个变量的方式指定他们的訪问地址、数据库等信息的，详细变量的值是什么，会在后面web层的config配置文件里定义，按这个格式写即可。先不用纠结。

这样也方便维护。

  最后，还是看一下NHibernateDAO层的文件夹结构：