NHibernate(一) 转自止于至善

最新推荐文章于 2024-07-27 21:41:27 发布
最新推荐文章于 2024-07-27 21:41:27 发布
阅读量447 收藏
点赞数
文章标签： string class hibernate 测试 null 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jayfushuai/article/details/2106429
版权
本文约定:
 1 . Nhibernate简写为NHB;
 2 . 本文例子的开发平台为win2000pro + sp4, sql server2000, Nhibernate0. 5 ;
 3 . 使用SQL Server自带的罗斯文商贸数据库(Northwind)，是英文版的哦;
 4 . 本文例子是基于测试驱动开发（TDD）的，因此建议使用NUnit和Log4Net 
一 NHB简介
NHB是基于ms.net的O / R Mapping持久框架，它从基于Java的Hibernate项目移植而来。O / R Mapping就是把对象到映射关系数据库的记录，简单的说就是能实现把一个对象存储为数据表中的一条记录和由一条记录创建一个相应的对象，数据表中的数据就是对象的属性。
那么为什么要使用O / R Mapping？它与传统的DataSet / DataTable又有什么不同了？
首先是设计上的不同，当使用O / R Mapping时，更多的是从对象的角度来设计程序，而把数据(对象的属性)存储的细节放在后面, 可以完全采用面向对象(OO)的方式来设计，而在使用DataSet / DataTable时，它只是存放数据的对象，看起来更像一个数据表，不能直观的表达业务概念。 

二 NHB中主要接口的介绍

ISession
ISession是面向用户的主要接口，主要用于对象持久化，数据加载等操作，支持数据库事务，它隐藏了NHB内部复杂的实现细节，ISession由ISessionFactory创建。

ISessionFactory
ISessionFactory是NHB内部的核心类，它维护到持久机制(数据库)的连接并对它们进行管理，同时还会保存所有持久对象的映射信息。
ISessionFactory由Configuration创建，因为创建ISessionFactory的开销非常大（需要加载映射信息），所以这个对象一般使用Singleton（单例）模式。

ITransaction
ITransaction是NHB的事务处理接口，它只是简单的封装了底层的数据库事务。
事务必须由ISession来启动。

ICriteria
ICriteria是Expression(表达式)数据加载接口，Expression是一个关系表达式组合，通过它能产生SQL语句的Where部分, 用户需要通过ISession来间接调用它。

IQuery
IQuery是HQL数据加载接口，HQL(Hibernate Query Language)是NHB专用的面向对象的数据查询语言，它与数据库的SQL有些类似，但功能更强大！同ICriteria一样，也需要通过ISession来间接调用它。

三 持久化操作

 1 . 会话和会话工厂
要进行持久化操作，必须先取得ISession和ISessionFactory，我们用一个Sessions类来封装它们， Sessions类的属性和方法都是静态的，它有一个Factory属性, 用于返回ISessionFactory, 有一个GetSession方法，用于取得一个新的ISession。

