ADO.NET与ORM的比较:NHibernate实现CRUD(转)

2022-07-12 08:58:38

原文地址

http://blog.csdn.net/zhoufoxcn/article/details/5402511

 

说明：个人感觉在Java领域大型开发都离不了ORM的身影，所谓的SSH就是Spring+Struts+Hibernate，除了在学习基础知识的时候被告知可以使用JDBC操作数据库之外，大量的书籍中都是讲述使用Hibernate这个ORM工具来操作数据。在.NET中操作数据库的方式有多种，除了最直接的方式就是使用ADO.NET之外，还可以使用NHibernate这个Hibernate在.NET中的实现ORM，如果你对第三方的ORM持怀疑态度，你还可以使用来自微软的实现、根正苗红的Linq或者EntityFramework。
大部分从早期就开始使用.NET开发的程序员可能对ADO.NET有种迷恋，使用ADO.NET可以充分将我们早期的SQL知识发挥得淋漓尽致，并且出于对性能的考虑，有些人对.NET中的ORM还保持一种观望态度，包括我自己也是这种态度。不过即使在实际开发中不用，并不代表我们不能去了解和比较这些技术，任何事物的出现和消亡总有其原因的，我们可以了解它们的优点和长处。所以本人抽出了几个周末的时间分别用ADO.NET、NHibernate、Linq和EntityFramework来实现对数据库单表数据的创建、读取、更新和删除操作，也就是所谓的CRUD（C:Create/R:Read/U:Update/D:Delete）。
通过实现相同功能的比较，大家自己判断那种方式更适合自己。需要说明的是，如果在VS2008中使用EntityFramework就需要安装VS2008SP1。
在本篇周公将讲述如何利用NHibernate实现CRUD功能，为了便于对比，在本次中采用与上次同样的数据库和表，并且也实现同样的功能。NHibernate是一个ORM框架，所谓ORM就是Object Relational Mapping，是一种将关系型数据库中的数据与面向对象语言中对象建立映射关联的技术，我们可以想操作对象一样操作数据，NHibernate将我们对对象的变更保存到数据库中去，并且还负责以对象的方式从数据库中查询数据，这样就可以使开发人员从处理SQL和ADO.NET上节省一些时间和精力用于处理业务逻辑。
1、准备
首先我们需要从网上下载NHibernate框架，这个可以到它的官方网站www.nhibernate.org上去下载，在周公写这篇文章的时候从网上能下载到的最新版本为2.1.2.GA。如果下载的是压缩包，请将压缩包解压，将会看到四分文件夹，它们的名称和作用分别如下：
Configuration_Templates：存放NHibernate连接数据库的配置文件的示例，在这个文件夹下分别有连接Firebird、SQL Server、MySQL、Oracle、PostgreSQL和SQLite数据库的配置示例，可以根据实际所使用的数据库选择示例中的代码并更改其中的数据源即可。
Required_Bins：存放NHibernate运行过程中所需要的类库文件，其中还包含了第三方的开源日志框架Log4Net，在不确定到底会使用那些类库的条件下建议将这个文件夹下所有的dll文件拷贝到项目的bin文件夹下。
Required_For_LazyLoading：存放延时加载特性支持所需的框架文件，在这个文件夹下提供了三种实现，选择一种将其下所有的dll文件拷贝到项目所在的bin文件夹下。在本示例中选择了Castle。
Tests：存放测试用文件，在此文件夹下还有一个名为ABC.hbm.xml的文件，这是一个数据表对应的配置文件的示例，在这个文件夹下的文件我们都用不着，不过在以后我们会用到.hbm.xml文件。
2、创建项目
我们创建一个项目，项目类型可以根据情况选择，因为我今后要使用NUnit来对项目进行单元测试，所以创建的类库项目。
创建项目成功之后将如下文件拷贝到项目的bin目录下：
Antlr3.Runtime.dll
Castle.Core.dll
Castle.DynamicProxy2.dll
Iesi.Collections.dll
log4net.dll
NHibernate.ByteCode.Castle.dll
NHibernate.dll
然后在项目中添加对这些dll的引用，如下图所示：
ADO.NET与ORM的比较:NHibernate实现CRUD(转) 
3、编写代码
3.1创建NHibernate配置文件
NHibernate的配置文件有相对比较固定的格式，这个可以从下载到框架文件压缩包解压得到，位于Configuration_Templates文件夹下。
向当前项目添加一个名为hibernate.cfg.xml的xml文件，在周公的机器上这个文件的格式内容如下：

