之前写过几篇关于聚合对象SQL的文章，讲的是如果设计框架，使用一句SQL语句来加载整个聚合对象树中的所有数据。相关内容，参见：《性能优化总结（二）：聚合SQL》、《性能优化总结（三）：聚合SQL在GIX4中的应用》。由于没有使用其它的ORM框架，当时项目组决定做聚合SQL，主要是为了减少SQL查询的次数，来提升部分模块的性能。现在看来，当时虽然达到了这个目标，但是聚合SQL的API却不简单，使用极为不便。至今，项目组中的其它人也不会使用。所以，这次我们决定把聚合SQL的API使用再次进行封装，以达到使用起来更简便的效果。
本文中的内容与前面几篇的内容、与OEA框架中的内容相关性比较大，有兴趣的朋友可以关注CodePlex中的项目：《OpenExpressApp》
结果对比
优化前的代码，在前面的文章中已经有所展示。这里主要看一下优化过后的代码：
最简单的聚合SQL生成：
var sqlSimple = AggregateSQL.Instance.GenerateQuerySQL<PBS>(
option => option.LoadChildren(pbs => pbs.PBSBQItems),
pbsTypeId
);
这样就生成了如下SQL：
SELECT
pbs0.pid as PBS_pid, pbs0.pbstypeid as PBS_pbstypeid, pbs0.code as PBS_code, pbs0.name as PBS_name, pbs0.fullname as PBS_fullname, pbs0.description as PBS_description, pbs0.pbssubjectid as PBS_pbssubjectid, pbs0.orderno as PBS_orderno, pbs0.id as PBS_id,
pbsbqi1.pbsid as PBSBQItem_pbsid, pbsbqi1.code as PBSBQItem_code, pbsbqi1.name as PBSBQItem_name, pbsbqi1.unit as PBSBQItem_unit, pbsbqi1.bqdbid as PBSBQItem_bqdbid, pbsbqi1.id as PBSBQItem_id
FROM PBS AS pbs0
LEFT OUTER JOIN PBSBQItem AS pbsbqi1 ON pbsbqi1.PBSId = pbs0.Id
WHERE pbs0.PBSTypeId = '084a7db5-938a-4c7b-8d6a-612146ad87f9'
ORDER BY pbs0.Id, pbsbqi1.Id
该SQL用于加载聚合根对象PBSType下的所有PBS子对象，同时每个PBS的子对象PBSBQItems也都被同时查询出来。
再进一步，我们还可以直接使用聚合关系加载出对象，而不需要SQL，如：
var pbsList = AggregateSQL.Instance.LoadEntities<PBS>(
option => option.LoadChildren(pbs => pbs.PBSBQItems),
pbsTypeId
);var projectPBSs = AggregateSQL.Instance.LoadEntities<ProjectPBS>(loadOptions =>
loadOptions.LoadChildren(pp => pp.ProjectPBSPropertyValues)
.Order<ProjectPBSPropertyValue>().By(v => v.PBSProperty.OrderNo)
.LoadFK(v => v.PBSProperty).LoadChildren(p => p.PBSPropertyOptionalValues),
criteria.ProjectId
);
总体设计
本次设计，主要是以提高模块的易用性为目的。
在原有的设计中，主要有两个步骤，生成聚合SQL 和 从大表中加载聚合对象。这两个过程是比较独立的。它们之间耦合的地方有两个。首先，是为表生成什么样的列名，生成SQL时按照这种列名的约定进行生成，加载对象时则在大表中找对应列的数据。其次，它们还隐含耦合一些说明性的数据，这些数据指明了需要加载哪些子属性或者外键，什么样的加载关系，对应一个什么样的聚合SQL，也就对应加载出来的对象。
也就是说，上述两个过程需要完整的封装起来，我们需要管理好这两个部分。而列名的生成在原来的模式中已经使用了“表名+列名”的格式进行了约定，所以现在我们只需要把“描述如何加载的描述性数据”进行管理就可以了。有了这些数据，则可以在框架内部生成聚合SQL，在框架内部按照它们进行大表到聚合对象的加载。以下，我将这些数据称为聚合对象的“加载选项”。
同时，考虑到聚合SQL生成的复杂性及使用的2/8原则，这次的聚合SQL自动生成和加载只处理比较简单的情况：只处理简单的链式的加载。例如：A对象作为Root的子对象，它还有子对象B、C，B有子对象D、E，D有外键引用对象F、F有子对象G，那么，只处理链式的加载意味着，最多可以在加载某个Root对象的A集合的同时，带上A.B、B.C、C.D、D.F、F.G。
如上图所示，在加载A.B的时候，不支持加载A.C；同理，加载B.D的时候，不支持加载B.E。其实在实际运用当中，这样的局限性在使用的时候并没有太大的问题，一是较多的使用场景不需要同时加载所有的子，二是可以分两条线加载对象后，再使用对象进行数据的融合。
核心数据结构 - 加载选项
上面已经说明了加载选项是整个聚合SQL加载的描述数据，描述如何生成SQL，描述如何加载对象。它其实也就是整个过程中的核心对象，由于时间有限（预计只有一天时间完成整个设计及代码实现），而且这个对象并不会直接暴露在外面，所以这直接使用了最简单的链表类型来表示链式的加载选项。（老实说，这个设计的扩展性并不好。）
/// <summary>
/// 聚合加载描述器。
///
/// 目前只包含一些聚合加载选项“AggregateSQLItem”
/// </summary>
internal class AggregateDescriptor
{
private LinkedList<LoadOptionItem> _items = new LinkedList<LoadOptionItem>();
/// <summary>
/// 所有的AggregateSQLItem
/// </summary>
internal LinkedList<LoadOptionItem> Items
{
get
{
return _items;
}
}
/// <summary>
/// 直接加载的实体类型
/// </summary>
internal Type DirectlyQueryType
{
get
{
return this._items.First.Value.OwnerType;
}
}
/// <summary>
/// 追加一个聚合加载选项
/// </summary>
/// <param name="item"></param>
internal void AddItem(LoadOptionItem item)
{
this._items.AddLast(item);
}
}
而它包含的每一个元素 LoadOptionItem 则表示一个加载项，它主要包含一个属性的元数据，用于表示要级联加载的子对象集合属性或者外键引用对象属性。
/// <summary>
/// 生成聚合SQL的加载项中的某一项
/// </summary>
[DebuggerDisplay("{OwnerType.Name}.{PropertyEntityType.Name}")]
internal class LoadOptionItem
{
private Action<Entity, Entity> _fkSetter;
/// <summary>
/// 加载这个属性。
/// </summary>
internal IPropertyInfo PropertyInfo { get; private set; }
internal Func<Entity, object> OrderBy { get; set; }
/// <summary>
/// 指标这个属性是一般的实体
/// </summary>
internal AggregateLoadType LoadType
{
get
{
return this._fkSetter == null ? AggregateLoadType.Children : AggregateLoadType.ReferenceEntity;
}
}
//.......
}
/// <summary>
/// 属性的加载类型
/// </summary>
internal enum AggregateLoadType
{
/// <summary>
/// 加载子对象集合属性
/// </summary>
Children,
/// <summary>
/// 加载外键引用实体。
/// </summary>
ReferenceEntity
}
对象加载
按照上面的加载选项的链式设计，SQL生成其实就比较简单了：列名生成还是使用原有的方法，其它部分则只需要按照元数据进行链式生成就行了。花些时间就搞定了。
框架中对象的聚合加载的实现，和手写时一样，也是基于原有的ReadFromTable方法的，也不复杂，贴下代码，不再一一描述：
/// <summary>
/// 聚合实体的加载器
/// </summary>
internal class AggregateEntityLoader
{
private AggregateDescriptor _aggregateInfo;
internal AggregateEntityLoader(AggregateDescriptor aggregate)
{
if (aggregate == null) throw new ArgumentNullException("aggregate");
if (aggregate.Items.Count < 1) throw new InvalidOperationException("aggregate.Items.Count < 2 must be false.");
this._aggregateInfo = aggregate;
}
/// <summary>
/// 通过聚合SQL加载整个聚合对象列表。
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
internal EntityList Query(string sql)
{
IGTable dataTable = null;
IDbFactory dbFactory = this._aggregateInfo.Items.First.Value.OwnerRepository;
using (var db = dbFactory.CreateDb())
{
dataTable = db.QueryTable(sql);
}
//使用dataTable中的数据 和 AggregateDescriptor 中的描述信息，读取整个聚合列表。
var list = this.ReadFromTable(dataTable, this._aggregateInfo.Items.First);
return list;
}
/// <summary>
/// 根据 optionNode 中的描述信息，读取 table 中的数据组装为对象列表并返回。
///
/// 如果 optionNode 中指定要加载更多的子/引用对象，则会递归调用自己实现聚合加载。
/// </summary>
/// <param name="table"></param>
/// <param name="optionNode"></param>
/// <returns></returns>
private EntityList ReadFromTable(IGTable table, LinkedListNode<LoadOptionItem> optionNode)
{
var option = optionNode.Value;
var newList = option.OwnerRepository.NewList();
newList.ReadFromTable(table, (row, subTable) =>
{
var entity = option.OwnerRepository.Convert(row);
EntityList listResult = null;
//是否还有后继需要加载的对象？如果是，则递归调用自己进行子对象的加载。
var nextNode = optionNode.Next;
if (nextNode != null)
{
listResult = this.ReadFromTable(subTable, nextNode);
}
else
{
listResult = this.ReadFromTable(subTable, option.PropertyEntityRepository);
}
//是否需要排序？
if (listResult.Count > 1 && option.OrderBy != null)
{
listResult = option.PropertyEntityRepository.NewListOrderBy(listResult, option.OrderBy);
}
//当前对象是加载类型的子对象还是引用的外键
if (option.LoadType == AggregateLoadType.Children)
{
listResult.SetParentEntity(entity);
entity.LoadCSLAProperty(option.CslaPropertyInfo, listResult);
}
else
{
if (listResult.Count > 0)
{
option.SetReferenceEntity(entity, listResult[0]);
}
}
return entity;
});
return newList;
}
/// <summary>
/// 简单地从table中加载指定的实体列表。
/// </summary>
/// <param name="table"></param>
/// <param name="repository"></param>
/// <returns></returns>
private EntityList ReadFromTable(IGTable table, EntityRepository repository)
{
var newList = repository.NewList();
newList.ReadFromTable(table, (row, subTable) => repository.Convert(row));
return newList;
}
}
美化的API
基于以上的基础，我们需要一个流畅的API来定义加载选项。这一点对于一个框架设计人员来说，往往很重要，只有流畅、易用的API才能对得起你的客户：框架使用者。以下我只把给出几个为达到流畅API而特别设计的类。其中，用到了《小技巧 - 简化你的泛型API》中提到的设计原则。
/// <summary>
/// 存储了加载选项项
/// </summary>
public abstract class LoadOptionSelector
{
internal LoadOptionSelector(AggregateDescriptor descriptor)
{
_descriptor = descriptor;
}
private AggregateDescriptor _descriptor;
internal AggregateDescriptor InnerDescriptor
{
get
{
return _descriptor;
}
}
}
/// <summary>
/// 属性选择器
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public class PropertySelector<TEntity> : LoadOptionSelector
where TEntity : Entity
{
internal PropertySelector(AggregateDescriptor descriptor) : base(descriptor) { }
/// <summary>
/// 需要同时加载外键
/// </summary>
/// <typeparam name="TFKEntity"></typeparam>
/// <param name="fkEntityExp">
/// 需要加载的外键实体属性表达式
/// </param>
/// <returns></returns>
public PropertySelector<TFKEntity> LoadFK<TFKEntity>(Expression<Func<TEntity, TFKEntity>> fkEntityExp)
where TFKEntity : Entity
{
var entityPropertyName = GetPropertyName(fkEntityExp);
var propertyName = entityPropertyName + "Id";
IEntityInfo entityInfo = ApplicationModel.GetBusinessObjectInfo(typeof(TEntity));
var propertyInfo = entityInfo.BOPropertyInfos.FirstOrDefault(p => p.Name == propertyName);
//构造一个临时代理方法，实现：TEntity.EntityProperty = TFKEntity
var pE = System.Linq.Expressions.Expression.Parameter(typeof(TEntity), "e");
var pEFK = System.Linq.Expressions.Expression.Parameter(typeof(TFKEntity), "efk");
var propertyExp = System.Linq.Expressions.Expression.Property(pE, entityPropertyName);
var body = System.Linq.Expressions.Expression.Assign(propertyExp, pEFK);
var result = System.Linq.Expressions.Expression.Lambda<Action<TEntity, TFKEntity>>(body, pE, pEFK);
var fkSetter = result.Compile();
var option = new LoadOptionItem(propertyInfo, (e, eFK) => fkSetter(e as TEntity, eFK as TFKEntity));
//避免循环
if (this.InnerDescriptor.Items.Any(i => i.OwnerType == option.PropertyEntityType))
{
throw new InvalidOperationException("有循环的实体设置。");
}
this.InnerDescriptor.AddItem(option);
return new PropertySelector<TFKEntity>(this.InnerDescriptor);
}
/// <summary>
/// 需要同时加载孩子
/// </summary>
/// <typeparam name="TChildren"></typeparam>
/// <param name="propExp">
/// 需要加载的孩子属性表达式
/// </param>
/// <returns></returns>
public ChildrenSelector LoadChildren<TChildren>(Expression<Func<TEntity, TChildren>> propExp)
where TChildren : EntityList
{
var propertyName = GetPropertyName(propExp);
IEntityInfo entityInfo = ApplicationModel.GetBusinessObjectInfo(typeof(TEntity));
var propertyInfo = entityInfo.BOsPropertyInfos.FirstOrDefault(p => p.Name == propertyName);
this.InnerDescriptor.AddItem(new LoadOptionItem(propertyInfo));
return new ChildrenSelector(this.InnerDescriptor);
}
private static string GetPropertyName<TProperty>(Expression<Func<TEntity, TProperty>> propExp)
{
var member = propExp.Body as MemberExpression;
var property = member.Member as PropertyInfo;
if (property == null) throw new ArgumentNullException("property");
var propertyName = property.Name;
return propertyName;
}
}
/// <summary>
/// 孩子选择器
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public class ChildrenSelector : LoadOptionSelector
{
internal ChildrenSelector(AggregateDescriptor descriptor) : base(descriptor) { }
public OrderByLoadOption<TEntity> Order<TEntity>()
where TEntity : Entity
{
return new OrderByLoadOption<TEntity>(this.InnerDescriptor);
}
/// <summary>
/// 把孩子集合转换为实体对象，需要继续加载它的子对象
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
public PropertySelector<TEntity> Continue<TEntity>()
where TEntity : Entity
{
return new PropertySelector<TEntity>(this.InnerDescriptor);
}
}
public class OrderByLoadOption<TEntity> : LoadOptionSelector
where TEntity : Entity
{
internal OrderByLoadOption(AggregateDescriptor descriptor) : base(descriptor) { }
public PropertySelector<TEntity> By<TKey>(Func<TEntity, TKey> keySelector)
{
this.InnerDescriptor.Items.Last.Value
.OrderBy = e => keySelector(e as TEntity);
return new PropertySelector<TEntity>(this.InnerDescriptor);
}
}
小结
本次重构由于只处理“链式的加载选项”，所以实现并不复杂。同时，由于把Repository都临时存放在了LoadOptionItem中，使得Repository的获取不再浪费，印证了：“一个重构后良好结构的程序，性能很有可能会有所提升。”
扫一扫
131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