测试类代码如下:
[TestFixture]
Public  class  SessionsFixture  {
   Public void SessionsFixture() {
   }
   [Test] // 测试能否取得NHB会话工厂。
   public void FactoryTest() {
      ISessionFactory sf = Sessions.Factory;
      Assert.IsNotNull( sf, “get sessionfactory fail!” );
   }
   [Test] // 测试能否取得NHB会话。
   public void GetSessionTest() {
      ISession s = Sessions.GetSession();
      Assert.IsNotNull( s, “get session fail!” );
   }
}
现在还没写Sessions类，将不能通过编译 !  下面我们来实现Sessions类.

 public   class  Sessions  {
   private static readonly object lockObj = new object();
   private static ISessionFactory _factory;

   public static Sessions() {` }

   Public static ISessionFactory Factory {
      get { 
         if ( _factory == null ) {
            lock ( lockObj ) {
               if ( _factory == null ) {
                  Cfg.Configuration cfg = new Cfg.Configuration ();
                  cfg.AddAssembly( Assembly.GetExecutingAssembly() );
                  _factory = cfg.BuildSessionFactory(); 
               }
            } // end lock
         }
         return _factory;
      }
   } 
   public static ISession GetSession() {
      return Factory.OpenSession();
   }
}
OK，现在编译可以通过了，启动NUnit并选择生成的文件NHibernateTest.exe,运行测试。
我们得到了红色的条，出错了！原来还没有加入NHibernate的配置信息（当使用NHibernate时，需要在项目的配置文件中加入NHibernate的配置信息。关于配置信息，在下面有说明）。
在项目的配置文件App.Config(如没有请自行创建一个)中加入以下内容.
 < configSections >
<! —定义NHibernate配置节的处理类  -->
    < section name = " nhibernate "  type = " System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089 "   />
</ configSections >
< nhibernate >
    <! — 指定在log中是否显示sql语句， 用于调试  -->
    < add key = " hibernate.show_sql "  value = " true "   />
    <! — 数据库连接提供  -->
    < add key = " hibernate.connection.provider "  
      value = " NHibernate.Connection.DriverConnectionProvider "   />
    <! —指定数据库方言， NHB可以针对数据库方言进行优化  -->
    < add key = " hibernate.dialect "  
      value = " NHibernate.Dialect.MsSql2000Dialect "   />
    <! —数据驱动对象  -->
    < add key = " hibernate.connection.driver_class "  
      value = " NHibernate.Driver.SqlClientDriver "   />
    <! —连接字符串, userid和password改成你自己的哦。  -->
    < add key = " hibernate.connection.connection_string "  
      value = " Server=localhost;initial catalog=northwind;user id=northwind;password=123456;Min Pool Size=2 "   />  
 </ nhibernate >
再次运行测试，就可以看见绿色的条了。

在取得会话工厂的代码中，我使用了如下代码：
 if  ( _factory  ==   null  )  {
   lock ( lockObj ) {
      if ( _factory == null ) {
         // build sessionfactory code;
      }
   } // end lock
}
这是一个典型的double lock方式，用来产生线程安全的Singletion（单例）对象。

 2 . 基本CRUD操作
在很多介绍NHB的文章，包括NHB带的测试用例中，业务对象只是做为一个数据实体存在的，它没有任何操作！这在java中是比较典型的作法。
而我希望我们的业务对象自身就能完成基本的Create / Retrieve / Update / Delete，即CRUD操作，
在罗斯文商贸应用中，存在客户(customer)业务对象，先来为它建立一个测试用例, 
[TestFixture]
 public   class  CustomerFixture  {
   public CustomerFixture() {
   }

   [Test] // 测试Customer对象的CRUD操作。
   public void TestCRUD() {
      Customer c = new Customer();
      c.CustomerId = "test";
      c.CompanyName = "company name";
      c.ContactName = "contact name";
      c.Address = "address";
      c.Create(); // test create.

      Customer c2 = new Customer( c.CustomerId ); // test retrieve.
      Assert.AreEqual( c2.CompanyName, "company name", "save companyname fail! " );

      c2.CompanyName = "update name";
      c2.Update(); // test update.

      Customer c3 = new Customer( c.CustomerId )
      Assert.AreEqual( c3.CompanyName, "update name", "update companyname fail! " );

      c3.Delete(); // test delete.
   }
}

接下来创建Customer业务类，

 public   class  Customer : BizObject  {
   public Customer() { }
   public Customer( string existingId ) : base( existingId ) { }

   persistent properties.
}
在Customer类中，没有实现CRUD操作，这些操作在业务对象基类BizObject中实现，代码如下:
 public   class  BizObject  {
   public BizObject() { }

   public BizObject( object existingId ) {
      ObjectBroker.Load( this, existingId );
   }
   public virtual void Create() {
      ObjectBroker.Create( this );
   }
   public virtual void Update() {
      ObjectBroker.Update( this );
   }
   public virtual void Delete() {
      ObjectBroker.Delete( this );
   }
}
BizObject简单的将数据操作转发至ObjectBroker类, 目的是为了降低业务层和NHB之间的耦合, 以利于持久层间的移植。

 public   class  ObjectBroker  {
   private ObjectBroker() { }

   public static void Load( object obj, object id ){
      ISession s = Sessions.GetSession(); 
      try {
         s.Load( obj, id );
      }
      finally {
         s.Close();
      }
   }

   public static void Create( object obj ) {
      ISession s = Sessions.GetSession();
      ITransaction trans = null;
      try {
         trans = s.BeginTransaction();
         s.Save( obj );
         trans.Commit();
      }
      finally {
         s.Close();
      } 
   }

   public static void Update( object obj ) {
      ISession s = Sessions.GetSession();
      ITransaction trans = null; 
      try {
         trans = s.BeginTransaction();
         s.Update( obj );
         trans.Commit();
      }
      finally {
         s.Close();
      }
   }

   public static void Delete( object obj ) {
      ISession s = Sessions.GetSession();
      ITransaction trans = null; 
      try {
         trans = s.BeginTransaction();
         s.Delete( obj );
         trans.Commit();
      }
      finally {
         s.Close();
      }
   }
}
ObjectBroker对ISession进行了必要的封装，通过ISession,就可以简单的完成对象的CRUD操作了。

编译并运行测试，CustomerFixture的TestCRUD操作还是不能通过 !  异常信息为:
NHibernateTest.Test.CustomerFixture.TestCRUD : NHibernate.ADOException : Could not save  object
---->  NHibernate.MappingException : No persisters  for : NHibernateTest.Business.Customer
显然，是因为我们还没有为Customer对象编写映射文件，而导致NHB不能对Customer对象进行持久化操作。

Customer对象的映射文件(Customer.hbm.xml)内容如下:
 <? xml version = " 1.0 "  encoding = " utf-8 "   ?>  
 < hibernate - mapping xmlns = " urn:nhibernate-mapping-2.0 " >
    < class  name = " NHibernateTest.Business.Customer, NHibernateTest "  table = " Customers " >  
       < id name = " CustomerId "  column = " customerId "  type = " String "  unsaved - value = "" >
          < generator  class = " assigned " />
       </ id >
       < property name = " CompanyName "  column = " companyName "  type = " String "   />
       < property name = " ContactName "  column = " contactName "  type = " String "   />
       < property name = " ContactTitle "  column = " contactTitle "  type = " String "   />
       < property name = " Address” column=”address” type= " String "  />
       < property name = " City” column=”city” type=”String” />
       < property name = " Region” column=”region” type=”String” />
       < property name = " PostalCode” column=”postalCode” type=”String” />
       < property name = " Country” column=”country” type=”String” />
       < property name = " Phone” column=”phone” type=”String” />
       < property name = " Fax” column=”fax” type=”String” />
    </ class >  
 </ hibernate - mapping >
这个映射文件算是NHB中较为简单的了。
class的name指定业务对象全名及其所在程序集，table指定数据表的名称；
id用于指定一个对象标识符（数据表中的主键）及其产生的方式, 常用的主健产生方式有自增型(identity)和赋值型(assigned)，这里使用了assigned，需要注意的是unsaved - value属性，它指定对象没有持久化时的Id值，主要用于SaveOrUpdate操作；
property用于指定其它映射的数据列；
在id和property中，name指定属性名称，column指定数据列的名称，type指定属性类型，注意这里的类型是NHB中的类型，而不是.NET或数据库中的数据类型。

另外，对象映射文件名称请按”对象名.hbm.xml”的规范来命名, 最后在映射文件的属性中把操作改为“嵌入的资源“。
现在重新编译程序并运行测试，就能看到绿条了！

因为Product对象将在后面的案例中多次使用，在这里按与Customer相同的步骤创建它。
 //  Product单元测试
[TestFixture]
 public   class  ProductFixture  {
   public ProductFixture() { }

   [Test] // 测试Product对象的CRUD操作。
   public void TestCRUD() {
      Product p = new Product();
      p.ProductName = "test";
      p.QuantityPerUnit = "1箱10只";
      p.UnitPrice = 10.5M;
      p.Create();

      Product p2 = new Product( p.ProductId );
      p2.UnitPrice = 15.8M;
      p2.Update();

      Product p3 = new Product( p.ProductId );
      Assert.AreEqual( p3.UnitPrice, 15.8M, "update fail! " );

      p3.Delete();
   }
}

//  Product对象
public   class  Product : BizObject  {
   public Product() : base() { }
   public Product( int existingId ) : base( existingId ) { }

   persistent properties
}

//  映射文件
<? xml version = " 1.0 "  encoding = " utf-8 "   ?>  
 < hibernate - mapping xmlns = " urn:nhibernate-mapping-2.0 " >
    < class  name = " NHibernateTest.Business.Product, NHibernateTest "  table = " Products " >  
       < id name = " ProductId "  column = " productId "  type = " Int32 "  unsaved - value = " 0 " >
          < generator  class = " identity " />
       </ id >
       < property name = " ProductName "  column = " ProductName "  type = " String "   />
       < property name = " QuantityPerUnit "  column = " QuantityPerUnit "  type = " String "   />
       < property name = " UnitPrice "  column = " unitPrice "  type = " Decimal "   />
       < property name = " UnitsInStock "  column = " unitsInStock "  type = " Int32 "   />
       < property name = " UnitsOnOrder "  column = " unitsOnOrder "  type = " Int32 "   />
       < property name = " ReorderLevel "  column = " reorderLevel "  type = " Int32 "   />
       < property name = " Discontinued "  column = " discontinued "  type = " Boolean "   />

       <! —后面对这两个属性进行重构 -->
       < property name = " SupplierId "  column = " SupplierId "  type = " Int32 "   />
       < property name = " CategoryId "  column = " categoryId "  type = " Int32 "   />
    </ class >  
 </ hibernate - mapping >
编译并运行测试，检查错误直到单元测试通过。
注意：因为在数据库中，products表与categories表、suppliers表有外键约束，必须先删除这两个约束，product测试用例才能通过，后面我们再加上这两个约束。

现在我们已经掌握了NHB的基本CRUD操作了，整个过程应该说是比较简单吧。呵呵，不再需要使用Connection、DataAdapter、DataSet / DataReader之类的对象了，下面继续学习NHB中更为复杂的映射关系。

 3 . one - to - one
一对一是一种常见的数据模型，它有两种情况：一种是主键(PrimaryKey)关联；另一种是外健(ForeignKey)关联，在使用外健的时候要保证其唯一性。
在主键关联的情况下, 必须有一个主键是根据别一个主键而来的。NHB是通过一种特殊的方式来处理这种情况的, 要注意两个主健名称必须同名，而外健关联需要在one - to - one配置中定义一个property - ref属性, 这个属性在当前版本的NHB中还没有实现。
在罗斯文商贸应用，不需要使用one - to - one映射，这里先不对其进行讲解，如欲了解one - to - one方面的应用，请参考我网站上的文章。

 4 . many - to - one
many - to - one是描述多对一的一种数据模型，它指定many一方是不能独立存在的，我个人认为many - to - one是NHB中保证数据有效性的最有用的一种映射，通过使用many - to - one能有效的防治孤儿记录被写入到数据表中。
在罗斯文商贸数据中，Product(产品)与Category(类别)是多对一的关系。下面我们来处理这一映射关系,
首先要让Category能实现基本的CRUD操作，步骤同上, 这里只列出测试用例，类和映射文件请参照上面的方式创建。
[TextFixture]
 public   class  CategoryFixture  {
   public CategoryFixture() { 
   }
   [Test] // 测试基本的CRUD操作。
   public void TextCRUD() {
      Category c = new Category();
      c.CategoryName = “category1”;
      c.Description = “category1”;
      c.Create();

      Category c2 = new Category(c.CategoryId);
      c2.CategoryName = "test update";
      c2.Update();

      Category c3 = new Category( c.CategoryId);
      Assert.AreEqual( c3.CategoryName, "test updated", "update fail! " );
      c3.Delete();
   }
}
上面的测试用例通过后，接着修改Product的各部分。
Product测试用例修改如下:
[Test]  //  测试Product对象的CRUD操作。
public   void  TestCRUD()  {
   Category c = null;
   try {
      c.CategoryName = "test";
      c.Create();

      Product p = new Product();
      p.ProductName = "test";
      p.QuantityPerUnit = "1箱10只";
      p.UnitPrice = 10.5M;
      p.Category = c;
      p.Create();

      // 为省篇幅，下略...(不是删除掉哦！)
   }
   finally {
      if ( c != null && c.CategoryId > 0 ) c.Delete();
   }
}
Product类做如下修改:
 1 . 删除categoryId 字段和CategoryId属性;
 2 . 加入以下代码:
 public  Category Category  {
   get { return _category; }
   set { _category = value; }
}
private  Category _category; 

Product映射文件做如下修改:
 <!--  property name = " CategoryId "  column = " categoryId "  type = " Int32 "   -->
< many - to - one name = " Category "  column = " categoryId "  unique = " true "
class = " NHibernateTest.Business.Category, NHibernateTest "   />
这里用到了一个many - to - one标签，用于指定与one的一方进行关联的对象信息。
name指定one一方在对象中的名称;
column指定映射数据列的名称;
unique指定one一方是唯一的;
 class  指定one一方类的全名，包括程序集名称;

重新编译程序，运行测试用例, 看到绿条了吗？没有就根据异常去除错吧！我已经看到绿条了。：）

声明: 因为过多的many - to - one使后面的测试代码变得异常庞大（创建对象时要创建one一方的类），所以在后面的代码中，我假定Product对象是没有实现任何many - to - one映射的。如果不怕麻烦，请自行修改后面测试用例。

 5 . one - to - many
一对多也是一种常见的数据模型，在按范式设计的数据库中随处可见。在NHB中通过one - to - many可以非常方便的处理这种模型，同时NHB还提供了级联更新和删除的功能，以保证数据完整性。
在罗斯文商贸案例中，Customer与Order(订单)、Order和OrderItem(订单项目)就是一对多的关系，值得注意的是，并不是所有一对多关系都应该在NHB中实现，这取决于实际的需求情况，无谓的使用one - to - many映射只会降低NHB的使用性能。

下面先让Order和OrderItem对象能单独的完成CRUD操作，按上面处理Customer的方法来创建测试用例和类，

[TestFixture]
 public   class  OrderFixture  {
   public OrderFixture() { 
   }
   [Test] // 测试Order对象的CRUD操作。
   public void TestCRUD() {
      Order o = new Order();
      o.CustomerId = 1;
      o.EmployeeId = 1;
      o.ShippedDate = new DateTime( 2005, 3, 5 );
      o.ShipVia = 1;
      o.Freight = 20.5M;
      o.ShipName = "test name";
      o.ShipAddress = "test address";
      o.Create();

      Order o2 = new Order( o.OrderId );
      o2.Freight = 21.5M;
      o2.ShipAddress = "update address";
      o2.Update();

      Order o3 = new Order( o.OrderId );
      Assert.AreEqual( o3.Freight, 21.5M, "update order fail! " );
      Assert.AreEqual( o3.ShipAddress, "update address", "update order fail! " );

      o3.Delete();
   }
   [Test] // 测试OrderItem对象的CRUD操作。
   public void TestItemCRUD() {
      OrderItem item = new OrderItem();
      item.OrderId = 1;
      item.ProductId = 1;
      item.UnitPrice = 10.5M;
      item.Quantity = 12;
      item.Discount = 1;
      item.Create();

      OrderItem item2 = new OrderItem( item.ItemId );
      item2.Quantity = 13;
      item2.Update();

      OrderItem item3 = new OrderItem( item.ItemId );
      Assert.AreEqual( item3.Quantity, 13, "update orderitem fail! " );

      item3.Delete();
   }
}
//  Order
public   class  Order : BizObject  {
   public Order() : base() { }
   public Order( int existingId ) : base( existingId ) { }

   persistent properties
}
//  Order映射文件
<? xml version = " 1.0 "  encoding = " utf-8 "   ?>  
 < hibernate - mapping xmlns = " urn:nhibernate-mapping-2.0 " >
    < class  name = " NHibernateTest.Business.Order, NHibernateTest "  table = " Orders " >  
       < id name = " OrderId "  column = " orderId "  type = " Int32 "  unsaved - value = " 0 " >
          < generator  class = " identity " />
       </ id >
       < property name = " OrderDate "  column = " orderDate "  type = " DateTime "   />
       < property name = " RequiredDate "  column = " requiredDate "  type = " DateTime "   />
       < property name = " ShippedDate "  column = " shippedDate "  type = " DateTime "   />
       < property name = " Freight "  column = " freight "  type = " Decimal "   />
       < property name = " ShipName "  column = " shipName "  type = " String "   />
       < property name = " ShipAddress "  column = " shipAddress "  type = " String "   />
       < property name = " ShipCity "  column = " shipCity "  type = " String "   />
       < property name = " ShipRegion "  column = " shipRegion "  type = " String "   />
       < property name = " ShipPostalCode "  column = " shipPostalCode "  type = " String "   />
       < property name = " ShipCountry "  column = " shipCountry "  type = " String "   />

       <! —后面对这三个属性进行重构 -->
       < property name = " CustomerId "  column = " customerId "  type = " String "   />
       < property name = " EmployeeId "  column = " employeeId "  type = " Int32 "   />
       < property name = " ShipVia "  column = " shipVia "  type = " Int32 "   />
    </ class >  
 </ hibernate - mapping >

//  OrderItem
public   class  OrderItem : BizObject  {
   public OrderItem() : base() { }
   public OrderItem( int existingId ) : base( existingId ) { }

   persistent properties
}
//  OrderItem映射文件
<? xml version = " 1.0 "  encoding = " utf-8 "   ?>  
 < hibernate - mapping xmlns = " urn:nhibernate-mapping-2.0 " >
    < class  name = " NHibernateTest.Business.OrderItem, NHibernateTest "  table = " Order Details " >  
       < id name = " ItemId "  column = " itemId "  type = " Int32 "  unsaved - value = " 0 " >
          < generator  class = " identity " />
       </ id >
       < property name = " UnitPrice "  column = " unitPrice "  type = " Decimal "   />
       < property name = " Quantity "  column = " quantity "  type = " Int32 "   />
       < property name = " Discount "  column = " discount "  type = " Double "   />
       <! —后面对这二个属性进行重构 -->
       < property name = " OrderId "  column = " orderId "  type = " Int32 "   />
       < property name = " ProductId "  column = " productId "  type = " Int32 "   />
    </ class >  
 </ hibernate - mapping >
因为设计上的原因(业务对象必须为单主健)，我们向OrderDetails加入一个ItemId字段，这是一个自增型的主健，以代替原来的联合主健。

编译并运行测试，检查错误直到单元测试全部通过。
注意，在数据库中要进行如下修改，测试用例才能通过
 1 ．orders表与customers表、employeess表和shippers表有外键约束，必须暂时将它们删除，后面我们再加上这三个约束；
 2 ．将Order Details改名为OrderDetails，表名中出现空格将导致NHB无法解析；
 3 ．orderDetails表与orders表、products表有外健约束，必须暂时将它们删除，下面我们将加上这些约束。

现在开始重构OrderItem的测试用例和对象，主要是加入many - to - one映射。

先将TestItemCRUD修改为如下：
[Test]  //  测试OrderItem对象的CRUD操作。
public   void  TestItemCRUD()  {
   Order o = null;
   Product p = null;
   try {
      Order o = new Order(); 
      o.CustomerId = "AA001";
      o.EmployeeId = 1;
      o.Create();

      Product p = new Product();
      p.ProductName = "test";
      p.UnitPrice = 11.1M;
      p.Create();

      OrderItem item = new OrderItem();
      // item.OrderId = 1;
      item.Order = o;
      // item.ProductId = 1;
      item.Product = p;

      item.UnitPrice = 10.5M;
      item.Quantity = 12;
      item.Discount = 1;
      item.Create();

      OrderItem item2 = new OrderItem( item.ItemId );
      item2.Quantity = 13;
      item2.Update();

      OrderItem item3 = new OrderItem( item.ItemId );
      Assert.AreEqual( item3.Quantity, 13, "update orderitem fail! " );

      item3.Delete();
   }
   finally {
      if ( o != null && o.OrderId > 0 ) o.Delete();
      if ( p != null && p.ProductId > 0 ) p.Delete();
   }
}

接下来修改OrderItem对象，改动如下：

 //  private int _orderId = 0;  //  many-to-one, 需要重构.
private  Order Order;
 //  private int _productId = 0;  //  many-to-one, 需要重构.
private  Product Product;

删除OrderId和ProductId属性，并加入以下属性:
 public  Order Order  {
   get { return _order; }
   set { _order = value; }
}
public  Product Product  {
   get { return _product; }
   set { _product = value; }
}

编译项目，确保其能通过，如出现错误，请检查是否有拼写错误。

最后修改OrderItem对象的映射文件，改动如下:

 <!--  后面对这二个属性进行重构  -->
<!--  property name = " OrderId "  column = " orderId "  type = " Int32 "   -->
< many - to - one name = ”Order” column = ”orderId” unique = ” true ”
 class = ”NHibernateTest.Business.Order, NHibernateTest”  />
<!--  property name = " ProductId "  column = " productId "  type = " Int32 "   -->
< many - to - one name = ”Product” column = ”productId” unique = ” true ”
 class = ”NHibernateTest.Business.Product, NHibernateTest”  />
按many - to - one一节中的说明对Order和Product对象设置many - to - one关联。

重新生成项目，以使改动的资源编译进程序集中，运行TestItemCRUD测试用例，这时应能得到一个绿条，如果是红条，请根据错误信息进行检查。

接下来重构Order测试用例和对象。
先添加一个TestOrderItem用例如下:
[Test]
 public   void  TestOrderItem()  {
   Product p = null;
   Product p2 = null;
   try {
      p = new Product();
      p.ProductName = "test";
      p.UnitPrice = 11.1M;
      p.Create();
      p2 = new Product();
      p2.ProductName = "test2";
      p2.UnitPrice = 12.2M;
      p2.Create();

      Order o = new Order(); 
      o.CustomerId = "AA001";
      o.EmployeeId = 1;
      o.Create();

      OrderItem item = new OrderItem();
      item.Product = p;
      item.UnitPrice = 10;
      item.Quantity = 5;

      OrderItem item2 = new OrderItem();
      item2.Product = p2;
      item2.UnitPrice = 11;
      item2.Quantity = 4;

      o.AddItem( item );
      o.AddItem( item2 );
      o.Create();

      Order o2 = new Order( o.OrderId );
      Assert.IsNotNull( o2.Items, "add item fail! " );
      Assert.AreEqual( o2.Items.Count, 2, "add item fail! " );

      IEnumerator e = o2.Items.GetEnumerator();
      e.MoveNext();
      OrderItem item3 = e.Current as OrderItem;
      o2.RemoveItem( item3 );
      o2.Update();

      Order o3 = new Order( o.OrderId );
      Assert.AreEqual( o3.Items.Count, 1, "remove item fail! " );

      o3.Delete();
   }
   finally {
      if (p!=null && p.ProductId > 0) p.Delete();
      if (p2!=null && p2.ProductId >0) p2.Delete();
   }
}
在这个测试用例中，我们在Order对象中封装了对OrderItem的添加和移除操作，提供一个ICollection类型的属性Items用于遍历OrderItem。

接着修改Order对象，要添加两个方法和一个属性、一些辅助字段.
 public   void  AddItem( OrderItem item )  {
   if ( _items == null ) _items = new ArrayList();
   item.Order = this;
   _items.Add( item );
}
public   void  RemoveItem( OrderItem item )  {
   _items.Remove( item );
}
public  ICollection Items  {
   return _items;
}
protected  IList _Items  {
   get { return _items; }
   set { _items = value; }
}
private  IList _items;

在上面加入的代码中，有个protected修饰的_Items属性，它是用于one - to - many映射的，由NHB使用。

最后修改Order对象的映射文件，加入以下one - to - many代码:
 < bag name = " _Items "  cascade = " all "  inverse = " true " >
    < key column = " orderId " />
    < one - to - many  class = " NHibernateTest.Business.OrderItem, NHibernateTest "   />
</ bag >
这里又用到了一个新的标签bag, bag用于集合映射，在NHB中还有set, list等，它们的元素大致相同，但对应的.NET集合对象却是不一样的，后面对它们进行详细的说明和比较。
bag属性用于指定集合的名称和级联操作的类型;
key元素指定关联的数据列名称;
one - to - many指定many一方类的全名，包括程序集名称。

再次编译项目并运行测试用例，我得到了一个这样的诊断错误信息：
NHibernateTest.Test.OrderFixture.TestOrderItem : remove item fail !  
expected: < 2 >
but was: < 1 >
从源代码可以得知，当执行Update操作时，级联操作并不会删除我们移除的子对象，必须自行删除！级联删除只是指删除父对象的时候同时删除子对象。

修改TestOrderItem测试用例代码如下：
o2.Update();  //  此行不变
item3.Delete();  //  加入此行代码

6 . element
集合element是一种处理多对多的映射，多对多在数据库中也是常见的数据模型，像用户与组，用户与权限等。多对多关系需要通过一个中间表实现，element的就是读取这个中间表中某列的值。
在罗斯文商贸应用中，Employee和Territory之间是多对多的关系，它们通过EmployeeTerritories表进行关联。 有关Employee和Territory对象的代码、测试用例和映射文件请自行参照上面的方法创建，这里就不列出代码了，下面只列出测试element映射的部分。
[TestFixture]
 public   class  EmployeeFixture()  {
// other test....
   [test]
   public TerritoryElementTest() {
      Employee e = new Employee();
      e.FirstName = “first”;
      e.LastName = “last”;
      e.AddTerritory( 1000 );
      e.AddTerritory( 1001 );
      e.Create();

      Employee e2 = new Employee( e.EmployeeId );
      Assert.IsNotNull( e2.Territories, “add territory fail!” );
      Assert.AreEqual( e2.Territories.Count, 2, “add territory fail!” );

      e2.RemoveTerritory( 1000 );
      e2.Update();

      Employee e3 = new Employee( e.EmployeeId );
      Assert.AreEqual( e3.Territories.Count, 1, “remove territory fail!” );
      e3.Delete();
   }
}
在上面的代码中，我们给Employee添加两个方法和一个属性，这和one - to - many一节中介绍的处理方法是相似的。
在Employee类中，要添加如下代码:
 public   class  Employee  {
// other fields , properties, method...
   public void AddTerritory( int territoryId ) {
      if ( _territory == null ) _territory = new ArrayList();
      _territory.Add( territoryId );
   }
   public void RemoveTerritory( int territoryId ) {
      _territory.Remove( teritoryId );
   }
   public ICollection Territories {
      get { return _territory; }
   }
   protected IList _Territories {
      get { return _territories; }
      set { _territories = value; }
   }
}

最后修改Employee对象的映射文件，加入以下内容:
 < bag name = " _Territories "  table = ”EmployeeTerritories” >
    < key column = " employeeId " />
    < element column = " territoryId "  type = ”String”  />
</ bag >
在bag标签中，加入了一个table属性，它指定一个实现多对多的中间表。在element元素中，指定要读取的列名及其类型。 

四 数据加载

 1 . Expression

Expression数据加载由ICriteria接口实现, ICriteria在程序中是无法直接构造的，必须通过ISession.CreateCriteria(type)来获得。ICriteria主要负责存储一组Expression对象和一组Order对象，当调用List执行查询时，ICriteria对Expression对象和Order对象进行组合以产生NHB内部的查询语句，然后交由DataLoader(数据加载器)来读取满足条件的记录。

下面列出ICriteria接口中的一些常用方法：

Add：加入条件表达式(Expression对象)，此方法可多次调用以组合多个条件；
AddOrder：加入排序的字段(Order对象)；
List：执行查询, 返回满足条件的对象集合。
SetMaxResults：设置返回的最大结果数，可用于分页；
SetFirstResult：设置首个对象返回的位置，可用于分页；

通过SetMaxResults和SetFirstResult方法，就可以取得指定范围段的记录，相当于是分页，
！！！ 要说明的是，对于SQL Server数据库，它是使用将DataReader指针移到firstResult位置，再读取maxResults记录的方式来实现分页的，在数据量非常大（10w以上）的情况下，性能很难保证。

所有表达式对象都继承之Expression类，这是一个抽象( abstract )类, 同时也是一个类工厂(Factory Method模式), 用于创建派生的Expression对象，这样就隐藏了派生类的细节。(又学到一招了吧！)

下面列出几个常用的Expression对象:

EqExpression ：相等判断的表达式, 等同于 propertyName  =  value，由Expression.Eq取得;
GtExpression ：大于判断的表达式, 等同于 propertyName  >  value，由Expression.Gt取得; 
LikeExpression ：相似判断的表达式, 等同于 propertyName like value，由Expression.Like取得；
AndExpression ：对两个表达式进行And操作, 等同于 expr1 and expr2，由Expression.And取得; 
OrExpression ：对两个表达式进行Or操作, 等同于 expr1 or expr2，由Expression.Or取得;
更多的Expression对象请参考相关文档或源代码。

Order对象用于向ICriteria接口提供排序信息，这个类提供了两个静态方法，分别是Asc和Desc，顾名思义就是创建升序和降序的Order对象，例如要取得一个按更新日期(Updated)降序的Order对象, 使用Order.Desc( " Updated " )就可以了。

下面以加载Customer数据为例来说明Expression的使用:
测试代码如下,
[TestFixture]
 public   class  CustomerSystemFixture  {
   public CustomerSystemFixture() {
   }
   [Test]
   public void LoadByNameTest() {
      Expression expr = Expression.Eq( “CompanyName”, “company name” );
      IList custs = ObjectLoader.Find( expr, typeof(Customer) );
      // 根据期望的结果集写Assertion.
   }
   [Test]
   public void LoadByNamePagerTest() {
      Expression expr = Expression.Eq( “CompanyName”, “company name” );
      PagerInfo pi = new PagerInfo( 0, 5 );
      IList custs = ObjectLoader.Find( expr, typeof(Customer) , pi );
      // 根据期望的结果集写Assertion.
   }
   [Test]
   public void LoadByNameAndAddressTest() {
      Expression expr = Expression.Eq( “CompanyName”, “company name” );
      Expression expr2 = Expression.Eq( “Address”, “address” );
      IList custs = ObjectLoader.Find( Expression.And(expr, expr2), typeof(Customer) );
      // 根据期望的结果集写Assertion.
   }
   [Test]
   public void LoadByNameOrAddressTest() {
      Expression expr = Expression.Eq( “CompanyName”, “company name” );
      Expression expr2 = Expression.Eq( “Address”, “address” );
      IList custs = ObjectLoader.Find( Expression.Or(expr, expr2), typeof(Customer) );
      // 根据期望的结果集写Assertion.
   }
}
在上面的代码中，给出了四个较简单的表达式加载的测试用例，它们都通过调用ObjectLoader对象的Find方法来取得数据，ObjectLoader是我们自己的数据加载器，它简单的封装了NHB中的数据加载功能。另外，我们还用一个PagerInfo类封装了分页数据，以方便数据传递。
 //  PagerInfo
public   class  PagerInfo  {
   private int firstResult; // 起始位置
   private int maxReuslts; // 返回最大记录数
   public PagerInfo( int firstResult, int maxResults ) {
      this.firstResult = firstReuslt;
      this.maxResults = maxResults;
   }
   public int FirstResult {
      get { return firstResult; }
   }
   public int maxResults {
      get { return maxResults; }
   }
}
//  ObjectLoader
public   class  ObjectLoader  {
   private ObjectLoader() {
   }
   public static IList Find( Expression expr, Type type ) {
      return Find( expr, type, null );
   }
   public static IList Find( Expression expr, Type type, PagerInfo pi ) {
      ISession s = Sessions.GetSession();
      try {
         ICriteria c = s.CreateCriteria( type ); 
         if ( ex != null ) c.Add( ex );
         if ( pi != null ) {
            c.SetFirstResult( pi.FirstResult );
            c.SetMaxResults( pi.MaxResults );
         }
         return c.List();
      }
      finally {
         s.Close();
      }
   }
}
在Find方法中，先通过会话取得ICriteria接口, 然后加入表达式，接着检查是否需要设置分页数据，最后返回列出的数据。

 2 . HQL

HQL（Hibernate Query Language）是NHB的专用查询语言，它完全面向对象！就是说只需要知道对象名和属性名就可以生成HQL了，这样就再也不用去理会数据表和列了，前面说的Expression查询最终也会转换为HQL。
有两种方式来执行HQL，一种是直接使用ISession的Find方法，另一种是使用IQuery接口。IQuery接口提供了一些额外的设置，最重要的就是分页了，这个和ICriteria差不多，另外一些就是设置参数的值了。
NHB中有一组类专门用于完成数据加载，它们分别对应不同的数据加载情况，如实体加载、Criteria加载、OneToMany加载等。

下面同样以加载Customer数据为例来说明HQL的使用:
在上面的CustomerSystemFixture类中加入以下几个测试用例:
 public   class  CustomerSystemFixture  {
   [Test]
   public void LoadAllTest () {
      string query = “ from Customer “;
      IList custs = ObjectLoader.Find( query, null );
      // 根据期望的结果集写Assertion.
   }
   [Test]
   public void LoadPagerDataTest() {
      string query = “ from Customer “;
      PagerInfo pi = new PagerInfo( 0, 5 );
      IList custs = ObjectLoader.Find( query, null, pi );
   }
   [Test]
   public void LoadByName2Test() {
      string query = “ from Customer c where c.CompanyName = :CompanyName “;
      paramInfos.Add( new ParameterInfo(“CompanyName”, “test name”,       TypeFactory.GetStringType()) );
      IList custs = ObjectLoader.Find( query, paramInfos );
// 根据期望的结果集写Assertion.
   }
   [Test]
   public void LoadByNameAndAddress2Test() {
      string query = “ from Customer c where c.CompanyName = :CompanyName and c.Address = :Address“;
      paramInfos.Add( new ParameterInfo(“CompanyName”, “test name”,       TypeFactory.GetStringType()) );
      paramInfos.Add( new ParameterInfo(“Address”, “test address”, TypeFactory.GetStringType()) );
      IList custs = ObjectLoader.Find( query, paramInfos );
      // 根据期望的结果集写Assertion.
   }
}
在上面的测试用例中，我们同样将数据加载交由ObjectLoader的Find方法来处理，Find有很多重载的版本，都用于数据加载。另外还使用了一个ParameterInfo类来存储HQL语句的参数信息。
 //  ParamInfo
public   class  ParamInfo  {
   private string name; // 参数名称
   private object value; // 参数值
   private IType type; // 参数类型
   public ParamInfo( string name, object value, IType type ) {
      this.name = name;
      this.value = value;
      this.type = type;
   } 
   public string Name {
      get { return name; }
   } 
   public object Value {
      get { return value; }
   } 
   public IType Type {
      get { return type; }
   } 
}   // class ParamInfo

向ObjectLoader类加入以下方法:
 public   class  ObjectLoader  {
// ....
   public static IList Find( string query, ICollection paramInfos ) {
      return Find( query, paramInfos, null );
   }
   public static IList Find( string query, ICollection paramInfos, PagerInfo pi ) {
      ISession s = Sessions.GetSession();
      try {
         IQuery q = s.CreateQuery( query );
         if ( paramInfos != null ) {
            foreach ( ParamInfo info in paramInfos ) {
               if ( info.Value is ICollection )
                  q.SetParameterList( info.Name, (ICollection)info.Value, info.Type );
               else
                  q.SetParameter( info.Name, info.Value, info.Type );
            } 
         }
         if ( pi != null ) {
            q.SetFirstResult( pi.FirstResult );
            q.SetMaxResults( pi.MaxResults );
         }
         return q.List();
      }
      finally {
         s.Close();
      }
   }
}
在上面的Find方法中，通过HQL语句创建一个IQuery, 然后加入参数，接着设置分页数据，最后返回列出的数据。

五 事务

既然而数据库打交道，那么事务处理就是必需的，事务能保整数据完整性。在NHB中，ITransaction对象只对.NET的事务对象(实现了IDbTransaction接口的对象)进行了简单的封装。

使用NHB的典型事务处理看起来像下面这样(见ISession.cs的注释)
ISession sess  =  factory.OpenSession();
Transaction tx;
 try   {
   tx = sess.BeginTransaction();
   //do some work
   //...
   tx.Commit();
}  
 catch  (Exception e)  {
   if (tx != null) tx.Rollback();
   throw e;
}  
 finally   {
   sess.Close();
}
事务对象由ISession的BeginTransaction取得,同时事务开始，如果执行顺利则提交事务，否则回滚事务。

当实现一个业务规则时，而这一规则要改变多个业务对象状态时，这时就需要使用事务了，事务能保证所有改变要么全部保存，要么全部不保存！

在罗斯文商贸案例中，有这样一个业务规则：
如果客户对某一产品下了订单，那么被订购产品的已订购数量（UnitsOnOrder）应该加上客户的产品订单量，根据这一业务规则，创建一个测试用例如下:

[TestFixture]
 public   class  OrderFixture  {
   [Test]
   public void OrderTest() {
      Product p = new Product();
      p.UnitsOnOdrer = 20;
      p.Create();

      Order o = new Order();

      OrderItem item = new OrderItem();
      item.Order = o;
      item.Product = p;
      item.OrderNum = 10;

      OrderCO.Create( o );

      Product p2 = new Product( p.ProductId );
      Assert.AreEqual( p2.UnitsOnOrder, 30, “add to unitsonorder fail!” );
   }
}


 
jayfushuai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
简单好用的Nhibernate代码自动生成工具
04-19
Nhibernate是一款广泛使用的对象关系映射（ORM）框架，它允许开发者使用面向对象的编程方式来操作数据库，而无需直接编写SQL语句。在实际开发中，手动编写Nhibernate映射代码和实体类可能会耗费大量时间，这时就需要...
NHibernate
12-25
NHibernate 是一个强大的Java持久化框架，用于简化数据库操作，特别是在大型企业级应用程序中。它实现了对象关系映射（ORM）的概念，允许开发者使用面向对象的编程方式来处理数据库交互，而无需直接编写SQL语句。这...
第一个 NHibernate 程序
刚哥的博客
08-17 367
开发环境是vs2015  采用的NHibernate 版本号是v4.0.4.4000 关于确定开发环境是因为，我刚开始是使用vs2013 安装v4.0.4.4000 这个版本安装不上，只能安装比这个低的版本，最新的NHibernate的版本是v5.1.3 ，关键是v5.1.3安装不上 NHibernate 的v4.0.4.4000 是采用Nuget的方式安装的，程序除了在部署的时候出现问题外...
Nhibernate一对多关系
夏天--程序员
06-10 1967
在nhibernate中，可以通过映射文件来关联对象之间的关系。 对象之间的关系：一对一，多对一，一对多，多对多关系。在关系中控制级联行为（Cascade behavior）：级联删除，级联更新。 父子关系的双向导(bidirectional navigation) 父实体映射 父实体Customer映射文件中，定义了： 集合类型：Set，Bag，List，Map 在保存，更新，删除
NHibernate（转）
aoyaju4076的博客
11-21 113
NHibernate 是一个面向.NET 环境的对象/关系数据库映射工具。对象关系映射(O/R Mapping，Object Relational Mapping)表示一种技术，用来把对象模型表示的对象映射到基于SQL 的关系模型数据结构中去。... [详细] NHibernate官方站点：http://nhforge.org/NHibernate参考文档：http://nhforge....
NHibernate的配置
麦当劳比肯德基好吃
01-10 650
1.创建一个控制台应用 2.引入dll，这里可以右击引用，点击管理NuGet程序包，然后直接去搜索下载。 我们这里下载MySql.Data和NHibernate 3. 配置hibernate的config 可以去官网Your first NHibernate based application - NHibernate 找到一个Configure NHibernate 其中我们要更改的是我红色方框圈出来的地方，一个是数据库类型，一个是连接 在项目中添加一个hibernate..
nhibernate mysql 中文乱码_(转)NHibernate+MySql常见问题
weixin_35948624的博客
02-03 104
http://blog.51cto.com/4837471/1567675版本:NHibernate :NHibernate 4.0.1GAMySql:MySql 5.0.1常见问题一:“NHibernate.HibernateException”类型的未经处理的异常在 NHibernate.dll 中发生其他信息: Could not create the driver from NHibern...
NHibernate自动生成配置
angfensa0646的博客
01-27 93
我们在项目中采用了NHibernate作为ERMaping的解决方案，目前NHibernate发布了0.300版本，可以参见:NHibernate.sourceforge.net ;可NHibernate目前没有自动的配置生成工具，要一个一个的生成配置文件非常的烦人，通过研究，开发了一个配置生成工具。 在自己的工程项目中引用NHibernateAttribute名字空间...
一个NHibernate的BUG
老谭的专栏
12-20 1002
发现了一个NHibernate的BUG，分享一下。
通过NHibernate ORM和CodeDom在任何数据库中自动生成表以生成代码
寒冰屋的专栏
04-20 645
目录 介绍 NHibernate NHibernate的优点： NHibernate缺点： NHibernate如何运作？ CodeDOM CodeDOM的优点： CodeDOM缺点： 逐步使用代码 1.创建数据库 2.使用Fluent NHibernate + Microsoft.Build for CodeDOM + AngularJS for Frontend创建MV...
Nhibernate
u010396639的专栏
05-18 234
1.NHibernate Profiler 监控实际执行sql
C#访问数据库的一种方法——NHibernate的配置和使用
q__y__L的博客
12-26 1201
目录 1.背景 2.配置 3.使用 4. 注意事项 1.背景 一般C#访问数据库可以通过引用MySql.Data.dll库来实现，然后添加一个MySqlHelper类来对MySql数据库进行访问和操作， 添加引用后在你的数据库操作类(如MySqlHelper.cs)中添加引用声明 using MySql.Data; using MySql.Data.MySqlClient;...
NHibernate3.2 连接oracle自动生成数据库
03-30
NHibernate 是一个流行的开源对象关系映射（ORM）框架，用于.NET环境，它允许开发者将.NET类与数据库表进行映射，从而简化数据操作。在本案例中，我们关注的是如何使用NHibernate 3.2版本连接Oracle数据库，并实现...
NHibernate 3.2 sqlite 自己生成
03-31
NHibernate 是一个流行的开源对象关系映射（ORM）框架，用于.NET环境，它允许开发者用高级面向对象的方式处理数据库操作。在本项目“NHibernate 3.2 sqlite 自己生成”中，重点在于利用NHibernate的特性来自动生成...
Spring.NET+NHibernate+NHibernate.Mapping.Attribute自动映射
05-25
不喜欢NHibernate传统的*.hbm.xml来对数据库进行映射的朋友有福了，可以使用NHibernate.Mapping.Attribute.dll来实现自动映射。 减少不小的工作量。
深入探索Stage #2：属性中的XSS注入技术
weixin_43822401的博客
06-04 672
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
Windows10+vs 2017中创建WEB API教程
Explinks的博客
07-24 994
本文将介绍如何在Windows10+vs 2017中创建web Api的教程。目前本教程当中的方法在Win10 + VS2017（MVC5）win server2016+vs2017，vs2013 vs2019当中测试通过。
搭建基于 ChatGPT 的问答系统第九章-评估(上)
最新发布
weixin_42553583的博客
07-27 313
需要学习提示词工程的同学请看前几章内容请查看。
SSM（Spring + Spring MVC + MyBatis）框架面试三道题
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
07-26 352
在这个过程中，DispatcherServlet起到了核心作用，它作为前端控制器，负责接收请求、分发请求、处理响应等。它就像一个指挥官，协调着整个Spring MVC框架的运作。注解可以将Bean的作用域设置为原型，这样每次请求都会创建一个新的Bean实例。关于Bean的作用域控制，Spring提供了几种作用域选项，如。，表示在Spring容器中只有一个Bean实例。注解或XML配置来控制。
NHibernate入门指南：一步步探索ORM世界
NHibernate是一个强大的对象关系映射（ORM）框架，专门为.NET Framework设计，灵感来源于Java的Hibernate。它的主要目标是提供一种方式，使得.NET开发者可以使用面向对象的编程模型来操作数据库，而无需直接编写SQL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值