[xhtml] view plaincopy
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <hibernate-configuration  xmlns="urn:nhibernate-configuration-2.2" >  
  3.  <session-factory>  
  4.   <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>  
  5.   <property name="connection.connection_string">  
  6.    Data Source=zhou;Initial Catalog=AspNetStudy;User ID=sa;Password=jerry;  
  7.   </property>  
  8.   <property name="adonet.batch_size">10</property>  
  9.   <property name="show_sql">true</property>  
  10.   <property name="dialect">NHibernate.Dialect.MsSql2005Dialect</property>  
  11.   <property name="use_outer_join">true</property>  
  12.   <property name="command_timeout">10</property>  
  13.   <property name="query.substitutions">true 1, false 0, yes ‘Y‘, no ‘N‘</property>  
  14.   <property name="proxyfactory.factory_class">  
  15.    NHibernate.ByteCode.Castle.ProxyFactoryFactory,  
  16.    NHibernate.ByteCode.Castle  
  17.   </property>  
  18.   <mapping assembly="NHibernateDemo"/>  
  19.  </session-factory>  
  20. </hibernate-configuration>  

 

如果你也是使用SQL Server2005作为数据库的话，那么需要更改connection.connection_string中的数据库连接信息为你本机的连接信息，并且实际情况更改assembly的值为你当前项目编译后的程序集名称。
在这里还需要注意的是需要将hibernate.cfg.xml的属性更改为复制属性改为始终复制，如下图所示：
ADO.NET与ORM的比较:NHibernate实现CRUD(转) 
3.2创建映射文件
映射文件包含了对象/关系所需要的元数据，其中包含了所使用的持久化类和到数据库的映射。NHibernate就是通过映射文件知道怎样加载和存储持久化对象。
在项目中增加一个名为UserInfo.hbm.xml的xml文件，这个xml文件的内容如下：

[xhtml] view plaincopy
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="NHibernateDemo" namespace="NHibernateDemo">  
  3.  <class name="UserInfo">  
  4.   <id name="UserId" column="UserId">  
  5.    <generator class="native"/>  
  6.   </id>  
  7.   <property name="UserName"/>  
  8.   <property name="RealName"/>  
  9.   <property name="Age"/>  
  10.   <property name="Sex"/>  
  11.   <property name="Mobile"/>  
  12.   <property name="Phone"/>  
  13.   <property name="Email"/>  
  14.  </class>  
  15. </hibernate-mapping>  


注意：如果想要获得在编辑hibernate.cfg.xml或者UserInfo.hbm.xml时的智能提示，可以将下载NHibernate压缩包中的nhibernate-configuration.xsd和nhibernate-mapping.xsd文件拷贝到VS的一个特殊文件夹中，在本机上周公在C盘安装了VS2008，那么需要将上面提到的文件拷贝到C:/Program Files/Microsoft Visual Studio 9.0/Xml/Schemas目录下，你需要根据你的实际情况来拷贝。
需要更改这个文件的属性，改为“嵌入的资源”，如下图所示：
 
3.3创建持久化类
在当前项目中创建一个名为UserInfo.cs的类文件，这个类的代码如下：

 

 

