nhibernate: 会话与持久化操作

nhibernate: 会话与持久化操作

会话是nhibernate中的主要接口，也是我们进行持久化操作和数据加载的主要接口，ISession在IClassPersister、ITransaction、ICriteria和IQuery之间起着协调者的作用。

会话对象通过调用会话工厂的OpenSession方法获得，OpenSession方法有一个参数interceptor，这是一个拦截器，由实现了IInterceptor接口的对象来完成，比较典型的是对会话的操作进行日志记录。

1. 持久对象的状态

持久对象的状态由EntityEntry类来维护。

sealed internal class EntityEntry  {
   private LockMode _lockMode;
   private Status _status;
   private object _id;
   private object[] _loadedState;
   private object[] _deletedState;
   private bool _existsInDatabase;
   private object _version;
   // for convenience to save some lookups
   [NonSerialized] private IClassPersister _persister;
   private string _className;
   // 
}

private IDictionary entitiesByKey; //key=Key, value=Object
entitiesByKey集合保存当前会话中的所有持久对象。

[NonSerialized] private IdentityMap entries;//key=Object, value=Entry
entries集合维护当前会话中所有持久对象的状态，entries中的项目和entitiesByKey中的项目是一一对应的。

2. 持久化操作

当执行持久化操作时(Save/Update/Delete)，除了少数情况外，持久化操作并没有立即执行(更新数据源)，而是被记录下来，直到会话Flush时才会实际更新到数据源，这样做的原因很容易理解，就是为了避免频烦的数据库连接操作。如果没有调用Flush而关闭了会话，当前会话中的持久对象将不会持久化！

SessionImpl.cs中有三个集合用来记录要持久化的计划对象:

[NonSerialized] private ArrayList insertions;
记录所有的ScheduledInsertion对象，ScheduledInsertion对象是通过要Save的持久对象创建的，如果对象的标识必须从数据库获得(如Identity标识)，那么并不会创建ScheduledInsertion对象，而是立即执行Save操作，原因很简单，因为必须取得Identity标识；

[NonSerialized] private ArrayList updates;
记录所有的ScheduledUpdate对象，ScheduledUpdate对象是通过要Update的持久对象创建的；

[NonSerialized] private ArrayList deletions;
记录所有的ScheduledDeletion对象，ScheduledDeletion对象是通过要Delete的持久对象创建的;

以上三个计划对象都从ScheduledEntityAction对象继承，而此对象实现了IExecutable接口，IExecutable接口的Execute方法用于执行执久化操作，此操作由Flush间接调用。

下面来看看Flush的代码:

 

public void Flush() {
   if (cascading>0) throw new HibernateException( "" );
   FlushEverything();
   Execute(); 
   PostFlush();
}

Execute执行所有的计划对象。

private void Execute() {
   log.Debug("executing flush");
   try {
      ExecuteAll( insertions );
      insertions.Clear();
      ExecuteAll( updates );
      updates.Clear();

      //

      ExecuteAll( deletions );
      deletions.Clear();
   } 
   catch (Exception e) {
      throw new ADOException("", e);
   }
}

分别执行insert/update/delete计划。
private void ExecuteAll(ICollection coll) {
   foreach(IExecutable e in coll) {
      executions.Add(e);
      e.Execute();
   }  
   if ( batcher!=null ) batcher.ExecuteBatch();
}

3. Save

ISession有两种保存持久对象的方法，区别在于有没有指定对象Id(标识符)。 

public object Save(object obj) {
   if (obj==null) throw new NullReferenceException("attempted to save null");

   if ( !NHibernate.IsInitialized(obj) ) 
      throw new PersistentObjectException("uninitialized proxy passed to save()"); 
   object theObj = UnproxyAndReassociate(obj); 

   EntityEntry e = GetEntry(theObj);
   if ( e!=null ) {
      if ( e.Status==Status.Deleted) {
         Flush();
      } 
      else {
        log.Debug( "object already associated with session" );
        return e.Id;
      }
   }

   object id;
   try {
      id = GetPersister(theObj).IdentifierGenerator.Generate(this, theObj);
      if( id == (object) IdentifierGeneratorFactory.ShortCircuitIndicator) 
         return GetIdentifier(theObj); //TODO: yick!
   } 
   catch (Exception ex) {
      throw new ADOException("Could not save object", ex);
   }

   return DoSave(theObj, id);
}

先取得持久对象的状态，如为删除则flush；然后取得持久对象的id(标识符)，最后调用DoSave方法。
有关持久对象的标识符请参考我的下一篇文章 《持久对象标识符》。

public void Save(object obj, object id) {

   if (obj==null) throw new NullReferenceException("attemted to insert null");
   if (id==null) throw new NullReferenceException("null identifier passed to insert()");

   if ( !NHibernate.IsInitialized(obj) ) throw new PersistentObjectException("uninitialized proxy passed to save()"); 
   object theObj = UnproxyAndReassociate(obj); 

   EntityEntry e = GetEntry(theObj);
   if ( e!=null ) {
      if ( e.Status==Status.Deleted ) {
         Flush();
      } 
      else {
         if ( !id.Equals(e.Id) ) 
            throw new PersistentObjectException("");
      }
   }
   DoSave(theObj, id);
}

与前一个Save方法不同的是，不用取得持久对象的id，显然这个方法适用于对象标识符已知的情况，这样会提高一些性能。

private object DoSave(object obj, object id) {
   IClassPersister persister = GetPersister(obj);

   Key key = null;
   bool identityCol;

   if (id==null) {
      if ( persister.IsIdentifierAssignedByInsert ) {
         identityCol = true;
      } 
      else {
         throw new AssertionFailure("null id");
      }
   } 
   else {
      identityCol = false;
   }

   if (!identityCol) { 
      // if the id is generated by the db, we assign the key later
      key = new Key(id, persister);
      object old = GetEntity(key);
      if (old!=null) {
         if ( GetEntry(old).Status==Status.Deleted) {
            Flush();
         } 
         else {
            throw new HibernateException( "") );
         }
      }
      persister.SetIdentifier(obj, id);
   }

   // 

   // Put a placeholder in entries, 
   AddEntry(obj, Status.Saving, null, id, null, LockMode.Write, identityCol, persister);

   // cascade-save to many-to-one BEFORE the parent is saved
   // 

   // set property values 
   if (identityCol) {
      try {
         id = persister.Insert(values, obj, this);
      } 
      catch (Exception e) {
         throw new ADOException("Could not insert", e);
      }
      key = new Key(id, persister);
      if ( GetEntity(key) != null ) 
         throw new HibernateException("");
      persister.SetIdentifier(obj, id);
   }

   AddEntity(key, obj);
   AddEntry(obj, Status.Loaded, values, id, Versioning.GetVersion(values, persister), LockMode.Write, identityCol, persister);
   
   if (!identityCol) insertions.Add( new ScheduledInsertion( id, values, obj, persister, this ) );

   // cascade-save to collections AFTER the collection owner was saved
   // 
  
   return id;
}

DoSave方法首先判断id是否为赋值的(assign)，然后将持久对象加入到当前会话的集合中。
如果id为identity类型的，则直接调用持久对象的持久化类来插入数据，否则将持久对象加入到insertions集合中，直到调用Flush时才插入数据。

4. Update

Update的处理基本上同Create是类似的，但值得注意的是Update方法并没有将持久对象加入到updates集合中，而是在执行Flush的时候通过判断持久对象的属性来决定持久对象是否需要Update。

5. Delete

Delete的处理比较复杂一些，包括处理集合和级联，这里就不贴出代码了。关于集合和级联处理我会在后续文章中进行分析。