序列号生成器

数据库中有自增长的字段，但是自增长字段有他的局限性，有的数据库是不支持自增长的。在开发过程中，部分客户业务需要生成业务的流程号，单纯的数字无法满足需求，于是就产生了编写一个序列号生成器的想法。

1、首先创建数据库表

create table sys_max_number (
   mn_id                varchar(32)          not null,
   mn_key_name          varchar(64)          not null,
   mn_key_value         bigint               not null default 0,
   mn_remark            varchar(512)         not null,
   constraint PK_SYS_MAX_NUMBER primary key (mn_id),
   constraint AK_UNIQUE_MAX_NUMBER_SYS_MAX_ unique (mn_key_name)
)
go

各个字段的含义如下：数据库主键，流水号的key，键值（默认0），流水号key说明

代码如下：

 package com.sys.maxnumber;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.work.core.db.DbConnectionFactory;

/**
 * @author wangmingjie
 * @date 2009-8-4上午09:59:15
 */
public class KeyInfo {
 private static Log log = LogFactory.getLog(KeyInfo.class); 
 private long keyMax; // 最大键值
 private long keyMin; // 最小键值
 private long nextKey; // 下一个键值
 private int poolSize; // 缓存大小，注意，太大容易浪费号码
 private String keyName; // 主键，用在哪个应用中的。

 public KeyInfo(int poolSize, String keyName) {
  this.poolSize = poolSize;
  this.keyName = keyName;
  retrieveFromDB(5); // 注意不能直接使用这个类，否则在多线程的情况下，会出问题。
  //上面必须初始化的时候调用，否则出错！目的是为了首先要给nextKey赋值
 }

 public long getKeyMax() {
  return keyMax;
 }

 public long getKeyMin() {
  return keyMin;
 }

 /**
  * 获取下一个字符串的键值。如果不符合长度，前面用零补齐；<br>
  * 例如参数是四，intkey=10，那么返回0010
  * 注意，这里面调用的是getNextIntKey方法。
  * 2,147,483,647 ，
  * @param paddingLength
  *            字符串长度，最大长度为10位。因为整形的缘故。
  *           
  * @return 如果参数长度大于指定的长度了，那么返回实际长度的字符串。
  */
 public String getNextStringKey(final int paddingLength) {
  String s = Long.toString(getNextIntKey());
  int len = s.length();
  if (len < paddingLength) {
   StringBuffer buf = new StringBuffer(paddingLength);
   for (int i = 0; i < paddingLength - len; i++) {
    buf.append('0');
   }
   buf.append(s);
   s = buf.toString();
  }
  return s;
 }

 /**
  * 获取下一个整型的键值；
  *
  * @return
  */
 public synchronized int getNextIntKey() {
  if (nextKey > keyMax) {
   retrieveFromDB(5);
  }
  return (int)(nextKey++);
 }
 
 /**
  * 获取长整形的键值
  * @return
  */
 public synchronized long getNextLongKey(){
  if (nextKey > keyMax) {
   retrieveFromDB(5);
  }
  return nextKey++;
 }

