Fluent NHibernate关系映射

1.好处:Fluent NHibernate让你不再需要去写NHibernate的标准映射文件(.hbm.xml), 方便了我们的代码重构,提供了代码的易读性,并精简了项目代码

实现:

(1)、首先我们通过nuget包管理器添加FluentNHibernate与NHibernate的引用。

(2)、编写实体类,注意实体的属性都是virtual

(3)、实体类编写完成以后我们用代码的方式实现对实体的映射

Fluent NHibernate主要实现的映射关系:一对一、一对多、多对一、多对多

下面介绍几种映射关系中主讲一对多关联属性

2. 一对一映射 HasOne<>()

2.1. 定义支持的关联属性

Cascade 指该对象在进行操作时关联到的子对象的操作类型

PropertyRef属性一般用来解决遗留数据库一对多关系的问题

PropertyRef被关联到此外键的类中的对应属性的名字,若没指定,使用被关联类的主键.

PropertyRef不是数据库表中的字段名,而是定义的类中的属性名

Fetch    在外连接抓取或者序列选择抓取选择其一.

class:被关联的类的名字

constrained  表明该类对应的表对应的数据库表,和被关联的对象所对应的数据库表之间,通过一个外键引用对主键进行约束。 这个选项影响Save()和Delete()在级联执行时的先后顺序以及决定该关联能否被委托

2.1.1.映射范例

用户和用户信息表在实际中是一对一的关系,这两个表之间是通过使用UserID来相互关联的,UserDetail使用的主键ID与User的ID是一致的,所以我们要使用Foregin来获取User的ID,它们有一个共同的ID,在插入Users表的同时也要写入UserDetail表,所以需要添加一对一的限制关系,具体的在User和UsersDetai两表的映射方法如下代码

  public UserMap() 

{ 

Table("Users");

    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 UserDetailMap() 

{ 

Table("UserDetais");

    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]"); 

    }); 

} 

2.1.2.补充说明

上面指定了All说明所有的操作都会关联到子表,还有SaveUpdate在添加和更新时关联子表,另外还有None类型不推荐使用此类型因为会出现很多问题。

一对一延迟加载

有时对我们来说,只需要User就可以了,我不需要查询UserDetail,或许你会说,使用以下方式来进行延迟加载:

HasOne<UserDetail>(u => u.Detail).Cascade.All().LazyLoad();

虽然Fluent支持,虽然编译通过,但在创建ISessionFactory的时候,却会抛出异常,因为NHibernate不支持HasOne的不支持一对一的延迟Lazy加载的特性, 可以用:

HasOne<UserDetail>(u => u.Detail).Cascade.All().Fetch.Select();

HasOne<User>(d => d.User).Cascade.All().Constrained();

3. 一对多HasMany<>() / 多对一 References<>()

3.1. 定义支持的关联属性

KeyColumn  表示主键名

Cascade表示级联取值,决定是否把对对象的改动反映到数据库中,所以Cascade对所有的关联关系都起作用, Cascade是操作上的连锁反映,Cascade取值可能是以下:

AllDeleteOrphan       在关联对象失去宿主(解除父子关系)时,自动删除不属于父对象的子对象, 也支持级联删除和级联保存更新.

DeleteOrphan           删除所有和当前对象解除关联关系的对象

All                 级联删除, 级联更新,但解除父子关系时不会自动删除子对象.

Delete                                  级联删除, 但不具备级联保存和更新

None                                     所有操作均不进行级联操作

SaveUpdate                        级联保存(load以后如果子对象发生了更新,也会级联更新). 在执行save/update/saveOrUpdate时进行关联操作,它不会级联删除

Inverse()    所描述的是对象之间关联关系的维护方式,作用是:是否将对集合对象的修改反映到数据库中。Inverse表示对集合对象的修改会被反映到数据库中;

为了维持两个实体类(表)的关系,而添加的一些属性,该属性可能在两个实体类(表)或者在一个独立的表里面,这个要看这双方直接的对应关系了: 这里的维护指的是当主控方进行增删改查操作时,会同时对关联关系进行对应的更新,Inverse是操作上的连锁反映。

ForeignKeyConstraintName   外键约束名

Access   NHibernate用来访问属性的策略。

unique: 为外键字段生成一个唯一约束。此外, 这也可以用作PropertyRef的目标属性。这使关联同时具有 一对一的效果。

OptimisticLock  定这个属性在做更新时是否需要获得乐观锁定(OptimisticLock)。 换句话说,它决定这个属性发生脏数据时版本(version)的值是否增长。

NotFound   指定外键引用的数据不存在时如何处理: ignore会将数据不存在作为关联到一个空对象(null)处理。

IsProxy     指定一个类或者接口,在延迟装载时作为代理使用。

Schema

3.1.1. 映射范例

一个用户可以拥有多个订单,一个订单只能拥有一个用户,对于用户来说,不需要每次都加载订单列表,反之订单可能每次都需要加载用户信息。

  public UserMap() 

