扩展hibernate的主键生成策略

Hibernate的主键生成策略有好几种：
1) assigned
2) hilo
3) seqhilo
4) increment
5) identity
6) sequence
7) native
8) uuid.hex
9) uuid.string
10) foreign
一般而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适
应性。另外由于常用的数据库，如Oracle、DB2、SQLServer、MySql 等，都提
供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。我们可以在数
据库提供的主键生成机制上，采用generator-class=native的主键生成方式。
不过值得注意的是，一些数据库提供的主键生成机制在效率上未必最佳，
大量并发insert数据时可能会引起表之间的互锁。
数据库提供的主键生成机制，往往是通过在一个内部表中保存当前主键状
态（如对于自增型主键而言，此内部表中就维护着当前的最大值和递增量），
之后每次插入数据会读取这个最大值，然后加上递增量作为新记录的主键，之
后再把这个新的最大值更新回内部表中，这样，一次Insert操作可能导致数据
库内部多次表读写操作，同时伴随的还有数据的加锁解锁操作，这对性能产生
了较大影响。
因此，对于并发Insert要求较高的系统，推荐采用uuid.hex 作为主键生成
机制。
另外我们可以扩展Hibernate的类来做自己的主键生成策略：
java 代码
 
package com.gsta.eshore.framework.util.uid;  
import java.io.Serializable;  
import org.hibernate.engine.SessionImplementor;  
import org.hibernate.id.AbstractUUIDGenerator;  
import org.hibernate.id.Configurable;  
import org.hibernate.id.IdentifierGenerator;  
import java.util.Properties;  
import org.hibernate.Hibernate;  
import org.hibernate.dialect.Dialect;  
import org.hibernate.type.Type;  
import org.hibernate.util.PropertiesHelper;  
/** 
 * <b>uuid</b><br> 
* @author hwq 
 */  
public class UIDGenerator extends AbstractUUIDGenerator implements Configurable {  
    private static long lastTime = System.currentTimeMillis();  
    private static short lastCount = -32768;  
    private static Object mutex = new Object();  
    private static long ONE_SECOND = 1000L;  
    private String sep = "";  
    public Serializable generate(SessionImplementor session, Object obj) {  
        long l = 0L;  
        short word0 = 0;  
        int i = 0;  
        synchronized(mutex)  
        {  
            if(lastCount == 32767)  
            {  
                for(boolean flag = false; !flag;)  
                {  
                    l = System.currentTimeMillis();  
                    if(l < lastTime + ONE_SECOND)  
                    {  
                        try  
                        {  
                            Thread.currentThread();  
                            Thread.sleep(ONE_SECOND);  
                        }  
                        catch(InterruptedException interruptedexception) { }  
                    } else  
                    {  
                        lastTime = l;  
                        lastCount = -32768;  
                        flag = true;  
                    }  
                }  
            } else  
            {  
                l = lastTime;  
            }  
            word0 = lastCount++;  
            i = getHostUniqueNum();  
        }  
        String s = Integer.toString(i, 16) + sep + Long.toString(l, 16) + sep + Integer.toString(word0, 16);  
        if(s.length() > 24)  
            s = s.substring(s.length() - 24);  
        return s;  
    }  
    public Serializable generate_old(SessionImplementor session, Object obj) {  
        String name = obj.getClass().getName();  
        return new StringBuffer(64)  
            .append(name.substring(name.lastIndexOf('.')+1)).append(sep)  
            .append((short)getIP()).append(sep)  
            .append(Math.abs((short)getJVM())).append(sep)  
            .append(getCount())   
            .toString();  
    }  
    private static int getHostUniqueNum()  
    {  
        return (new Object()).hashCode();  
    }  
    public void configure(Type type, Properties params, Dialect d) {  
        sep = PropertiesHelper.getString("separator", params, "");  
    }  
    public static void main( String[] args ) throws Exception {  
        Properties props = new Properties();  
        props.setProperty("separator", "");  
        IdentifierGenerator gen = new UIDGenerator();  
        ( (Configurable) gen ).configure(Hibernate.STRING, props, null);  
        IdentifierGenerator gen2 = new UIDGenerator();  
        ( (Configurable) gen2 ).configure(Hibernate.STRING, props, null);  
        for ( int i=0; i<10; i++) {  
            String id = (String) gen.generate(null, gen);  
            System.out.println(id);  
            String id2 = (String) gen2.generate(null, gen2);  
            System.out.println(id2);  
        }  
    }  
}  
这个类必须要扩展AbstractUUIDGenerator并实现Configurable接口，在generate方法中生成我们想要的主键。
在hibernate的配置文件中要做以下的配置:
xml 代码
 
<id name="id" type="java.lang.String">  
      <column name="id" length="24" />  
      <generator class="com.gsta.eshore.framework.util.uid.UIDGenerator"><param name="separator">-</param></generator>  
  </id>  
Generator的类要引用UIDGenerator，并且可以带参数生成主键，示例是根据时间，Ip等生成一个24位的字符串。这样做的灵活性大大提高了，提供了最好的性能和数据库平台适应性。
但是有时候我们在保存一条记录的时候是不能指定主键的，因为它的主键要来源于其他的表的主键，（hibernate推荐用代理主键，但是有时候设计的时候没有用到）。这个时候的主键生成策略就要是assigned了。为了保持主键的连贯性，我总不能又用另外一种主键生成策略吧。
仿照上面的类，我们做一个生成24为随机字符串的类。
java 代码
 
package com.gsta.eshore.framework.util.uid;  
public class UID  
{  
    private static long lastTime = System.currentTimeMillis();  
    private static short lastCount = -32768;  
    private static Object mutex = new Object();  
    private static long ONE_SECOND = 1000L;  
    public UID()  
    {  
    }  
    public static String getUID()  
    {  
        long l = 0L;  
        short word0 = 0;  
        int i = 0;  
        synchronized(mutex)  
        {  
            if(lastCount == 32767)  
            {  
                for(boolean flag = false; !flag;)  
                {  
                    l = System.currentTimeMillis();  
                    if(l < lastTime + ONE_SECOND)  
                    {  
                        try  
                        {  
                            Thread.currentThread();  
                            Thread.sleep(ONE_SECOND);  
                        }  
                        catch(InterruptedException interruptedexception) { }  
                    } else  
                    {  
                        lastTime = l;  
                        lastCount = -32768;  
                        flag = true;  
                    }  
                }  
            } else  
            {  
                l = lastTime;  
            }  
            word0 = lastCount++;  
            i = getHostUniqueNum();  
        }  
        String s = Integer.toString(i, 16) + "`" + Long.toString(l, 16) + "`" + Integer.toString(word0, 16);  
        if(s.length() > 24)  
            s = s.substring(s.length() - 24);  
        return s;  
    }  
    private static int getHostUniqueNum()  
    {  
        return (new Object()).hashCode();  
    }  
  
   public static void main(String[] args) {  
        for (int i = 0; i < 100; i++) {  
            String uid=getUID();  
            System.out.println(uid);  
        }  
        }  
}  
在save一个实体的时候调用entity.setId(UID.getUID())。
呵呵，以后用hibernate就不用烦用什么主键生成策略了，自己做一个。
<id name="id" type="java.lang.String"><column name="id" length="24"><id type="java.lang.String" name="id"><column length="24" name="id"></id></column></id>