如何使用Fluent Nhibernate中的Automapping進行OR Mapping映射

由於在項目中使用了NHibernate來作為ORMapping構建數據訪問層，那么就必須要配置Object和DataTable的映射。最早的項目中，我們使用了最傳統的XML配置文件的方式編寫映射關系，但是這樣太麻煩，每次修改class和表時都要去修改對應的XML文件，而且還容易出錯，一定有疏忽遺漏的地方，還不容易找出錯誤，所以在第二個項目中，我們使用了Fluent NHibernate的Mapping方式代替XML配置。使用Fluent NHibernate的最大好處是降低了出錯的機會，因為Fluent Nhibernate的配置是使用C#來編寫，可以智能感知，而且還能編譯，不像原始的XML配置，寫錯了都不知道。

    public sealed class ConfigMapping : ClassMap<Config>
    {
        public ConfigMapping()
        {
            Table("CONFIG");
            Id(x => x.Id, "CONFIG_ID").GeneratedBy.HiLo("1000000000");
             Map(x => x.ConfigKey, "CONFIG_KEY");
             Map(x => x.ConfigValue, "CONFIG_VALUE");
        }
    }

但是使用Fluent NHibernate的配置方式仍然是需要編寫Mapping代碼的，也就意味着，如果我更改class或者DataTable的時候，還要對應的更改該Mapping文件。更多的修改意味着更多的風險，為了減少這方面的風險，同時為了減少配置的工作量，所以在最新的項目中采用了Fluent NHibernate中的Automapping。我們只需要定義好映射的規則，就可以不對每個表和類分別編寫映射配置，而是按照規則進行自動的Mapping工作。這樣在修改class或者DataTable時，只需要修改類和表即可，不需要再修改配置文件。

要做到Automapping，就一定要定義好嚴格的命名規范，然后按照規范編寫Automapping規則，實現自動化的映射。比如我們可以定義如下的規則：

1. 類名和字段名采用每個單詞首字母大寫的方式而數據庫表名和列名使用全部大寫，單詞之間下划線分割的方式。（比如CostCenter類對應表COST_CENTER）
2. 類中的主鍵使用Id命名，表中的主鍵使用表名+“_ID”的命名方式。（比如CostCenter中有public virtual long Id{get;set;}，對應表中的列COST_CENTER_ID）
3. 對於一對多的關系，使用父方的類名作為屬性名，表中使用父表的主鍵列名作為對應的外鍵列的列名。（比如一個班對應多個學生，在Class類中就有public virtual IList<Student> Students{get;set;}，而在Student類中就必須使用Class作為屬性名：public virtual Class Class{get;set;}）
4. 對於SubClass，采用將多個子對象都存在同一個表中的方式實現，使用“TYPE”列作為DiscriminatorColumn，使用之類的類名作為子類的唯一標識。
5. 對於多對多的關系，把兩個類對應的表名進行排序，將小的排前面，然后將兩個表名連接起來，中間使用“_”分割。（比如Course和Student是多對多關系，那么產生的中間表表名為COURSE_STUDENT）
6. 對於枚舉，在數據庫中使用tinyint也就是一個Byte來存儲，枚舉在Automapping中作為UserType進行處理。

下面就來編寫Automapping的轉換規則，首先對String寫一個擴展方法，實現CostCenter到COST_CENTER的轉換：

static string ToDatabaseName(this string s)
 {
        return Regex.Replace(s, @"\B[A-Z]", match => "_" + match.ToString()).ToUpper();
 }

對於1，需要實現IClassConvention實現如下：

public class ClassNameConvention : IClassConvention
{
    public virtual void Apply(IClassInstance instance)
    {
        var tableName = instance.EntityType.Name.ToDatabaseName();
        instance.Table(tableName);
    }
}

同時對於列，需要使用IPropertyConvention接口，實現如下：

public class PropertyConvention : IPropertyConvention
{
    public void Apply(IPropertyInstance instance)
    {
        instance.Column(instance.Name.ToDatabaseName());
    }
}

對於2，需要實現IIdConvention接口，另外我們采用的是Hilo值的主鍵生成方式，使用一個表HIBERNATE_UNIQUE_KEY存儲每個表的流水。具體實現如下：

public class PrimaryKeyConvention : IIdConvention
{
    public const string NextHiValueColumnName = "VALUE";
    public const string NHibernateHiLoIdentityTableName = "HIBERNATE_UNIQUE_KEY";
    public const string TableColumnName = "TABLE_NAME";

    public virtual void Apply(IIdentityInstance instance)
    {
        var tableName = instance.EntityType.Name.ToDatabaseName();
        instance.Column(tableName + "_ID");//這里設置主鍵的命名為表名+“_ID”
        if (instance.Type == typeof(long))//接下來設置主鍵的生成方式為HiLo值方式
        {
            instance.GeneratedBy.HiLo(
                NHibernateHiLoIdentityTableName, 
                NextHiValueColumnName, 
                "1000000000",
                builder => builder.AddParam("where", string.Format("{0} = '{1}'", TableColumnName, tableName)));
        }
    }
}

對於3，一對多的情況，需要設置“一”的一方的Collection和“多”的一方的Reference，具體如下：

public class CollectionConvention : ICollectionConvention
{
    public void Apply(ICollectionInstance instance)
    {
        string colName;
        var entityType = instance.EntityType;
        var childType = instance.ChildType;
        if (entityType == childType)//這里是專門對自身關聯一對多的情況進行特殊處理，統一使用PARENT_ID作為外鍵列
            colName = "PARENT_ID";
        else
        {
            colName = entityType.Name.ToDatabaseName() + "_ID";
        }
        instance.Key.Column(colName);
        instance.Cascade.AllDeleteOrphan();
    }
}

