Fluent NHibernate之旅（四）-- 关系

最新推荐文章于 2024-05-09 09:45:57 发布

eqera

最新推荐文章于 2024-05-09 09:45:57 发布

阅读量4.3k

点赞数

分类专栏： .net

.net 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

今天我们将说一下ORM中的R映射，我们现在的数据库大多都是关系型数据库了，所以可以说关系在我们数据库设计中也是非常重要的部分，NHibernate也非常重视这一块，但在传统方式中，配置就比较麻烦，不是说我们Fluent能简单，只是传统方式的xml看上去不太美观，而Fluent这种代码式方式，更能符合我们Developer的习惯。

　　数据库关系

　　数据库关系一般有：

　　1、一对一

　　2、一对多

　　3、多对多

　　开始

　　结合我们前三个系列的示例，我们这一次加一个用户表[User]，目的就是存储用户信息所用，再加一个UserDetail，作为用户的详细信息。怎么简单怎么来，数据库设计如下：

够简单的吧，User和UserDetail是一对一关系，构建我们的实体类：

public　class　User　
{　
　　public　virtual　int　UserID　{　get;　set;　}　
　
　　public　virtual　string　UserName　{　get;　set;　}　
　
　　public　virtual　string　Password　{　get;　set;　}　
　
　　public　virtual　DateTime　CreateTime　{　get;　set;　}　
　
　　public　virtual　UserDetail　Detail　{　get;　set;　}　
}　
　
public　class　UserDetail　
{　
　　public　virtual　User　User　{　get;　set;　}　
　
　　public　virtual　int　UserID　{　get;　set;　}　
　
　　public　virtual　DateTime　LastUpdated　{　get;　set;　}　
　
　　public　virtual　PersonName　Name　{　get;　set;　}　
}　
　
public　class　PersonName　
{　
　　public　virtual　string　FirstName　{　get;　set;　}　
　
　　public　virtual　string　LastName　{　get;　set;　}　
}

嘿，为什么是三个model呢，因为我发现前几个系列里，没有说一下Component Mapping，所以今天一并说了。这是我们简单的一个一对一的设计，我们先只要求实现映射，至于其他的比如延迟加载的，稍后说。先跑起来溜溜。

　　映射

　　Fluent NHibernate 映射代码：

public　class　UserMap　:　ClassMap<User>　
{　
　　public　UserMap()　
　　{　
　　　　Id(u　=>　u.UserID).GeneratedBy.Identity()　;　
　　　　Map(u　=>　u.UserName);　
　　　　Map(u　=>　u.Password);　
　　　　Map(u　=>　u.CreateTime);　
　　　　HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().PropertyRef("User");　
　　}　
}　
　
public　class　UserDetailMap　:　ClassMap<UserDetail>　
{　
　　public　UserDetailMap()　
　　{　
　　　　Id(u　=>　u.UserID).Column("UserID").GeneratedBy.Foreign("User");　
　　　　HasOne<User>(d　=>　d.User).Cascade.All().Constrained();　
　　　　Map(u　=>　u.LastUpdated).Nullable();　
　　　　Component<PersonName>(u　=>　u.Name,　p　=>　
　　　　{　
　　　　　　p.Map(o　=>　o.FirstName).Column("[First　Name]");　
　　　　　　p.Map(o　=>　o.LastName).Column("[Last　Name]");　
　　　　});　
　　}　
}

　代码中有几点要注意（红色标记）：因为UserDetail使用的主键ID与User的ID是一致的，所以我们要使用Foregin来获取User的ID。Foreign的用法与先前版本有一点不同，需要指定propertyName。很多关联方法都是与NHibernate很类似的，比如Cascade，Cascade.All代表的是cascade="all"，代表的是无论什么操作，都会同时操作关联对象。

　　映射完，我们测试一下：

 
      
 
     