{ 

Table("Users");

    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(); ////处理一对多关系的映射,一个User可以有多个订单, 关联的数据表进行懒加载,主键名为UserID,级联关系所有操作

}

  public OrderMap() 

  { 

Table("Orders");

    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");  //处理多对一关系,多个Order可以属于一个User

  } 

/// <summary>

/// 映射关系实体类的构造函数

/// 在构造函数中处理好映射关系

/// </summary>

public CustomerMapping()

{

//指定持久化类对应的数据表

Table("TB_Customer");

//自动增长的id

//Id(i => i.CustomerID);

//映射关系

Id<Guid>("CustomerID").GeneratedBy.GuidComb();

//指定主键后一定要加上主键字段的映射关系,不然返回的id为new Guid(),也就是一串0

Map(m => m.CustomerID).Nullable();

Map(m => m.CustomerAddress).Length(50).Nullable();

Map(m => m.CustomerName).Length(32).Nullable();

Map(m => m.Version);

//处理一对多关系的映射,一个客户可以有多个订单

//关联的数据表进行懒加载,主键名为CustomerID,级联关系所有操作,cascade:All|delete|saveorUpdate,级联删除时需加上Inverse()

//     Inverse the ownership of this entity. Make the other side of the relationship

//     responsible for saving.

HasMany<Order>(h => h.Orders).LazyLoad().AsSet().KeyColumn("CustomerID").Cascade.All().Inverse();

}

首先是Tasks表的映射,因为Tasks表是多的一端,所以要添加对Projects表的外键引用关系,另外因为是一种外键引用不关系到父表的操作,所以这里可以使用Cascade.None()。

public TasksMappping()

{

Table("Tasks");

LazyLoad();

Id(x => x.ID).Column("TaskID").GeneratedBy.Identity();

References(x => x.Project).Nullable().Column("ProjectID").Cascade.None();//处理多对一关系,多个Tasks可以属于一个Project

Map(x => x.Name).Nullable();

}

在Projects表中,因为该表中的一个ID会对应多个Tasks所以在添加HasMany方法,来表明Projects和Tasks的多对一的关系,如下代码它会涉及到任务的添加和更新操作,所以需要使用Cascade.SaveUpdate()。

public ProjectsMapping()

{

Table("Projects");

LazyLoad();

Id(x => x.ID).Column("ProjectID").GeneratedBy.Identity();

References(x => x.User).Column("UserID").Cascade.None(); //它的操作不会涉及到Projects的操作

Map(x => x.Name).Nullable();

HasMany(x => x.Task).KeyColumn("ProjectID").LazyLoad().Cascade.SaveUpdate();

//在save或者update Projects的时候会连带着修改Tasks

}

3.1.2.补充说明

一对多的映射,比起一对一来说还相对的简单点,默认是延迟加载,如果项目中,有些地方,需要立即加载,我们也可以使用 FetchMode.Eager 来加载;

4. 多对多映射 HasManyToMany <>()

4.1. 定义支持的关联属性

ParentKeyColumn        定义与A表关联的字段名

ChildKeyColumn         定义与B表关联的字段名

Table                  关系表

4.1.1. 映射范例

比如电子商务站的订单和产品的关系

  public ProductMap() 

  { 

Table("Products");

    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 OrderMap() 

  { 

Table("Orders");

    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"); //多个订单属于一个客户

  } 

这里我们用了一个单独的一个表OrderProduct来保存这个多对多关系

比如 一个Project会有有很多Product,同时一个Product也可能会在多个Project中

public ProjectsMapping()

{

Table("Projects");

LazyLoad();

Id(x => x.ID).Column("ProjectID").GeneratedBy.Identity();

References(x => x.User).Column("UserID").Cascade.None();

Map(x => x.Name).Nullable();

HasMany(x => x.Task).KeyColumn("ProjectID").LazyLoad().Cascade.SaveUpdate();

HasManyToMany(x => x.Product).ParentKeyColumn("ProjectID").ChildKeyColumn("ProductID").Table("ProjectProduct");

}

public ProductMapping()

{

Table("Product");

Id(x => x.ID).Column("ProductID").GeneratedBy.Identity();

Map(x => x.Name).Nullable();

Map(x => x.Color).Nullable();

HasManyToMany(x => x.Project).ParentKeyColumn("ProductID").ChildKeyColumn("ProjectID").Table("ProjectProduct");

}

4.1.2.补充说明

具体添加关联的步骤如下:

(1)在映射的两端同时添加HasManyToMany的关系这样就形成了双向的关联关系

(2)指定映射的ParentKey和ChildKey,一般会将对象本身的ID指定为ParentKey,关联对象的ID指定为ChildKey

(3)指定关联关系的关系表,使用Table方法指定关联表,如上示例的Table("ProjectProduct")。

以上只为突出一对一的双向关联映射,一对多的单向关联和多对多的双向关联关系

上一篇:本机搭建外网web服务器


下一篇:夺命雷公狗ThinkPHP项目之----企业网站13之文章列表页的实现(主要是分页的实现)