public class ReferenceConvention : IReferenceConvention
{
    public void Apply(IManyToOneInstance instance)
    {
        string colName = null;
        var referenceType = instance.Class.GetUnderlyingSystemType();
        var entityType = instance.EntityType;
        var propertyName = instance.Property.Name;
        //Self association
        if (referenceType == entityType)
            colName = "PARENT_ID";
        else
            colName = propertyName.ToDatabaseName() + "_ID";

        instance.Column(colName);
    }
}

對於4SubClass的處理，需要涉及到指定要進行Discriminate的類，還有DiscriminateColumn，然后指定DiscriminateColumn中如何對Subclass進行Mapping。

這里就需要重寫DefaultAutomappingConfiguration類，在該類中指定主鍵、Discriminate的類等，具體代碼如下：

public class AutoMapConfiguration : DefaultAutomappingConfiguration
{
    public override bool ShouldMap(Type type)
    {
        return (type.IsClass && type.Namespace.StartsWith("OurProject.Core.Model"));//指定了哪些類是要進行AutoMapping的
    }

    public override bool IsId(Member member)
    {
        return member.Name == "Id";//指定了每個類中的Id屬性就是該類的主鍵
    }

    public override bool IsDiscriminated(Type type)//指定了哪些類是需要進行SubClass繼承，將其SubClass都存放在一個表中的。
    {
        return type.In(          
            typeof(Client),
            typeof (Classification),
            typeof (MultiClassification)
            );
    }

    public override string GetDiscriminatorColumn(Type type)
    {
        return "TYPE";//指定了SubClass的區分列就是有一個叫做TYPE的列
    }
}

然后就是關於DiscriminateColumn中的值如何映射成對應的Subclass，需要實現ISubclassConvention接口，代碼如下：

public class SubclassConvention : ISubclassConvention
{
    public void Apply(ISubclassInstance instance)
    {
        instance.DiscriminatorValue(instance.EntityType.Name);
    }
}

對於5多對多，就需要實現IHasManyToManyConvention接口，在這個接口中對兩個表名進行排序，然后進行連接表示中間表。具體代碼如下：

  public class HasManyToManyConvention : IHasManyToManyConvention
    {
        public void Apply(IManyToManyCollectionInstance instance)
        {
            var entityDatabaseName = instance.EntityType.Name.ToDatabaseName();
            var childDatabaseName = instance.ChildType.Name.ToDatabaseName();
            var name = GetTableName(entityDatabaseName, childDatabaseName);//對兩個表名進行排序，然后連接組成中間表名

            instance.Table(name);
            instance.Key.Column(entityDatabaseName + "_ID");
            instance.Relationship.Column(childDatabaseName + "_ID");
        }

        private string GetTableName(string a, string b)
        {
            var r = System.String.CompareOrdinal(a, b);
            if (r > 0)
            {
                return "{0}_{1}".Fill(b, a);
            }
            else
            {
                return "{0}_{1}".Fill(a, b);
            }
        }
    }

對於6枚舉的處理，需要指定枚舉為UserType，實現接口IUserTypeConvention，具體代碼如下：

public class EnumConvention : IUserTypeConvention
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.Property.PropertyType.IsEnum);
    }

    public void Apply(IPropertyInstance instance)
    {
        instance.CustomType(instance.Property.PropertyType);
    }
}

實現了以上這幾個接口，那么大部分情況下的Automapping都可以實現了。最后是將這些接口通知給FluentNhibernate，讓其應用這些接口，導入指定Assembly中的DomainModel，具體的實現方法是：

public virtual AutoPersistenceModel Generate(string[] domainAssemblies, string[] dalAssemblies)
{
    var mappings = AutoMap.Assemblies(
        new AutoMapConfiguration(), domainAssemblies.Select(Assembly.LoadFrom).ToArray());

    foreach (var ignoredBaseType in IgnoredBaseTypes)
    {
        mappings.IgnoreBase(ignoredBaseType);
    }
    foreach (var includeBaseType in IncludeBaseTypes)
    {
        mappings.IncludeBase(includeBaseType);
    }

    mappings.Conventions.Setup(GetConventions());//指定了Automapping轉換的接口實現


    foreach (var dalAssembly in dalAssemblies)
    {
        mappings.UseOverridesFromAssembly(Assembly.LoadFrom(dalAssembly));
    }

    return mappings;
}
public static IList<Type> IgnoredBaseTypes = new List<Type>//這里列出的類都是些Base類，不會Mapping到具體某個表
                                                 {
                                                     typeof (Entity) //該對象其實就只有Id這個屬性，作為所有要Mapping的類的父類
                                                 };
public static IList<Type> IncludeBaseTypes = new List<Type>//默認情況下抽象類是不會Mapping成表的，所以這里需要指明這些類是要Mapping成表的
                                                 {
                                                     typeof (Classification),
                                                     typeof (MultiClassification),
                                                     typeof(Client)
                                                 };
protected Action<IConventionFinder> GetConventions()
{
    return finder =>
               {
                   finder.Add<ClassNameConvention>();
                   finder.Add<PrimaryKeyConvention>();
                   finder.Add<CollectionConvention>();
                   finder.Add<ReferenceConvention>();
                   finder.Add<HasManyConvention>();
                   finder.Add<SubClassNameConvention>();
                   finder.Add<SubclassConvention>();
                   finder.Add<PropertyConvention>();
                   finder.Add<EnumConvention>();
                   finder.Add<HasManyToManyConvention>();
               };
}

該方法返回了一個AutoPersistenceModel，使用這個對象注冊到NHibernate中即可。

PS:以上代碼主要都是同事在前期實現的，我只是在后期接手了該工作，在此基礎上做了一些簡單的維護和修改。