public　void　CreateUserTest()　
{　
　　var　factory　=　FluentSessionFactory.GetCurrentFactory();　
　　using　(var　session　=　factory.OpenSession())　
　　{　
　　　　DateTime　createTime　=　DateTime.ParseExact("2009-07-08　11:00",　"yyyy-MM-dd　hh:ss",null);　
　　　　User　user　=　new　User()　
　　　　{　
　　　　　　CreateTime　=　createTime,　
　　　　　　Password　=　"ilovecandy",　
　　　　　　UserName　=　"james",　
　　　　};　
　
　　　　UserDetail　detail　=　new　UserDetail　
　　　　{　
　　　　　　Name　=　new　PersonName　{　FirstName　=　"James",　LastName　=　"Ying"　},　
　　　　　　LastUpdated　=　createTime,　
　　　　};　
　
　　　　detail.User　=　user;　
　　　　user.Detail　=　detail;　
　
　　　　session.Save(user);　
　　　　session.Flush();　
　　}　
}　
　
[Fact]　
public　void　SelectUserTest()　
{　
　　　var　factory　=　FluentSessionFactory.GetCurrentFactory();　
　　　using　(var　session　=　factory.OpenSession())　
　　　{　
　　　　　User　user　=　session.Get<User>(1);　
　　　　　Assert.Equal("James",　user.Detail.Name.FirstName);　
　　　}　
}

从这篇以后，单元测试会使用Xunit，可以点此下载
　　一个插入测试，一个查询测试，看看测试结果：


       output： 
      
 
     
 
       
      
 
     
　　ok，测试通过。我们的一对一简单映射也说完了，同时也完成了Component的映射，接下来说说延迟加载
　　一对一延迟加载 
　　细心的朋友一定会发现我们的output出来的Sql语句，使用的是联合查询，但有时对我们来说，只需要User就可以了，我不需要查询UserDetail，或许你会说，使用以下方式来进行延迟加载：
HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().LazyLoad();
 虽然Fluent支持，虽然编译通过，但在创建ISessionFactory的时候，却会抛出异常，因为NHibernate不支持one-to-one的Lazy的特性，也就是说NHibernate不支持一对一的延迟加载。但是查了很多资料，说可以用： 
      
 
      HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().Fetch.Select();
 HasOne<User>(d　=>　d.User).Cascade.All().Constrained(); 
      
 进行延迟加载，但结果只是分了2条Sql语句进行的查询，并不是延迟加载，这一点可以通过Sql Server Profiler查看： 
      
 
     
 
       
      
 
     

       NHibernate是不支持one-to-one的延迟加载的，我也不知道为什么，但我们可以婉转的进行延迟加载，老赵已经在他的文章“ 
      NHibernate中一对一关联的延迟加载”中提出了解决方案，大家可以看一下 
      
 
     
场景和数据库设计 
　　延续我们的演示范例，用户和订单是非常典型的一对多范例。
　　1、一个用户可以拥有多个订单
　　2、一个订单只能拥有一个用户
　　对于用户来说，不需要每次都加载订单列表，反之订单可能每次都需要加载用户信息。Let's Go：

