Nhibernate的第一个实例

第一个NhIbernate程序

1、目的：

a) 链接到oracle数据库

b) 增删改

c) 基本查询、sql查询

d) 视图查询

e) 使用存储过程

f) 多表查询、级联查询

g) 级联增删改

2、后续目的

a) 加载机制——立即加载or延迟加载

b) 并发控制

c) 缓存——一级缓存，二级缓存

接下来我会一一完成上面的目的，以便对Hhibernate有更多的了解，写希望各位能多多的指正。

3、第一个项目

a) 下载

Nhibernate最新版本为4.0.1.GA，下载地址：http://nhforge.org/

下载内容如下图

其中  Configuration_Templates中放的是各个数据库连接的配置文件样本模板，基本上包含了主流的数据库

B) 创建项目

根据三层架构把项目分为三层：

第一层： Model层——主要存放数据实体与映射文件

第二层： DAL层——存放数据库的操作方法

第三层： Facade层——业务逻辑层，主要实现与页面的业务逻辑

第四层： View层——页面层，包含接口、web

第五层：Common层——公共类层，主要存储一些共有的操作类

由于分五层为个人习惯问题，有不习惯的园友可以分三层：去掉第三层与第五层。

分布图如下

C) 引用DLL文件 （这里介绍主要的几个引用，其他的话，可以根据我放出的实例来看）

Model层： 需要引入Required_Bins 文件夹中的Iesi.Collections.dll，NHibernate.dll；

DAL层 ：  需要引入Required_Bins 文件夹中的Iesi.Collections.dll，NHibernate.dll和Model层；

Facade层：需要引入Model层与DAL层；

View层：  需要引入Required_Bins 文件夹中的Iesi.Collections.dll，NHibernate.dll，log4net.dll和Model层与Facade层；

其实还有另一种方法可以添加引用，就是通过NuGet进行引用，这种方法我在这里就不介绍了。

D) 创建数据库

先在oracle数据库中创建一张表，如图

该表没有任何外键关联，也没其他表的ID字段。

E)创建model层中的持久化类 及 xml映射文件

创建cat的类

创建cat的mapping对应的xml文件

基本文件位置如下

F)修改配置文件

因为连接的是oracle的数据库，所以在下载的文件Configuration_Templates文件夹中找到oracle的配置文件，如图

选择oracle.cfg.xml 文件 放到View层下面 ，并且修改名字。默认的名字是hibernate.cfg.xml，且需要放在bin——debug文件夹下面。大多数情况我们会根据自身的习惯进行一些调整。比如我喜欢放在App_Data文件夹下。

修改配置文件信息

原始的配置文件信息

我修改后的文件信息

G)编写DAL方法与实例

首先  先写一个NhibernateHelper.cs文件

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

 using NHibernate;
 using NHibernate.Linq;
 using NHibernate.Criterion;

 namespace CommonClass
 {
    public class NHibernateHelper
     {
        /// <summary>
         /// Session工厂
         /// </summary>
         private  readonly ISessionFactory SessionFactory;
         /// <summary>
         /// nhibernate.cfg.xml 所在相对路径
         /// </summary>
         private  string xmlString = "App_Data/hibernate.cfg.xml";
         /// <summary>
         /// 构造函数
         /// </summary>
         public NHibernateHelper()
         {
             if (SessionFactory == null)
             {
                 var cfg = new NHibernate.Cfg.Configuration().Configure(xmlString);

                 SessionFactory = cfg.BuildSessionFactory();

             }
         }

        public NHibernateHelper(string path)
         {
             if (SessionFactory == null)
             {
                 var cfg = new NHibernate.Cfg.Configuration().Configure(path);

                 SessionFactory = cfg.BuildSessionFactory();
             }
         }

         /// <summary>
         /// 获取一个Isession
         /// </summary>
         /// <returns></returns>
         public ISession GetSession()
         {
             return SessionFactory.OpenSession();
         }
         /// <summary>
         /// 关闭一个Isession
         /// </summary>
         /// <param name="session"></param>
         public void CloseSeeion(ISession session)
         {
             session.Close();
         }

         /// <summary>
         /// 关闭一个Isessionfactory
         /// </summary>
         public void CloseSessionFactory()
         {
             SessionFactory.Close();
         }
     }
 }

再编写CATDAL.cs  用来操作数据库的方法

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

using NHibernate;
using NHibernate.Linq;
using NHibernate.Criterion;

using ModelEntityClass.Model;
using CommonClass;

