Hibernate--Increment和Hilo主键生成策略原理

       最近项目中遇到集群问题，比如我们有两个集群节点，在正常情况下只有一个节点工作（A），当出现异常时切换到另一个集群节点（B）上。项目中使用Hibernate的increment作为数据库主键生成策略。它的原理如下：
Hibernate初始化完成后，当获取主键时，会查询一次数据库将最大的Id查询出来，之后的操作就全部是在内存中维护主键的自增，保存时更新到数据库，其源码如下：

package org.hibernate.id;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.exception.JDBCExceptionHelper;
import org.hibernate.jdbc.Batcher;
import org.hibernate.mapping.Table;
import org.hibernate.type.Type;
import org.hibernate.util.StringHelper;

public class IncrementGenerator
  implements IdentifierGenerator, Configurable
{
  private static final Log log = LogFactory.getLog(IncrementGenerator.class);
  private long next;
  private String sql;
  private Class returnClass;

  public synchronized Serializable generate(SessionImplementor session, Object object)
    throws HibernateException
  {
    if (this.sql != null) {
      getNext(session);
    }
    return IdentifierGeneratorFactory.createNumber(this.next++, this.returnClass);
  }

  public void configure(Type type, Properties params, Dialect dialect)
    throws MappingException
  {
    String tableList = params.getProperty("tables");
    if (tableList == null) tableList = params.getProperty("identity_tables");
    String[] tables = StringHelper.split(", ", tableList);
    String column = params.getProperty("column");
    if (column == null) column = params.getProperty("target_column");
    String schema = params.getProperty("schema");
    String catalog = params.getProperty("catalog");
    this.returnClass = type.getReturnedClass();

    StringBuffer buf = new StringBuffer();
    for (int i = 0; i < tables.length; ++i) {
      if (tables.length > 1) {
        buf.append("select ").append(column).append(" from ");
      }
      buf.append(Table.qualify(catalog, schema, tables[i]));
      if (i >= tables.length - 1) continue; buf.append(" union ");
    }
    if (tables.length > 1) {
      buf.insert(0, "( ").append(" ) ids_");
      column = "ids_." + column;
    }

    this.sql = "select max(" + column + ") from " + buf.toString();
  }

  private void getNext(SessionImplementor session)
  {
    log.debug("fetching initial value: " + this.sql);
    try
    {
      PreparedStatement st = session.getBatcher().prepareSelectStatement(this.sql);
      try {
        ResultSet rs = st.executeQuery();
        try {
          if (rs.next()) {
            this.next = (rs.getLong(1) + 1L);
            if (rs.wasNull()) this.next = 1L;
          }
          else {
            this.next = 1L;
          }
          this.sql = null;
          log.debug("first free id: " + this.next);
        }
        finally {
          rs.close();
        }
      }
      finally {
         session.getBatcher().closeStatement(st);
      }
    }                                                  
    catch (SQLException sqle)
    {
       throw JDBCExceptionHelper.convert(session.getFactory().getSQLExceptionConverter(), sqle, "could not fetch initial value for increment generator", this.sql);
    }
  }
}

/* Location:           D:\Workspace\HibernateTest\bin\lib\hibernate3.jar
 * Qualified Name:     org.hibernate.id.IncrementGenerator
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.5.3
 */

            大家请看其generate方法，当sql语句不等于Null的时候，获取下一个版本，也就是从数据库拿最大的id，然后就将sql置为null。这样下次获取id时，就不会从数据库拿，而是在内存++。那么这样就会产生问题。比如系统现在在A节点上工作，当next走到10的时候，突然网络断了，于是系统切换到了B节点上工作，B节点获取id时查询数据库拿到最大值，并且顺利执行next走到了20，此时又切回到了A节点，然而A节点的next此时为10，并且sql语句为null，于是A不查询数据库直接取next的值，那么将导致从10开始到20的id都会发生主键冲突，必须重启A节点才能解决问题。

因此如果涉及到使用hibernate的集群一定不能使用increment做为主键生成策略。从上面分析我们可以看出如果想解决该问题，必须解决两个进程之间的内存共享，也就是共享next变量，但是实现起来很复杂。最后采用Hilo的主键生成策略解决。其部分源码如下：

 

   public Serializable doWorkInCurrentTransaction(Connection conn, String sql)
     throws SQLException
   {
     int result;
     int rows;
     do
     {
       sql = this.query;
       SQL.debug(this.query);
       PreparedStatement qps = conn.prepareStatement(this.query);
       try {
         ResultSet rs = qps.executeQuery();
         if (!(rs.next())) {
           String err = "could not read a hi value - you need to populate the table: " + this.tableName;
           log.error(err);
           throw new IdentifierGenerationException(err);
         }
         int result = rs.getInt(1);
         rs.close();
       }
       catch (SQLException sqle)
       {
         throw sqle;
       }
       finally {
         qps.close(); }
 
       sql = this.update;
       SQL.debug(this.update);
       PreparedStatement ups = conn.prepareStatement(this.update);
       int rows;
       try {
         ups.setInt(1, result + 1);
         ups.setInt(2, result);
         rows = ups.executeUpdate();
       }
       catch (SQLException sqle)
       {
         throw sqle;
       }
       finally {
         ups.close();
       }
     }
     while (rows == 0);
     return new Integer(result);
   }
 }

 上面代码说明获取主键时，hibernate都会在同一个事务中从数据库中拿出主键，并将该主键更新。这样保证另外的进程从数据库取值时能够获取最大值。

关键是下面的代码：

 public class TableHiLoGenerator extends TableGenerator
 {
   public static final String MAX_LO = "max_lo";
   private long hi;
   private int lo;
   private int maxLo;
   private Class returnClass;
   private static final Log log = LogFactory.getLog(TableHiLoGenerator.class);
 
   public void configure(Type type, Properties params, Dialect d) {
     super.configure(type, params, d);
     this.maxLo = PropertiesHelper.getInt("max_lo", params, 32767);
     this.lo = (this.maxLo + 1);
     this.returnClass = type.getReturnedClass();
   }
 
   public synchronized Serializable generate(SessionImplementor session, Object obj) throws HibernateException
   {
     if (this.maxLo < 1)
     {
       int val = ((Integer)super.generate(session, obj)).intValue();
       return IdentifierGeneratorFactory.createNumber(val, this.returnClass);
     }
     if (this.lo > this.maxLo) {
       int hival = ((Integer)super.generate(session, obj)).intValue();
       this.lo = ((hival == 0) ? 1 : 0);
       this.hi = (hival * (this.maxLo + 1));
       log.debug("new hi value: " + hival);
     }
 
     return IdentifierGeneratorFactory.createNumber(this.hi + this.lo++, this.returnClass);
   }
 }

 

我们可以看到 ，查询主键时将数据库的的主键+1保存，如果这个事物没有成功，那么this.lo将永远大于this.maxLo，即便是此时切换到了B，当再次回到A时，首先会查询一次数据库，这样保证this.hi永远不会相等。如果成功那么当从B切换到A时，由于B的hi值比A的hi值至少大this.maxLo+1,因此，即便A保持hi不变从内从中拿低位，也不会和B相同，因为当this.lo大于this.maxLo时又会查询数据库。这个算法太美了。

其详细原理可以参照源码和下面的链接对比：

http://hi.baidu.com/sai5d/blog/item/88e5f4db09e90277d0164e30.html