我们原先的订单系统太贫血了，我们进一步扩展一下，现在已经可以储存收货人的姓名和地址，还包括了发起人的UserID。
　　映射 
　　不得不赞叹一下 Fluent Nhibernate ，有了它，我们的映射一切都变得如此简单，先来看看Model吧，用户的订单列表，对于用户来说，暂时是不需要排序的，所以我们可以使用ISet作为Order的列表。

 
        public　class　User　
{　
　　public　virtual　int　UserID　{　get;　set;　}　
　
　　public　virtual　string　UserName　{　get;　set;　}　
　
　　public　virtual　string　Password　{　get;　set;　}　
　
　　public　virtual　DateTime　CreateTime　{　get;　set;　}　
　
　　public　virtual　UserDetail　Detail　{　get;　set;　}　
　
　　public　ISet<Order>　Orders　{　get;　set;　}　
}　
　
public　class　Order　
{　
　　public　virtual　int　OrderID　{　get;　set;　}　
　
　　public　virtual　float　Price　{　get;　set;　}　
　
　　public　virtual　OrderState　State　{　get;　set;　}　
　
　　public　virtual　DateTime　CreateTime　{　get;　set;　}　
　
　　public　virtual　User　User　{　get;　set;　}　
　
　　public　virtual　string　Address　{　get;　set;　}　
　
　　public　virtual　string　Zip　{　get;　set;　}　
　
　　public　virtual　string　Coignee　{　get;　set;　}　
}
 
        
 好，我们看看Fluent如何映射吧，你会发觉，一切就是这么简单： 
        
 
       

 
         
 
        
 
          public　class　UserMap　:　ClassMap<User>　
{　
　　public　UserMap()　
　　{　
　　　　Id(u　=>　u.UserID).GeneratedBy.Identity()　;　
　　　　Map(u　=>　u.UserName);　
　　　　Map(u　=>　u.Password);　
　　　　Map(u　=>　u.CreateTime);　
　　　　HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().Fetch.Select();　
　　　　HasMany<Order>(u　=>　u.Orders).AsSet().KeyColumn("UserID").Cascade.All();　
　　}　
}　
　
public　class　OrderMap　:　ClassMap<Order>　
{　
　　public　OrderMap()　
　　{　
　　　　Id(o　=>　o.OrderID).GeneratedBy.Identity();　
　　　　Map(o　=>　o.Price);　
　　　　Map(o　=>　o.State).CustomType<OrderState>();　
　　　　Map(o　=>　o.Address);　
　　　　Map(o　=>　o.Coignee);　
　　　　Map(o　=>　o.CreateTime);　
　　　　Map(o　=>　o.Zip);　
　　　　References<User>(o　=>　o.User).Not.LazyLoad().Column("UserID");　
　　}　
}
 
          
 怎么样，简单明了吧，比传统方式要容易懂吧，看一下我们的测试结果： 
          
 
         

 
            [Fact]　
public　void　CreateOrder()　
{　
　　var　factory　=　FluentSessionFactory.GetCurrentFactory();　
　　using　(var　session　=　factory.OpenSession())　
　　{　
　　　　User　user　=　session.Get<User>(1);　
　　　　Order　order　=　new　Order()　
　　　　{　
　　　　　　Address　=　"James　&　Candy　's　Home",　
　　　　　　Coignee　=　"Candy",　
　　　　　　CreateTime　=　DateTime.Now,　
　　　　　　Price　=　1500,　
　　　　　　State　=　OrderState.Created,　
　　　　　　Zip　=　"200000",　
　　　　};　
　
　　　　order.User　=　user;　
　　　　session.Save(order);　
　　}　
}
 
            
 
             
            
 
           
一对多的映射，比起一对一来说还相对的简单点，默认是延迟加载，如果项目中，有些地方，需要立即加载，我们也可以使用 FetchMode.Eager 来加载。
　　立即加载 
 
             
 
            
 
               
              
 
             

               我们在Output中，能看到NHibernate生成的Sql语句，测试也成功，说明我们刚刚是立即加载了Orders属性。 
              
 
             
场景和数据库设计 
　　前两篇我们介绍了“一对一”和“一对多（多对一）”，或许前两种用的比较多，但多对多的关系，有时候我们也会遇到，比如我们一直演示的电子商务站，我们的订单和产品的关系，就是一个非常典型的“多对多”。看看我们的数据库设计：


               这里说一下，订单对于产品来说，不一定需要知道，也或者可以不需要一起加载，所以可以用延迟加载或者不加载，而产品对于订单来说，应该是需要立即加载，从而知道订单中所有的商品。随着扩展，我们必须给我们的Product和Order加入相关的属性： 
              
 
             