[c-sharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4.   
  5. namespace NHibernateDemo  
  6. {  
  7.     /// <summary>  
  8.     /// 数据库中UserInfo表的持久化类  
  9.     /// 作者：周公  
  10.     /// 博客地址：http://blog.csdn.net/zhoufoxcn  
  11.     /// 日期：2010-03-19  
  12.     /// </summary>  
  13.     public class UserInfo  
  14.     {  
  15.         public virtual int UserId { get; set; }  
  16.         public virtual string UserName { get; set; }  
  17.         public virtual string RealName { get; set; }  
  18.         public virtual int Age { get; set; }  
  19.         public virtual bool Sex { get; set; }  
  20.         public virtual string Mobile { get; set; }  
  21.         public virtual string Phone { get; set; }  
  22.         public virtual string Email { get; set; }  
  23.     }  
  24. }  


注意：NHibernate通过使用属性的getter和setter操作来实现对象的持久化，并且要求类不能为sealed，方法和属性必须为virtual。
3.4编写辅助类
通过上面的文件NHibernate就可以实现关系映射了，这里编写相关的辅助类代码，如下：

[c-sharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using Iesi.Collections;  
  5. using NHibernate;  
  6. using NHibernate.Cfg;  
  7.   
  8. namespace NHibernateDemo  
  9. {  
  10.     /// <summary>  
  11.     /// 说明：这个类是为了演示NHibernate中的CRUD的用法  
  12.     /// 作者：周公（周金桥）  
  13.     /// 日期：2010-03-07  
  14.     /// </summary>  
  15.     public class NHibernateCRUD  
  16.     {  
  17.         private ISessionFactory sessionFactory;  
  18.         public NHibernateCRUD()  
  19.         {  
  20.             sessionFactory = new Configuration().Configure().BuildSessionFactory();  
  21.         }  
  22.   
  23.         public ISession GetSession()  
  24.         {  
  25.             return sessionFactory.OpenSession();  
  26.         }  
  27.         /// <summary>  
  28.         /// 统计用户总数  
  29.         /// </summary>  
  30.         /// <returns></returns>  
  31.         public int Count()  
  32.         {  
  33.             #region 方法一  
  34.             //ISession session = GetSession();  
  35.             //ISQLQuery query = session.CreateSQLQuery("select count(1) from UserInfo");  
  36.             //int count = query.List<int>()[0];  
  37.             //session.Close();  
  38.             //return count;  
  39.             #endregion  
  40.  
  41.             #region 方法二  
  42.             ISession session = GetSession();  
  43.             IQuery query = session.CreateQuery("select count(c.UserId) from UserInfo c");  
  44.             //注意：不能对于count函数不能使用query.List<int>()，因为默认返回的数值类型是long  
  45.             //否则会抛出GenericADOException，异常描述是：Could not execute query[SQL: SQL not available]  
  46.             //InnerException: System.ArgumentException，InnerException描述是："值“*”不是“System.Int32”类型，不能在此泛型集合中使用。/r/n参数名: value  
  47.             int count =(int)(query.List<long>()[0]);  
  48.             session.Close();  
  49.             return count;  
  50.             #endregion  
  51.         }  
  52.         /// <summary>  
  53.         /// 创建用户  
  54.         /// </summary>  
  55.         /// <param name="info">用户实体</param>  
  56.         /// <returns></returns>  
  57.         public int Create(UserInfo info)  
  58.         {  
  59.             ISession session = GetSession();  
  60.             int newId=(int)(session.Save(info));  
  61.             session.Flush();  
  62.             session.Close();  
  63.             return newId;  
  64.         }  
  65.         /// <summary>  
  66.         /// 读取用户信息  
  67.         /// </summary>  
  68.         /// <param name="userId">用户编号</param>  
  69.         /// <returns></returns>  
  70.         public UserInfo Read(int userId)  
  71.         {  
  72.             ISession session = GetSession();  
  73.             UserInfo info=session.Get<UserInfo>(userId);  
  74.             session.Close();  
  75.             return info;  
  76.         }  
  77.         /// <summary>  
  78.         /// 更新用户信息  
  79.         /// </summary>  
  80.         /// <param name="info">用户实体</param>  
  81.         /// <returns></returns>  
  82.         public void Update(UserInfo info)  
  83.         {  
  84.             ISession session = GetSession();  
  85.             session.Update(info);  
  86.             session.Flush();  
  87.             session.Close();  
  88.         }  
  89.         /// <summary>  
  90.         /// 删除用户  
  91.         /// </summary>  
  92.         /// <param name="userId">用户编号</param>  
  93.         /// <returns></returns>  
  94.         public void Delete(int userId)  
  95.         {  
  96.             ISession session = GetSession();  
  97.             //在NHibernate中支持直接使用参数值、":"+参数名、?（类似于在Access中使用参数化SQL语句的方式,给参数赋值要按照参数出现的顺序来)等几种方式  
  98.             IQuery query = session.CreateQuery("delete from UserInfo where UserId=:UserId");  
  99.             //如果采用":"+参数名方式使用参数，那么给参数赋值时不需要在参数名前加":"号，如query.SetInt32(":UserId", userId);就会报错  
  100.             query.SetInt32("UserId", userId);  
  101.             int affectedRows = query.ExecuteUpdate();  
  102.             session.Close();  
  103.             //return affectedRows;  
  104.         }  
  105.   
  106.         /// <summary>  
  107.         /// 删除用户  
  108.         /// </summary>  
  109.         /// <param name="userId">用户实体</param>  
  110.         /// <returns></returns>  
  111.         public void Delete(UserInfo info)  
  112.         {  
  113.             ISession session = GetSession();  
  114.             session.Delete(info);  
  115.             session.Flush();  
  116.             session.Close();  
  117.         }  
  118.   
  119.         /// <summary>  
  120.         /// 获取用户表中编号最大的用户  
  121.         /// </summary>  
  122.         /// <returns></returns>  
  123.         public int GetMaxUserId()  
  124.         {  
  125.             ISession session = GetSession();  
  126.             IQuery query=session.CreateQuery("select max(UserId) from UserInfo");  
  127.             int userId=query.List<int>()[0];  
  128.             session.Close();  
  129.             return userId;  
  130.         }  
  131.     }  
  132. }  

 


3.5单元测试代码

 

[c-sharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using NUnit.Framework;  
  6. using NHibernateDemo;  
  7.   
  8. namespace NUnitTest  
  9. {  
  10.     [TestFixture]  
  11.     public class NHibernateTest  
  12.     {  
  13.         private NHibernateCRUD instance = null;  
  14.         [SetUp]  
  15.         public void Initialize()  
  16.         {  
  17.             instance = new NHibernateCRUD();  
  18.         }  
  19.         [Test]  
  20.         /// <summary>  
  21.         /// 统计用户总数  
  22.         /// </summary>  
  23.         /// <returns></returns>  
  24.         public void Count()  
  25.         {  
  26.             Assert.Greater(instance.Count(), 0);  
  27.         }  
  28.         [Test]  
  29.         /// <summary>  
  30.         /// 创建用户  
  31.         /// </summary>  
  32.         /// <param name="info">用户实体</param>  
  33.         /// <returns></returns>  
  34.         public void Create()  
  35.         {  
  36.             UserInfo info = new UserInfo()  
  37.             {  
  38.                 Age = 12,  
  39.                 Email = "zzz@ccav.com",  
  40.                 Mobile = "13812345678",  
  41.                 Phone = "01012345678",  
  42.                 RealName = "测试" + DateTime.Now.Millisecond.ToString(),  
  43.                 Sex = true,  
  44.                 UserName = "zhoufoxcn" + DateTime.Now.Millisecond.ToString()  
  45.             };  
  46.             instance.Create(info);  
  47.         }  
  48.         [Test]  
  49.         /// <summary>  
  50.         /// 读取用户信息  
  51.         /// </summary>  
  52.         /// <param name="userId">用户编号</param>  
  53.         /// <returns></returns>  
  54.         public void Read()  
  55.         {  
  56.             UserInfo info = instance.Read(1);  
  57.             Assert.NotNull(info);  
  58.         }  
  59.         [Test]  
  60.         /// <summary>  
  61.         /// 更新用户信息  
  62.         /// </summary>  
  63.         /// <param name="info">用户实体</param>  
  64.         /// <returns></returns>  
  65.         public void Update()  
  66.         {  
  67.             UserInfo info = instance.Read(1);  
  68.             info.RealName = "测试" + DateTime.Now.Millisecond.ToString();  
  69.             instance.Update(info);  
  70.         }  
  71.         [Test]  
  72.         /// <summary>  
  73.         /// 删除用户  
  74.         /// </summary>  
  75.         /// <param name="userId">用户编号</param>  
  76.         /// <returns></returns>  
  77.         public void DeleteByID()  
  78.         {  
  79.             int userId = instance.GetMaxUserId();  
  80.             instance.Delete(userId);  
  81.         }  
  82.   
  83.         [Test]  
  84.         /// <summary>  
  85.         /// 删除用户  
  86.         /// </summary>  
  87.         /// <param name="userId">用户实体</param>  
  88.         /// <returns></returns>  
  89.         public void Delete()  
  90.         {  
  91.             int userId = instance.GetMaxUserId();  
  92.             UserInfo info = instance.Read(userId);  
  93.             Console.WriteLine("MaxUserId=" + userId);  
  94.             instance.Delete(info);  
  95.         }  
  96.     }  
  97. }  


4.点评
使用ORM的很大的一个好处就是很少或者根本不用编写数据库记录映射到对象的代码，并且在大部分情况下也不用编写SQL代码（取而代之的是HSQL）。在使用ADO.NET时代我经常有这样的体会，因为数据库的变动可能需要更改从显示到数据库访问层的相关代码，并且还需要更改自己编写的从数据库记录转换为对象的代码，而现在仅仅需要更改映射文件和持久化类的代码就可以了，除此之外我们还可以使用面向对象的方式对数据进行操作，大家可以看到在NHibernateCRUD中对数据库进行CRUD的代码比直接使用ADO.NET进行CRUD操的代码要简洁许多，这就是ORM的魅力。
当然使用ORM也会存在一些缺点，毕竟ORM在底层使用的是ADO.NET，对于一个有经验的开发人员来说，可能直接使用ADO.NET的性能比使用NHibernate的效率要高，通过NHibernate的缓存机制多少能在某种程度上缓解这个问题。不过当数据量在千万级左右时这个问题就显得比较突出了，在一些数据量在百万级以下的情况中，合理使用NHibernate是没有什么问题的。

 

ADO.NET与ORM的比较:NHibernate实现CRUD(转),布布扣,bubuko.com

ADO.NET与ORM的比较:NHibernate实现CRUD(转)

上一篇：浅谈 Redis


下一篇：如何快速搭建微服务开发测试环境