简单的方式

基于数据库 auto_increment_increment 来获取 ID。首先在数据库中创建一张 sequence 表,其中 seq_name 用以区分不同业务标识,从而实现支持多种业务场景下的自增 ID, current_value 为当前值, _increment 为步长,可支持分布式数据库的哈希策略。


 
  1. CREATE TABLE `sequence` (  
  2. `seq_name` varchar(200) NOT NULL 
  3. `current_value` bigint(20) NOT NULL
  4. `_increment` int(4) NOT NULL 
  5. PRIMARY KEY (`seq_name`)  
  6. ) ENGINE=InnoDB DEFAULT CHARSET=utf8 

通过 SELECT LAST_INSERT_ID() 方法,更新 sequence 表,进行 ID 递增,并同时获取上次更新的值。这里注意, current_value = LAST_INSERT_ID(current_value + _increment) 将更新的 ID 赋值给了 LAST_INSERT_ID ,否则返回的将是行 id。

 


 
  1. UPDATE sequence 
  2. SET 
  3. current_value = LAST_INSERT_ID(current_value + _increment) 
  4. WHERE 
  5. seq_name = #{seqName} 

最后 Dao 提供服务,需要提醒的是注意数据库的事务隔离级别,如果将 getSeq() 方法放到 Service 中有事务的方法里,将出现问题,因为数据库事务开启会创建一张视图,在事务没有提交之前,更新的 ID 还没有被提交到数据库中,这在多线程并发操作的情况下,如果事务里的其他方法导致性能慢了,可能出现两个请求获取到相同的 ID,所以解决方法一是不要将 getSeq() 方法放到有事务的方法里,另一种就是将 getSeq() 方法的隔离界别为 PROPAGATION_REQUIRES_NEW ,实现开启新事务,外层事务不会影响内部事务的提交。


 
  1. @Autowired  
  2. private SeqDao seqDao; 
  3. @Autowired  
  4. private PlatformTransactionManager transactionManager;  
  5. @Override  
  6. public long getSeq(final String seqName) throws Exception {  
  7. TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);  
  8. // 事务行为,独立于外部事物独立运行 
  9. transactionTemplate 
  10. .setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);  
  11. return (Long) transactionTemplate.execute(new TransactionCallback() {  
  12. public Object doInTransaction(TransactionStatus status) {  
  13. try {  
  14. Seq seq = new Seq();  
  15. seq.setSeqName(seqName);  
  16. if (seqDao.update(seq) == 0) { 
  17. throw new RuntimeException("seq update failure.");  
  18.  
  19. return seq.getId();  
  20. } catch (Exception e) { 
  21. throw new RuntimeException("seq update error.");  
  22.  
  23.  
  24. });  

稍复杂一点的方法

上述的方法的问题,想必大家都知道,就是每次获取 ID 都要调用数据库,在高并发的情况下会对数据库产生极大的压力,我们的改进方法也很简单,就是一次申请一个段的 ID,然后发到内存里,每次获取 ID 先从内存里取,当内存中的 ID 段全部被获取完毕,则再一次调用数据库重新申请一个新的 ID 段。

同样有数据库表的设计,通过 Name 区分业务,用 ID 标明已经申请到的最大值。当然如果是分布式架构,也可以通过增加步长属性来实现。


 
  1. CREATE TABLE `sequence_value` (  
  2. `Name` varbinary(50) DEFAULT NULL 
  3. `ID` int(11) DEFAULT NULL  
  4. ) ENGINE = InnoDB DEFAULT CHARSET = utf8 

Step 是 ID 段的内存对象,有两个属性,其中 currentValue 当前的使用到的值,endValue 是内存申请的最大值。


 
  1. class Step {  
  2. private long currentValue;  
  3. private long endValue;  
  4. Step(long currentValue, long endValue) {  
  5. this.currentValue = currentValue;  
  6. this.endValue = endValue;  
  7.  
  8. public void setCurrentValue(long currentValue) {  
  9. this.currentValue = currentValue;  
  10.  
  11. public void setEndValue(long endValue) {  
  12. this.endValue = endValue;  
  13.  
  14. public long incrementAndGet() {  
  15. return ++currentValue;  
  16.  

代码的实现稍微复杂一点,获取 ID 会根据业务标识 sequencename,先从内存获取 Step 的 ID 段,如果为 null,则从数据库中读取当前最新的值,并根据步长计算 Step,然后返回请求 ID。如果从内存中直接获取到 Step,则直接取 ID,并对 currentValue 进行加一。当 currentValue 的值超过 endValue 时,则更新数据库的 ID,重新计算 Step。


 
  1. private Map<String,Step> stepMap = new HashMap<String, Step>();  
  2. public synchronized long get(String sequenceName) {  
  3. Step step = stepMap.get(sequenceName);  
  4. if(step ==null) {  
  5. step = new Step(startValue,startValue+blockSize);  
  6. stepMap.put(sequenceName, step);  
  7. else { 
  8. if (step.currentValue < step.endValue) {  
  9. return step.incrementAndGet();  
  10.  
  11. if (getNextBlock(sequenceName,step)) {  
  12. return step.incrementAndGet();  
  13.  
  14. throw new RuntimeException("No more value.");  
  15.  
  16. private boolean getNextBlock(String sequenceName, Step step) {  
  17. // "select id from sequence_value where name = ?" 
  18. Long value = getPersistenceValue(sequenceName);  
  19. if (value == null) { 
  20. try {  
  21. // insert into sequence_value (id,namevalues (?,?)  
  22. value = newPersistenceValue(sequenceName);  
  23. } catch (Exception e) {  
  24. value = getPersistenceValue(sequenceName);  
  25.  
  26.  
  27. // update sequence_value set id = ? where name = ? and id = ?  
  28. boolean b = saveValue(value,sequenceName) == 1;  
  29. if (b) {  
  30. step.setCurrentValue(value);  
  31. step.setEndValue(value+blockSize); 
  32.  
  33. return b;  

使用该方法获取 ID 可以减少对数据库的访问量,以降低数据库的压力,但是同样需要注意,获取 ID 同样关注数据库事务问题,因为当系统重启的时候,stepMap 为 null,所以会取数据库查询当前 ID,更计算更新 Step,然后更新数据库的 ID。如果该方法被放到数据库事务里,由于其他方法性能慢了,导致查询之后没有及时更新,并发情况下另一个线程查询的时候,可能会获取到该线程未提交的 ID,因而出现两个线程获取到相同的 ID 问题。

本文小结

订单号生成是一个非常简单的功能,但是在高并发的场景下,高性能和高可用就成为了需要关注的要点。所以,实际工作中的每一个小细节都值得我们去深思。