代码
Many-To-Many 双向关联
1.双向N——N关联的两边都需要指定连接表的表名，外键列的列名。
2.两个set元素table必须指定，并且必须相同。
3.set元素的两个字元素：key和many-to-many都必须指定column属性，key和many-to-many分别制定本持久化类，关联类在连接表中的外键列名，因此两边的key与many-to-many的column属性交叉相同。
例如：
T_User表 T_User_Role T_Role表
Id Int主键自增 UserId User表id Id Int主键自增
UserName String 50 RoleId Role表id RoleName String 50
UserPassword String 50
User类：
―――――――――――――――――――――――――
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace NHibernateTest.Model
{
[Serializable]
public class User
{
private int _userid;
public virtual int UserId
{
get { return _userid; }
set { _userid = value; }
}
private string _username;
public virtual string UserName
{
get { return _username; }
set { _username = value; }
}
private string _userpassword;
public virtual string UserPassword
{
get { return _userpassword; }
set { _userpassword = value; }
}
private IList _roles;
public virtual IList Roles
{
get { return _roles; }
set { _roles = value; }
}
public User()
{
_userid = 0;
_username = null;
_userpassword = null;
_roles = new ArrayList();
}
}
}
Role类：
―――――――――――――――――――――――
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace NHibernateTest.Model
{
[Serializable]
public class Role
{
private int _roleid;
public virtual int RoleId
{
get { return _roleid; }
set { _roleid = value; }
}
private string _rolename;
public virtual string RoleName
{
get { return _rolename; }
set { _rolename = value; }
}
private IList _users;
public virtual IList Users
{
get { return _users; }
set { _users = value; }
}
public Role()
{
_roleid = 0;
_rolename =null;
_users = new ArrayList();
}
}
}
User类映射文件User.hbm.xml：
-----------------------------------------------------------------------------
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
<class name="NHibernateTest.Model.User,NHibernateTest.Model"
table="T_User">
<id name="UserId" column="Id" type="Int32" unsaved-value="0">
<generator class="native"/>
</id>
<property column="UserName" type="String" name="UserName" not-null="true" length="50" />
<property column="UserPassword" type="String" name="UserPassword" not-null="true" length="50" />
<bag name="Roles" table="T_User_Role" lazy="true">
<!--指定本持久化类（User）在连接表（T_User_Role）中的外键列名UserId，也就是T_User_Role表的UserId -->
<key column="UserId"/>
<!--指定关联类（Role）在连接表（T_User_Role）中的外键列名RoleId -->
<many-to-many class="NHibernateTest.Model.Role,NHibernateTest.Model" column="RoleId"/>
</bag>
</class>
</hibernate-mapping>
Role类映射文件 Role.hbm.xml:
---------------------------------------------------
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
<class name="NHibernateTest.Model.Role,NHibernateTest.Model" table="T_Role">
<id name="RoleId" column="Id" type="Int32" unsaved-value="0">
<generator class="native"/>
</id>
<property column="RoleName" type="String" name="RoleName" not-null="true" length="50" />
<bag name="Users" table="T_User_Role" lazy="true" inverse="true">
<!--指定本持久化类（Role）在连接表（T_User_Role）中的外键列名，也就是T_User_Role表的RoleId-->
<key column="RoleId"/>
<!--指定关联类（User）在连接表（T_User_Role）中的外键列名-->
<many-to-many class="NHibernateTest.Model.User,NHibernateTest.Model" column="UserId"/>
</bag>
</class>
</hibernate-mapping>
实现代码如下：
using System;
using System.Collections;
using System.Collections.Generic;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using NHibernateTest.Model;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;
namespace NHibernateTest
{
/* many-to-many和别的关联映射有所不同。
* 例子中：Role和User没有直接的依赖关系，而是通过一张中间表完成。
* 在删除User时一般不会要求删除Role，而是删除之间的关系
* （即从中间表删除数据）。
*/
public partial class Many_To_Many : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
protected void TestAddRoleToUser_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
User user = session.Load(typeof(User), 4) as User;
Role role = session.Load(typeof(Role), 4) as Role;
user.Roles.Add(role);
role.Users.Add(user);
session.Update(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//移除user和role的关联关系
protected void TestRemoveRoleFromUser_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
//移除user和role的关联关系
User user = session.Load(typeof(User), 5) as User;
Role role = session.Load(typeof(Role), 5) as Role;
user.Roles.Remove(role);
role.Users.Remove(user);
session.Update(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//更新了与UserId＝6关联的Role的RoleName名字
protected void TestUpdateUserWithRole_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
//更新了与UserId＝6关联的Role的RoleName名字
User user = session.Load(typeof(User), 6) as User;
((Role)user.Roles[0]).RoleName = "UpdateRole";
session.Update(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//删除T_User表id＝10的记录和删除了T_User_Role表的UserId＝10的记录
//跟踪Sql：go
/* DELETE FROM T_User_Role WHERE UserId = @p0', N'@p0 int', @p0 = 10
DELETE FROM T_User WHERE Id = @p0', N'@p0 int', @p0 = 10
*/
protected void TestDeleteUserWithSetRole_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
User user = session.Load(typeof(User), 10) as User;
session.Delete(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//添加了User，Role 以及User－Role的关系
protected void TestAddUserAndRole_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
User user = new User();
user.UserName = "222";
user.UserPassword = "222";
Role role = new Role();
role.RoleName = "秘书";
role.Users.Add(user);
user.Roles.Add(role);
session.Save(user);
session.Save(role);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
}
}
One－To－Many（单项关联1－N）
因为集合属性都需要保存到另一个数据表中，所以保存集合属性表必须必须包含一个外键列，用于参照主键列。该外键列通过在<Set/>等集合元素中使用<key…/>子元素column来映射。不管使用那种集合，使用<bag../>元素都将映射成无序集合。集合属性对应的表没有主键。
对于1—N的单向关联，需要在1的一端增加对应的集合映射元素。与映射集合类似，必须为<set> ,<bag>等集合元素增加key子元素，用以映射关联外键列。
one-to-many标签包含在标签bag/set中.bag标签的。inverse属性使collection不更新连接。
key标签的column属性指出了在另一个数据库表中加入外键，来关联本类。
T_Parent T_Child
Id Int主键自增 ChildId Int自增
Name String Name String
ParentId T_Parent表Id
Many－To－One
many-to-one：描述多对一的一种数据模型，它指定many一方是不能独立存在的，我个人认为many-to-one是NHB中保证数据有效性的最有用的一种映射，通过使用many-to-one能有效的防治孤儿记录被写入到数据表中。
<many-to-one
name="propertyName"(1)
column="column_name"(2)
class="ClassName"(3)
cascade="all|none|save-update|delete"(4)
unique="true|false" (10)
/>
１．name：属性名。指出many一方的类用哪个属性和one一方的类关联．
２．column：字段名（可选）．指出many一方的类对应的数据表用哪个列和one一方的类对应的数据表关联（两表之间存在外键关联）；
３．class：关联的类的名字（可选 - 默认是通过反射得到属性类型）；
４．cascade：指明哪些操作会从父对象级联到关联的对象（可选）．cascade属性允许下列值：: all, save-update, delete, none. 设置除了none以外的其它值会传播特定的操作到关联的（子）对象中。
5．unique：允许产生外键列唯一约束的数据库定义语言（DDL）（可选）
1.双向N——N关联的两边都需要指定连接表的表名，外键列的列名。
2.两个set元素table必须指定，并且必须相同。
3.set元素的两个字元素：key和many-to-many都必须指定column属性，key和many-to-many分别制定本持久化类，关联类在连接表中的外键列名，因此两边的key与many-to-many的column属性交叉相同。
例如：
T_User表 T_User_Role T_Role表
Id Int主键自增 UserId User表id Id Int主键自增
UserName String 50 RoleId Role表id RoleName String 50
UserPassword String 50
User类：
―――――――――――――――――――――――――
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace NHibernateTest.Model
{
[Serializable]
public class User
{
private int _userid;
public virtual int UserId
{
get { return _userid; }
set { _userid = value; }
}
private string _username;
public virtual string UserName
{
get { return _username; }
set { _username = value; }
}
private string _userpassword;
public virtual string UserPassword
{
get { return _userpassword; }
set { _userpassword = value; }
}
private IList _roles;
public virtual IList Roles
{
get { return _roles; }
set { _roles = value; }
}
public User()
{
_userid = 0;
_username = null;
_userpassword = null;
_roles = new ArrayList();
}
}
}
Role类：
―――――――――――――――――――――――
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace NHibernateTest.Model
{
[Serializable]
public class Role
{
private int _roleid;
public virtual int RoleId
{
get { return _roleid; }
set { _roleid = value; }
}
private string _rolename;
public virtual string RoleName
{
get { return _rolename; }
set { _rolename = value; }
}
private IList _users;
public virtual IList Users
{
get { return _users; }
set { _users = value; }
}
public Role()
{
_roleid = 0;
_rolename =null;
_users = new ArrayList();
}
}
}
User类映射文件User.hbm.xml：
-----------------------------------------------------------------------------
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
<class name="NHibernateTest.Model.User,NHibernateTest.Model"
table="T_User">
<id name="UserId" column="Id" type="Int32" unsaved-value="0">
<generator class="native"/>
</id>
<property column="UserName" type="String" name="UserName" not-null="true" length="50" />
<property column="UserPassword" type="String" name="UserPassword" not-null="true" length="50" />
<bag name="Roles" table="T_User_Role" lazy="true">
<!--指定本持久化类（User）在连接表（T_User_Role）中的外键列名UserId，也就是T_User_Role表的UserId -->
<key column="UserId"/>
<!--指定关联类（Role）在连接表（T_User_Role）中的外键列名RoleId -->
<many-to-many class="NHibernateTest.Model.Role,NHibernateTest.Model" column="RoleId"/>
</bag>
</class>
</hibernate-mapping>
Role类映射文件 Role.hbm.xml:
---------------------------------------------------
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
<class name="NHibernateTest.Model.Role,NHibernateTest.Model" table="T_Role">
<id name="RoleId" column="Id" type="Int32" unsaved-value="0">
<generator class="native"/>
</id>
<property column="RoleName" type="String" name="RoleName" not-null="true" length="50" />
<bag name="Users" table="T_User_Role" lazy="true" inverse="true">
<!--指定本持久化类（Role）在连接表（T_User_Role）中的外键列名，也就是T_User_Role表的RoleId-->
<key column="RoleId"/>
<!--指定关联类（User）在连接表（T_User_Role）中的外键列名-->
<many-to-many class="NHibernateTest.Model.User,NHibernateTest.Model" column="UserId"/>
</bag>
</class>
</hibernate-mapping>
实现代码如下：
using System;
using System.Collections;
using System.Collections.Generic;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using NHibernateTest.Model;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;
namespace NHibernateTest
{
/* many-to-many和别的关联映射有所不同。
* 例子中：Role和User没有直接的依赖关系，而是通过一张中间表完成。
* 在删除User时一般不会要求删除Role，而是删除之间的关系
* （即从中间表删除数据）。
*/
public partial class Many_To_Many : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
protected void TestAddRoleToUser_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
User user = session.Load(typeof(User), 4) as User;
Role role = session.Load(typeof(Role), 4) as Role;
user.Roles.Add(role);
role.Users.Add(user);
session.Update(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//移除user和role的关联关系
protected void TestRemoveRoleFromUser_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
//移除user和role的关联关系
User user = session.Load(typeof(User), 5) as User;
Role role = session.Load(typeof(Role), 5) as Role;
user.Roles.Remove(role);
role.Users.Remove(user);
session.Update(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//更新了与UserId＝6关联的Role的RoleName名字
protected void TestUpdateUserWithRole_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
//更新了与UserId＝6关联的Role的RoleName名字
User user = session.Load(typeof(User), 6) as User;
((Role)user.Roles[0]).RoleName = "UpdateRole";
session.Update(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//删除T_User表id＝10的记录和删除了T_User_Role表的UserId＝10的记录
//跟踪Sql：go
/* DELETE FROM T_User_Role WHERE UserId = @p0', N'@p0 int', @p0 = 10
DELETE FROM T_User WHERE Id = @p0', N'@p0 int', @p0 = 10
*/
protected void TestDeleteUserWithSetRole_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
User user = session.Load(typeof(User), 10) as User;
session.Delete(user);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
//添加了User，Role 以及User－Role的关系
protected void TestAddUserAndRole_Click(object sender, EventArgs e)
{
Configuration config = new Configuration();
config.AddAssembly("NHibernateTest.Model");
ISessionFactory sessions = config.BuildSessionFactory();
ISession session = sessions.OpenSession();
ITransaction trans = session.BeginTransaction();
try
{
User user = new User();
user.UserName = "222";
user.UserPassword = "222";
Role role = new Role();
role.RoleName = "秘书";
role.Users.Add(user);
user.Roles.Add(role);
session.Save(user);
session.Save(role);
trans.Commit();
}
catch
{
trans.Rollback();
throw new Exception("失败！");
}
finally
{
session.Close();
}
}
}
}
One－To－Many（单项关联1－N）
因为集合属性都需要保存到另一个数据表中，所以保存集合属性表必须必须包含一个外键列，用于参照主键列。该外键列通过在<Set/>等集合元素中使用<key…/>子元素column来映射。不管使用那种集合，使用<bag../>元素都将映射成无序集合。集合属性对应的表没有主键。
对于1—N的单向关联，需要在1的一端增加对应的集合映射元素。与映射集合类似，必须为<set> ,<bag>等集合元素增加key子元素，用以映射关联外键列。
one-to-many标签包含在标签bag/set中.bag标签的。inverse属性使collection不更新连接。
key标签的column属性指出了在另一个数据库表中加入外键，来关联本类。
T_Parent T_Child
Id Int主键自增 ChildId Int自增
Name String Name String
ParentId T_Parent表Id
Many－To－One
many-to-one：描述多对一的一种数据模型，它指定many一方是不能独立存在的，我个人认为many-to-one是NHB中保证数据有效性的最有用的一种映射，通过使用many-to-one能有效的防治孤儿记录被写入到数据表中。
<many-to-one
name="propertyName"(1)
column="column_name"(2)
class="ClassName"(3)
cascade="all|none|save-update|delete"(4)
unique="true|false" (10)
/>
１．name：属性名。指出many一方的类用哪个属性和one一方的类关联．
２．column：字段名（可选）．指出many一方的类对应的数据表用哪个列和one一方的类对应的数据表关联（两表之间存在外键关联）；
３．class：关联的类的名字（可选 - 默认是通过反射得到属性类型）；
４．cascade：指明哪些操作会从父对象级联到关联的对象（可选）．cascade属性允许下列值：: all, save-update, delete, none. 设置除了none以外的其它值会传播特定的操作到关联的（子）对象中。
5．unique：允许产生外键列唯一约束的数据库定义语言（DDL）（可选）