【翻译】How-To: Using the N* Stack, part 3

原文地址：http://jasondentler.com/blog/2009/08/how-to-using-the-n-stack-part-3/ 
Java – 一种代码松散的XML

在我们学习 Fluent NHibernate 之前, 应该先了解下老式的 NHibernate 映射文件应该是怎样写的。 在一个典型的 NHibernate 配置中，你会有很多类似这样的映射文件：

1. <?xml version="1.0" encoding="utf-8" ?>
2. <hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
3.     <class name="NStackExample.Address, NStackExample.Core" table="Address">
4.         <composite-id>
5.             <key-many-to-one name="Person" class="NStackExample.Person, NStackExample.Core" column="ID" />
6.             <key-property name="Type" type="Int32" />
7.         </composite-id>
8.         <property name="City" type="String" length="255" />
9.         <property name="Lines" type="String" length="255" />
10.         <property name="State" type="String" length="2" />
11.         <property name="Zip" type="String" length="10" />
12.     </class>
13. </hibernate-mapping>

复制代码

你必须为每一个实体类配置一个这样的映射文件，这种做法是从 Java 的 Hibernate 中遗留下来的。在我看来，这么做是非常痛苦的，不过幸运的是，有一个好办法来解决这个问题。
更好的选择: Fluent Mappings

有了 Fluent NHibernate ，上面的映射文件就可以用下面这个类来代替：

1. using FluentNHibernate.Mapping;
3. namespace NStackExample.Data
4. {
6.     public class AddressMapping : ClassMap
7.     {
9.         public AddressMapping()
10.         {
11.             UseCompositeId()
12.                 .WithKeyReference(x => x.Person)
13.                 .WithKeyProperty(x => x.Type);
14.             Map(x => x.Lines).WithLengthOf(255);
15.             Map(x => x.City).WithLengthOf(255);
16.             Map(x => x.State).WithLengthOf(2);
17.             Map(x => x.Zip).WithLengthOf(5);
18.         }
20.     }
21. }

复制代码

看起来这个类可能比之前的映射文件还要复杂，但是因为有智能感知，我们能轻而易举的完成，并且我们不用担心魔字符串(magic strings)的问题。当你使用重构工具来改变属性名称的时候，你的映射文件也会同步改变。
现在大家都知道基本的概念了吧，那么让我们继续。
Where?

因为数据库连接、 NHibernate 配置、实体类映射和 DAO 的实现只是我们选择的ORM的执行细节，所以应该把他们放到一个单独的程序集中。

• 创建一个新的类库项目，名字叫做：NStackExample.Data 。
  
• 添加新项目的引用，将 Core 项目，NHibernate.dll 和 FluentNHibernate.dll 添加进去。
  
• 为了以后我们能轻松的检索一些应用程序的设置，将System.Configuration.dll 也添加进去。
  
• 此外，在我们的 Web 项目中也需要将新建的项目添加到引用当中。
  

下面让我们来完成我们的映射文件。

1. using NStackExample;
2. using FluentNHibernate.Mapping;
4. namespace NStackExample.Data
5. {
6.     public class CourseMapping : ClassMap<Course>
7.     {
8.         public CourseMapping()
9.         {
10.             Id(x => x.ID).GeneratedBy.GuidComb();
11.             Map(x => x.CourseNumber)
12.                 .Not.Nullable()
13.                 .WithLengthOf(4)
14.                 .UniqueKey("CourseNaturalKey");
15.             Map(x => x.Subject)
16.                 .Not.Nullable()
17.                 .WithLengthOf(4)
18.                 .UniqueKey("CourseNaturalKey");
19.             Map(x => x.Title)
20.                 .Not.Nullable()
21.                 .WithLengthOf(255);
22.             Map(x => x.Description)
23.                 .Not.Nullable()
24.                 .WithLengthOf(1024);
25.             Map(x => x.Hours)
26.                 .Not.Nullable();
28.             HasMany(x => x.Sections)
29.                 .AsSet()
30.                 .WithForeignKeyConstraintName("CourseSections");
31.         }
32.     }
33. }

复制代码

上面的代码非常容易理解，最后得到的就是我们需要的映射文件。
我们的映射类继承自 ClassMap ，ClassMap 类是 Fluent NHibernate 搜索查找映射时的具体类型。在这里，这个类提供了 Course 实体类的映射。在构造函数中，我们定义了每个属性的具体映射。

• 将 Id 设置成持久化对象标示符(POID)，基本上这就是数据表的主键。对于有多个属性的主键，请参照我们上面 AddressMapping 示例中的 UseCompositeId 。我不建议使用多重主键，并且据我所知，Fluent NHibernate 也不支持多重主键。
  
• GeneratedBy 是用来指定 POID 生成策略。在这里我们使用的是 GuidComb 。使用 GUID 做主键有非常多的好处，具体的内容大家可以参考 Davy Brion在NHForge博客上发表的随笔。
  
• Map 只是将属性映射到数据库的列上。如果有需要的话，你可以指定 Not.Nullable 和 WithLengthOf 。
  
• UniqueKey 指定了列的唯一索引。如果你对多个列指定了相同的名称，那么这些列都会变为这个唯一索引的一部分。在这个示例中，我们强制要求我们的自然键是唯一的。每个 subject 和 course number 都必须是唯一的。
  
• HasMany 是定义了一个一对多的关系，你可以指定集合的确切行为。在这里有 Set 和 Bag 两个选项。
  
  
  
  • AsSet 不允许重复的项目
    
  • AsBag 允许重复的项目
    
  
  