 private void retrieveFromDB(int count) {
  if (count == 0) {
   if(log.isErrorEnabled())
    log.error("最终获取序列号失败！放弃继续获取...");   
   return;
  }
  boolean success = false;
  
  long keyFromDB = 0;
  String updateSql = "UPDATE sys_max_number SET mn_key_value = mn_key_value + "
    + poolSize + " WHERE mn_key_name =? ";

  String selectSql = "SELECT mn_key_value FROM sys_max_number WHERE mn_key_name = ? ";
  Connection conn = null;
  PreparedStatement pstUpdate = null;
  PreparedStatement pstSelect = null;
  ResultSet rst = null;
  try {
//   conn = DbConnectionFactory.getJdbcConn();
   conn = DbConnectionFactory.getConnection();//从连接池中获取数据库连接
   conn.setAutoCommit(false);
   pstUpdate = conn.prepareStatement(updateSql);
   pstUpdate.setString(1, keyName.trim());
   pstUpdate.executeUpdate();

   pstSelect = conn.prepareStatement(selectSql);
   pstSelect.setString(1, keyName.trim());
   rst = pstSelect.executeQuery();
   while (rst.next()) {
    keyFromDB = rst.getLong(1);
   }
   conn.commit();
   success = true;
  } catch (SQLException e) {
   try {
    conn.rollback();
   } catch (SQLException e1) {
    e1.printStackTrace();
   }
   e.printStackTrace();
   if(log.isWarnEnabled())
    log.warn("获取序列号失败！", e);
  } finally {

   try {
    if (rst != null)
     rst.close();
   } catch (SQLException e) {
   }
   try {
    if (pstUpdate != null)
     pstUpdate.close();
   } catch (SQLException e) {
   }
   try {
    if (pstSelect != null)
     pstSelect.close();
   } catch (SQLException e) {
   }
   try {
    if (conn != null)
     conn.close();
   } catch (SQLException e) {
   }
  }

  keyMax = keyFromDB;
  keyMin = keyFromDB - poolSize + 1;
  nextKey = keyMin;

  if (!success) {
   if(log.isWarnEnabled())
    log.warn("警告，因线程争夺，获取下一个序列号失败。进行下一次尝试..."); 
   // Call this method again, but sleep briefly to try to avoid thread contention.
   try {
    Thread.sleep(75);
   } catch (InterruptedException ie) {
   }
   retrieveFromDB(count - 1);
  }
 }
}

======================================

package com.sys.maxnumber;

import java.util.HashMap;
//
//import org.apache.commons.logging.Log;
//import org.apache.commons.logging.LogFactory;

/**
 * @author wangmingjie
 * @date 2009-8-4上午10:33:19
 */
public class KeyGenerator {
// private static Log log = LogFactory.getLog(KeyGenerator.class); 
 
 private static HashMap<String, KeyGenerator> kengens = new HashMap<String, KeyGenerator>(
   10);
 /* 最小为1，因为数据库中，默认的是0，生成的序列值最小为1 */
 private static final int POOL_SIZE = 1;
 
 private KeyInfo keyinfo;

 /**
  * 构造方法。
  * @param poolSize 每次获取几个数值，放到缓存中。如果小于1，那么默认为1。<br>
  * 建议值为2，这样每次重新启动应用最多浪费一个数，而且能够提高到两倍的效率。<br>
  * 如果使用1，废号的几率是最低的。但是不能应用在高并发的系统中。
  * @param keyName  对应最大好表的键。
  */
 private KeyGenerator(int poolSize,String keyName) {
  if(poolSize<1){
   poolSize=POOL_SIZE;
  }
  keyinfo = new KeyInfo(poolSize, keyName);
 }

 /**
  * 保证线程安全。
  * @param poolSize 缓存大小
  * @param keyName  主键名称
  * @return
  */
 public static synchronized KeyGenerator getInstance(int poolSize,String keyName) {
  KeyGenerator keygen;
  if (kengens.containsKey(keyName)) {
   keygen = kengens.get(keyName);
   //System.out.println("从缓存中获得"+keyName);
  } else {
   keygen = new KeyGenerator(poolSize,keyName);
   kengens.put(keyName, keygen); //注册到hashmap中。提高效率
   //System.out.println("注册了"+keyName);
  }
  return keygen;
 }

 /**
  * 获取到int类型的序列值
  * @return
  */
 public int getNextIntKey() {
  return keyinfo.getNextIntKey();
 }
 /**
  * 获取到long类型的序列值。一般不会用到。除非是像移动联通，这样的，每天的通话记录都是上亿的。
  * @return
  */
 public long getNextLongKey() {
  return keyinfo.getNextLongKey();
 } 
 /**
  * 获取到string类型的序列值
  * @param paddingLength 返回string的长度，最大长度是10位。如果使用long可以到19位。
  * @return
  */
 public String getNextStringKey(int paddingLength){
  return keyinfo.getNextStringKey(paddingLength);
 }
}
================测试类如下==========================

package com.sys.maxnumber;

/**
 * 注意测试的时候，修改KeyInfo的retrieveFromDB方法，使其通过jdbc连接。
 * 使用的时候注意，keyname必须在最大号表中存在！
 * @author wangmingjie
 * @date 2009-8-4上午10:38:19
 */
public class KeyClient {
//一般使用方法，KeyGenerator.getInstance(1,"BugProject").getNextIntKey();
//在并发数量多的情况下面，提高poolsize的值，这样就可以减少数据库的访问次数。 
 
