Nhibernate的第一个实例

2022-09-18 09:47:44

第一个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实例就完成了。

项目实例下载

码农公寓

相关文章