namespace DALClass
{
    public class CATDAL
    {
        private  NHibernateHelper HB_Helper = null;
        public CATDAL()
        {
            HB_Helper = new NHibernateHelper();
        }
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entitys"></param>
        /// <returns></returns>
        public bool InsertAll(List<CAT> entitys)
        {
            bool flag = false;
            ISession session = HB_Helper.GetSession();
            using (ITransaction tt = session.BeginTransaction())
            {
                try
                {
                    foreach (CAT entity in entitys)
                    {
                        session.Save(entity);
                    }
                    session.Flush();
                    tt.Commit();
                    flag = true;
                }
                catch (HibernateException ex)
                {
                    tt.Rollback();
                }
            }

            HB_Helper.CloseSeeion(session);
            return flag;
        }
        /// <summary>
        /// 根据ID进行查找
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public CAT Find(string id)
        {
            ISession session = HB_Helper.GetSession();
            CAT cat = null;
            using (ITransaction tt = session.BeginTransaction())
            {
                try
                {
                    cat = session.Query<CAT>().Where(p => p.ID == id).FirstOrDefault();
                }
                catch (HibernateException ex)
                {
                    tt.Rollback();
                }
            }

            HB_Helper.CloseSeeion(session);
            return cat;
        }
        /// <summary>
        /// 查询所有
        /// </summary>
        /// <returns></returns>
        public List<CAT> FindAll()
        {
            ISession session = HB_Helper.GetSession();
            //ICriteria criteria = session.CreateCriteria(typeof(CAT));
            List<CAT> catList = null;
            using (ITransaction tt = session.BeginTransaction())
            {
                try
                {
                    catList = session.Query<CAT>().ToList();
                }
                catch (HibernateException ex)
                {
                    tt.Rollback();
                }
            }

            HB_Helper.CloseSeeion(session);
            return catList;
        }

        /// <summary>
        /// 删除所有
        /// </summary>
        /// <param name="entitys"></param>
        /// <returns></returns>
        public bool DeleteAll(List<CAT> entitys)
        {

            bool flag = false;
            ISession session = HB_Helper.GetSession();
            using (ITransaction tt = session.BeginTransaction())
            {
                try
                {
                    foreach (CAT entity in entitys)
                    {
                        session.Delete(entity);
                    }
                    session.Flush();
                    tt.Commit();
                    flag = true;
                }
                catch (HibernateException ex)
                {
                    tt.Rollback();
                }
            }

            HB_Helper.CloseSeeion(session);
            return flag;

        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool Delete(CAT entity)
        {

            bool flag = false;
            ISession session = HB_Helper.GetSession();
            using (ITransaction tt = session.BeginTransaction())
            {
                try
                {
                    session.Delete(entity);

                    session.Flush();
                    tt.Commit();
                    flag = true;
                }
                catch (HibernateException ex)
                {
                    tt.Rollback();
                }
            }

            HB_Helper.CloseSeeion(session);
            return flag;

        }

        /// <summary>
        /// 保存和添加
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool SaveAndUpdate(List<CAT> entitys)
        {
            bool flag = false;
            ISession session = HB_Helper.GetSession();
            using (ITransaction tt = session.BeginTransaction())
            {
                try
                {
                    foreach (CAT entity in entitys)
                    {
                        session.SaveOrUpdate(entity);
                    }
                    session.Flush();
                    tt.Commit();
                    flag = true;
                }
                catch (HibernateException ex)
                {
                    tt.Rollback();
                }
            }

            HB_Helper.CloseSeeion(session);
            return flag;
        }
    }
}

接下来编辑业务逻辑层的类，由于它是对应ConsoleApplication1项目的这个业务，我把他命名成ConsoleFacade（里面只有一个方法，后面可以根据需要进行添加）

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

using ModelEntityClass.Model;
using DALClass;

namespace FacadeClass
{
   public  class ConsoleFacade
    {

       public bool InsertAll(List<CAT> entitys)
       {
           CATDAL dal = new CATDAL();
           return dal.InsertAll(entitys);
       }
    }
}

现在我们进行测试

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

using ModelEntityClass.Model;
using FacadeClass;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            CAT cat = new CAT();

            cat.ID = Guid.NewGuid().ToString();

            cat.NAME = "芝麻";
            cat.SHORTNAME = "小婊砸";
            cat.CREATDATA = DateTime.Now;
            cat.ADDRESS = "北京市不知道什么的地方";
            cat.AGE = ;
            cat.CODE = "M0001";

            List<CAT> InsertList = new List<CAT> ();
            InsertList.Add(cat);

            ConsoleFacade facade = new ConsoleFacade();
           if(  facade.InsertAll(InsertList))
           {
               Console.WriteLine("添加成功");
           }else
           {
               Console.WriteLine("添加失败");
           }

           Console.ReadKey();
        }
    }
}

测试页面如下

这样我们一个简单的Nhibernate实例就完成了。

项目实例下载