 /**
  * 使用方法
  *
  * @param args
  */
 public static void main(String[] args) {
//  KeyGenerator keygen = KeyGenerator.getInstance(1,"BugProject");
//
//  for (int i = 0; i < 25; i++) {
//   System.out.println("key(" + (i + 1) + ")= " + keygen.getNextIntKey());
//  }
//  
//  for (int i = 0; i < 25; i++) {
//   System.out.println("key(" + (i + 1) + ")= " + keygen.getNextStringKey(6));
//  }
  
  ThreadA t = new ThreadA();
  Thread t1 = new Thread(t, "A");
  Thread t2 = new Thread(t, "B");
  Thread t3 = new Thread(t, "C");
  Thread t4 = new Thread(t, "D");
  t1.start();
  t2.start();
  t3.start();
  t4.start();
//  访问多了就出现事务死锁。所以高并发系统中必须提高缓存数量。
//  java.sql.SQLException: 事务（进程 ID  143）与另一个进程已被死锁在  lock 资源上，且该事务已被选作死锁牺牲品。请重新运行该事务。
//  Bkey A(12)= 000137  
//  ThreadA ta = new ThreadA();
//  ta.run(); 
//  ThreadB tb = new ThreadB();
//  tb.run(); 
  
 }
}
class  ThreadA implements Runnable{
 public void run(){
  KeyGenerator keygen = KeyGenerator.getInstance(1,"BugProject");
  for (int i = 0; i < 500; i++) {
   System.out.println(Thread.currentThread().getName()+"key A(" + (i + 1) + ")= "
     + keygen.getNextIntKey()+"||"
     + keygen.getNextIntKey()
     +"||"
     + keygen.getNextStringKey(4));
  }
 }
}
class  ThreadB implements Runnable{
 public void run(){
  KeyGenerator keygen = KeyGenerator.getInstance(1,"BugProject");
  for (int i = 0; i < 500; i++) {
   System.out.println(Thread.currentThread().getName()+"key B(" + (i + 1) + ")= " + keygen.getNextStringKey(6));
  }
 }
}
==============pojo================

package com.sys.model;

import java.io.Serializable;

/**
 *
 */

public class MaxNumber implements Serializable {

 // constructors
 public MaxNumber() {

 }

 /**
  * Constructor for primary key
  */
 public MaxNumber(String id) {
  this.setId(id);

 }

 // primary key
 private String id;//ID

 

 public java.lang.String getId() {
  return id;
 }

 public void setId(String id) {
  this.id = id;
 }

 private String keyName;  //主键
 private Integer keyValue;  //值
 private String remark;  //备注

 public String getKeyName() {
  if(keyName==null) return null;
  else return keyName.trim();
 }

 public void setKeyName(String keyName) {
  this.keyName = keyName;
 }
 public Integer getKeyValue() {
  return keyValue;
 }

 public void setKeyValue(Integer keyValue) {
  this.keyValue = keyValue;
 }
 public String getRemark() {
  if(remark==null) return null;
  else return remark.trim();
 }

 public void setRemark(String remark) {
  this.remark = remark;
 }

 /* (non-Javadoc)
  * @see java.lang.Object#hashCode()
  */
 @Override
 public int hashCode() {
  final int PRIME = 31;
  int result = super.hashCode();
  result = PRIME * result + ((id == null) ? 0 : id.hashCode());
  return result;
 }

 /* (non-Javadoc)
  * @see java.lang.Object#equals(java.lang.Object)
  */
 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (!super.equals(obj))
   return false;
  if (getClass() != obj.getClass())
   return false;
  final MaxNumber other = (MaxNumber) obj;
  if (id == null) {
   if (other.id != null)
    return false;
  } else if (!id.equals(other.id))
   return false;
  return true;
 }

 public String toString() {
  StringBuffer sb = new StringBuffer("");
  sb.append("MaxNumber{id=");sb.append(id);sb.append(",");
  sb.append("keyName=");sb.append(keyName);sb.append(",");
  sb.append("keyValue=");sb.append(keyValue);sb.append(",");
  sb.append("remark=");sb.append(remark);
  sb.append("}");
  return sb.toString();
 }

 

}