浅谈订单号生成的设计方案

今天讨论分享下订单号生成的简单实现方案，为实际场景中需要用到订单号生成服务提供解决思路。

10年积累的做网站、网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有凤阳免费网站建设让你可以放心的选择与我们合作。

最简单的方式

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

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

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

 
 
 
    
  
  
  
    2. 
  
  
  
  2.     UPDATE sequence
    3. 
  
  
  
  3.     SET
    4. 
  
  
  
  4.     current_value = LAST_INSERT_ID(current_value + _increment)
    5. 
  
  
  
  5.     WHERE
    6. 
  
  
  
  6.     seq_name = #{seqName}
    7. 
  
  
  
    8. 
  
  
  
  8.         
    9. 
  
  
  
  9. 
  
  
  
  10.

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

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

稍复杂一点的方法

上述的方法的问题，想必大家都知道，就是每次获取 ID 都要调用数据库，在高并发的情况下会对数据库产生极大的压力，我们的改进方法也很简单，就是一次申请一个段的 ID，然后发到内存里，每次获取 ID 先从内存里取，当内存中的 ID 段全部被获取完毕，则再一次调用数据库重新申请一个新的 ID 段。同样有数据库表的设计，通过 Name 区分业务，用 ID 标明已经申请到的最大值。当然如果是分布式架构，也可以通过增加步长属性来实现。

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

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

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

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

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

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

本文小结

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

【本文是专栏作者张开涛的原创文章，作者微信公众号：开涛的博客，id:kaitao-1234567】

分享标题：浅谈订单号生成的设计方案
文章转载：http://www.csdahua.cn/qtweb/news25/484775.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站设计公司知识

同城分类信息

成都定制网页设计　　 　攀枝花SEO　　 　app软件定制开发　　 　珉田数据中心　　 　乐至网站建设　　 　四川雅安服务器托管　　 　木包装箱　　 　买链接　　 　犀浦封阳台　　 　梓潼网站建设　　 　绵阳机房托管　　 　簇桥薇薇新娘　　 　成都网络公司　　 　研帮主　　 　微信公众号二次开发　　 　LED显示屏　　 　叙永网站建设　　 　网站建设推广　　 　成都木托盘　　 　SSL证书