public　abstract　class　Product　
{　
　　public　virtual　int　ProductID　{　get;　set;　}　
　
　　private　ISet<Order>　m_orders　=　null;　
　　public　ISet<Order>　Orders　
　　{　
　　　　get　
　　　　{　
　　　　　　if　(this.m_orders　==　null)　
　　　　　　{　
　　　　　　　　this.m_orders　=　new　HashedSet<Order>();　
　　　　　　}　
　　　　　　return　this.m_orders;　
　　　　}　
　　　　set　
　　　　{　
　　　　　　this.m_orders　=　value;　
　　　　}　
　　}　
　
　　//product　other　Property　
}　
　
public　class　Order　
{　
　　public　Order()　
　　{　
　　　　this.Products　=　new　HashedSet<Product>();　
　　}　
　
　　public　virtual　int　OrderID　{　get;　set;　}　
　
　　public　ISet<Product>　Products　{　get;　set;　}　
　
　　//order　other　Property　
}

　映射 
　　如果大家先前几篇都看过的话，我觉得应该没有任何问题了，因为Fluent NHibernate 真的很简单，很流畅，代码如下：

public　class　ProductMap　:　ClassMap<Product>　
{　
　　public　ProductMap()　
　　{　
　　　　Id(p　=>　p.ProductID);　
　　　　HasManyToMany<Order>(p　=>　p.Orders)　
　　　　　　.AsSet()　
　　　　　　.LazyLoad()　
　　　　　　.ParentKeyColumn("ProductID")　
　　　　　　.ChildKeyColumn("OrderID")　
　　　　　　.Table("OrderProduct");　
　
　　　　Map(p　=>　p.CreateTime);　
　　　　Map(p　=>　p.Name);　
　　　　Map(p　=>　p.Price);　
　　}　
}　
　
public　class　OrderMap　:　ClassMap<Order>　
{　
　　public　OrderMap()　
　　{　
　　　　Id(o　=>　o.OrderID).GeneratedBy.Identity();　
　　　　HasManyToMany<Product>(o　=>　o.Products)　
　　　　　　.AsSet()　
　　　　　　.Not.LazyLoad()　
　　　　　　.Cascade.All()　
　　　　　　.ParentKeyColumn("OrderID")　
　　　　　　.ChildKeyColumn("ProductID")　
　　　　　　.Table("OrderProduct");　
　
　　　　Map(o　=>　o.Price);　
　　　　Map(o　=>　o.State).CustomType<OrderState>();　
　　　　Map(o　=>　o.Address);　
　　　　Map(o　=>　o.Coignee);　
　　　　Map(o　=>　o.CreateTime);　
　　　　Map(o　=>　o.Zip);　
　　　　References<User>(o　=>　o.User).Not.LazyLoad().Column("UserID");　
　　}　
}

　这里我们用了一个单独的一个表来保存这个多对多关系，所以需要Table("Table Name")。
　　ParentKeyColumn和ChildKeyColumn都是相对于自己的，大家也可以生成hbm来看下多对多的传统的写法。
　　测试 
　　映射完成了，我们测试一下，我们还是使用xunit来单元测：

[Fact]　
public　void　CreateOrder()　
{　
　　using(var　session　=　this.SessionFactory.OpenSession())　
　　{　
　　　　session.Transaction.Begin();　
　　　　var　products　=　session.CreateCriteria<Product>().List<Product>();　
　　　　var　user　=　session.Load<User>(1);　
　　　　var　order　=　new　Order　
　　　　{　
　　　　　　User　=　user,　
　　　　　　Address　=　"Shang　Hai",　
　　　　　　Coignee　=　"Candy",　
　　　　　　State　=　OrderState.Created,　
　　　　　　CreateTime　=　DateTime.Now,　
　　　　　　Zip　=　"200336"　
　　　　};　
　
　　　　order.Products.AddAll(products);　
　　　　order.Price　=　order.Products.Sum(p　=>　p.Price);　
　
　　　　session.Save(order);　
　　　　session.Transaction.Commit();　
　　}　
}

（测试代码不是很完全，在文章结尾会有源代码，大家可以下载进行学习。）
　　ok，我们来看下我们的测试结果，我们需要：绿
 
                    
 
                   
 
                    
 
                   
 
                    代码  
                   