默认情况下，所有关系都是延迟加载的。就是说当你从数据库中获取到了 course ，和其相关联的 sections 并不是马上获取出来，而是直到当你访问该属性的时候才会被加载进来，如果你从未访问过该属性的话，那么它永远都不会被加载，这样可以大大的提高性能。这些功能都是用代理来实现的。
下面容我们来映射 sections:

1. using NStackExample;
2. using FluentNHibernate.Mapping;
4. namespace NStackExample.Data
5. {
6.     public class SectionMapping : ClassMap<Section>
7.     {
8.         public SectionMapping()
9.         {
10.             Id(x => x.ID).GeneratedBy.GuidComb();
11.             Map(x => x.FacultyName)
12.                 .WithLengthOf(255);
13.             Map(x => x.RoomNumber)
14.                 .WithLengthOf(10);
15.             Map(x => x.SectionNumber)
16.                 .WithLengthOf(4)
17.                 .Not.Nullable()
18.                 .UniqueKey("SectionNaturalKey");
20.             References(x => x.Course)
21.                 .Not.Nullable()
22.                 .UniqueKey("SectionNaturalKey");
24.             References(x => x.Term)
25.                 .Not.Nullable()
26.                 .UniqueKey("SectionNaturalKey");
28.             HasMany(x => x.StudentSections)
29.                 .AsSet()
30.                 .WithForeignKeyConstraintName("SectionStudentSections");
31.         }
32.     }
33. }

复制代码

在这里引入了多对一关系的映射，可以把它看成一对多关系的另一边。 本示例中就是从孩子 section 到它的父亲 course 的关系。
练习：完成所有实体类的映射。
到这里或许你会在想这个系列是不是会很长很长呢？到现在我们甚至连数据库都还没有开始建立。不用担心，这些事 NHibernate 会帮我们做的。
8小时 or 8分钟?

在我没有使用 NHibernate 之前，我至少需要一天的时间来建立数据库。这让我很郁闷，估计大家也一样很不喜欢浪费这么多时间去建立数据库。不过，这样的事情将在今天结束。
声明: 如果你尝试使用现有的旧版数据库和数据库架构，没有什么调整的机会或者很渺茫，Fabio Maulo 的这篇随笔 将告诉你如何选择。
首先，让我们配置 NHibernate 。在 Fluent NHibernate Wiki 上 有一篇非常好的文章

介绍了应该如何配置。

1. using FluentNHibernate.Cfg;
2. using FluentNHibernate.Cfg.Db;
3. using NHibernate;
4. using NHibernate.Cfg;
5. using NHibernate.Tool.hbm2ddl;
6. using System.IO;
7. using System.Configuration;
9. namespace NStackExample.Data
10. {
11.     public class Configuration
12.     {
14.         private ISessionFactory m_Factory;
15.         private string m_SchemaPath;
17.         public Configuration Configure()
18.         {
20.             m_SchemaPath = ConfigurationManager.AppSettings["NStackExample.Data.Configuration.SchemaPath"];
22.             m_Factory = Fluently.Configure()
23.                 .Database(MsSqlConfiguration.MsSql2005
24.                         .ConnectionString(
25.                          x => x.FromConnectionStringWithKey("NStackExample.Data.Configuration.Db")))
26.                 .Mappings(x => x.FluentMappings.AddFromAssemblyOf<CourseMapping>()
27.                                 .ExportTo(m_SchemaPath))
28.                 .ExposeConfiguration(BuildSchema)
29.                 .BuildSessionFactory();
31.             return this;
32.         }
34.         private void BuildSchema(NHibernate.Cfg.Configuration cfg)
35.         {
36.             SchemaExport SchemaExporter = new SchemaExport(cfg);
37.             SchemaExporter.SetOutputFile(Path.Combine(m_SchemaPath, "schema.sql"));
38.             SchemaExporter.Create(true, false);
39.         }
41.         public ISession OpenSession()
42.         {
43.             if (m_Factory == null) Configure();
44.             return m_Factory.OpenSession();
45.         }
46.     }
47. }

复制代码

配置分为两个部分：数据库和映射。在本示例中，数据库使用的是 SQL 2005，连接字符串是从 Web.config 文件中读取的。 所有的映射部分都是从
fluent 中读取的，没有自动映射。注意，我们出口的映射是在 web.config 文件的 appsettings 节中指定的一个目录，这会将我们 fluent 的映射分别转换成 hbm.xml文件。这么做是为了方便我们映射部分的调试，尤其是在需要 NHibernate 在线帮助的时候。
这里有个附加项，我们使用 ExposeConfiguration 方法调用 BuildSchema 函数来完成对 NHibernate 的配置。
在 BuildSchema 中，我们使用NHibernate中非常好的一个工具：schema export 。这个工具将会帮助我们创建数据库。构造函数接受两个布尔值的参数。第一个参数指定是否输出 DDL 文件 -- 一个包含所有表、键、索引和关系的数据库脚本。 第二个参数指定了是否将脚本应用到指定的数据库上。
非常简单吧。
两个警告:

• 执行脚本将删除并创建和你的 Model 相关的每一个表，这对已有的环境可能是极具破坏性的操作。
  
• 脚本一般不会带有“use [databasename]”语句，所以你如果不小心执行了，可能会建立到 master 数据库中，在执行脚本的时候请注意选择数据库。
  

在下篇教程当中，我们将介绍如何对你的映射进行测试，包括读取、查询和写入数据库。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！