Java如何解决同时出库入库订单号自动获取问题：详解与实战

原创

bug菌

发布于 2024-12-28 10:57:42

1.8K0

文章被收录于专栏：滚雪球学Java滚雪球学Java

咦咦咦，各位小可爱，我是你们的好伙伴——bug菌，今天又来给大家普及Java SE相关知识点了，别躲起来啊，听我讲干货还不快点赞，赞多了我就有动力讲得更嗨啦！所以呀，养成先点赞后阅读的好习惯，别被干货淹没了哦~

🏆本文收录于「滚雪球学Java」专栏中，这个专栏专为有志于提升Java技能的你打造，覆盖Java编程的方方面面，助你从零基础到掌握Java开发的精髓。赶紧关注，收藏，学习吧！

环境说明：Windows 10 + IntelliJ IDEA 2021.3.2 + Jdk 1.8

前言

在电商、物流和库存管理等系统中，出库和入库操作是常见的业务场景。在实际的开发过程中，出库和入库操作可能同时发生，为了确保订单号的唯一性和顺序性，必须实现一种高效的机制来自动生成唯一订单号。如果处理不当，多线程同时操作数据库或内存中的订单号，可能会导致订单号重复、错乱，影响系统的稳定性和数据的一致性。

本篇文章将详细介绍如何在 Java 中解决同时出库入库时订单号自动获取的问题，涉及数据库的事务控制、分布式环境下的唯一标识生成等多个技术点。通过实际的编码示例和原理解析，帮助开发者掌握如何高效、稳定地处理订单号的生成与管理。

一、订单号生成的挑战

在实际开发中，订单号通常具有以下几个特性：

唯一性：每个订单号必须是唯一的，避免重复。
有序性：订单号往往需要具备一定的顺序，尤其在生成报表或追踪操作时，顺序非常重要。
并发环境下的安全性：在高并发情况下（如多个用户同时进行出库入库操作），订单号的生成和分配需要保证线程安全。

挑战场景

假设在一个库存管理系统中，多个用户可以同时进行出库和入库操作，后台系统需要为每个订单生成唯一且有序的订单号。如果没有处理好并发问题，可能会出现以下几种情况：

订单号重复：两个不同操作分配到了相同的订单号，造成数据混乱。
顺序错乱：订单号不按照预期顺序生成，导致数据难以追踪。

为了解决这些问题，Java 提供了多种并发处理和唯一标识生成的方式。下面我们将从基础的数据库锁机制，到分布式系统中更高级的唯一标识生成算法，逐一介绍如何在实际项目中应用这些技术。

二、解决方案一：数据库自增序列

1. 使用数据库的自增主键

最简单的方式是利用数据库的自增字段来生成订单号。在 MySQL 中，可以使用 AUTO_INCREMENT 来保证订单号的唯一性和有序性。这样做的好处是简单易行，数据库会自动管理自增逻辑，开发者只需插入数据即可。

示例：MySQL 自增主键

CREATE TABLE orders (
    id INT AUTO_INCREMENT PRIMARY KEY,
    order_number VARCHAR(20) NOT NULL,
    product_id INT,
    quantity INT
);

每次插入一条新订单记录，数据库会自动生成唯一且自增的 id 作为订单号。不过，这种方式只适用于单数据库场景，如果系统是分布式的，依赖数据库自增 ID 可能会有一定的瓶颈。

2. 使用数据库序列（适用于 Oracle、PostgreSQL）

在某些数据库中，如 Oracle 和 PostgreSQL，可以使用序列（Sequence）来生成唯一订单号。序列具有递增且唯一的特性，可以在插入订单数据时通过查询序列值来生成订单号。

示例：Oracle 序列生成

CREATE SEQUENCE order_seq
    START WITH 1000
    INCREMENT BY 1
    NOCACHE;
    
-- 插入订单时获取下一个序列值作为订单号
INSERT INTO orders (order_number, product_id, quantity)
VALUES (order_seq.NEXTVAL, 101, 10);

3. 数据库事务与锁机制

为了防止多个线程同时插入数据而获取重复的订单号，可以使用悲观锁或乐观锁机制，确保每个线程在生成订单号时，操作是串行化的。

示例：使用悲观锁

public synchronized String getNextOrderNumber() {
    // 查询数据库锁定行
    String sql = "SELECT order_number FROM order_sequence FOR UPDATE";
    // 执行获取和更新逻辑，确保只有一个线程能操作此行
    // 生成并返回唯一的订单号
}

通过 FOR UPDATE，在查询到当前的最大订单号后，行级锁确保其他线程必须等待，直到当前事务提交完成，避免重复订单号的生成。

三、解决方案二：UUID生成器

1. 基于 UUID 的唯一订单号生成

UUID（Universally Unique Identifier）是一个常用的生成全局唯一标识符的方法。它在分布式系统中非常有用，可以确保在不依赖中心节点的情况下生成唯一订单号。

示例：使用 Java 的 UUID

import java.util.UUID;

public class OrderService {
    public String generateOrderNumber() {
        return UUID.randomUUID().toString();
    }
    
    public static void main(String[] args) {
        OrderService service = new OrderService();
        System.out.println("订单号：" + service.generateOrderNumber());
    }
}

UUID 的长度比较长，且生成的结果是无序的，因此在某些业务场景下，UUID 可能不适合用作显示给用户的订单号。不过它在分布式系统中生成唯一标识非常可靠。

四、解决方案三：基于时间戳和业务编号的订单号生成

为了生成既唯一又有一定含义的订单号，开发者可以基于时间戳、业务编号等信息组合生成订单号。常见的做法是将当前时间（精确到毫秒）和随机数或用户 ID 结合，生成一个唯一且有序的订单号。

示例：基于时间戳生成订单号

import java.text.SimpleDateFormat;
import java.util.Date;

public class OrderNumberGenerator {
    private static long orderCount = 0;

    public synchronized String generateOrderNumber() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
        String timestamp = sdf.format(new Date());

        // 保证订单号的唯一性，通过加上递增的计数器
        orderCount++;
        return timestamp + String.format("%03d", orderCount);
    }

    public static void main(String[] args) {
        OrderNumberGenerator generator = new OrderNumberGenerator();
        System.out.println("订单号：" + generator.generateOrderNumber());
    }
}

这种方式通过时间戳来保证订单号的有序性，并结合递增的计数器来保证在同一时间段内的唯一性。在高并发环境下，为了防止计数器的重复，可以使用线程安全的递增机制（如使用 AtomicLong）来生成计数值。

五、解决方案四：分布式系统中的唯一订单号生成

在分布式系统中，使用单个数据库或服务生成唯一订单号可能成为瓶颈。因此，分布式系统通常需要一种高效且去中心化的唯一标识生成机制。以下是常用的两种方法：

1. 雪花算法（Snowflake Algorithm）

雪花算法由 Twitter 开发，是一种高效生成唯一 ID 的算法。它使用 64 位长的数字来表示唯一 ID，其中包含了时间戳、机器 ID 和序列号，保证了分布式系统中的全局唯一性和有序性。

雪花算法的 ID 结构

时间戳部分：记录生成 ID 的时间，确保有序性。
机器 ID 部分：用于标识生成 ID 的机器，确保在分布式环境下唯一。
序列号部分：保证在同一毫秒内生成多个不同的 ID。

示例：Java 实现雪花算法

public class SnowflakeIdGenerator {
    private final long workerId;
    private final static long twepoch = 1288834974657L;
    private long sequence = 0L;
    private final static long workerIdBits = 5L;
    private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
    private final static long sequenceBits = 12L;
    private final static long workerIdShift = sequenceBits;
    private final static long timestampLeftShift = sequenceBits + workerIdBits;
    private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
    private long lastTimestamp = -1L;

    public SnowflakeIdGenerator(long workerId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException("worker Id can't be greater than " + maxWorkerId + " or less than 0");
        }
        this.workerId = workerId;
    }

    public synchronized long nextId() {
        long timestamp = timeGen();

        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards.");
        }

        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence

 = 0L;
        }

        lastTimestamp = timestamp;
        return ((timestamp - twepoch) << timestampLeftShift) | (workerId << workerIdShift) | sequence;
    }

    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    protected long timeGen() {
        return System.currentTimeMillis();
    }

    public static void main(String[] args) {
        SnowflakeIdGenerator generator = new SnowflakeIdGenerator(1);
        System.out.println("订单号：" + generator.nextId());
    }
}

2. Redis 分布式锁

Redis 作为一种分布式缓存系统，也常被用于生成全局唯一的订单号。通过使用 Redis 的自增操作，可以确保多个客户端同时请求时不会生成重复的订单号。

示例：使用 Redis 自增生成订单号

import redis.clients.jedis.Jedis;

public class RedisOrderNumberGenerator {
    private static final String ORDER_KEY = "order_key";

    public static String generateOrderNumber() {
        try (Jedis jedis = new Jedis("localhost")) {
            long orderId = jedis.incr(ORDER_KEY);
            return "ORD" + String.format("%010d", orderId);
        }
    }

    public static void main(String[] args) {
        System.out.println("订单号：" + generateOrderNumber());
    }
}

Redis 的 INCR 操作是原子性的，可以保证在并发环境下，多个线程都能获得唯一的递增订单号。

六、总结

订单号的自动生成是电商、库存管理等系统中的关键环节。Java 提供了多种方法来确保订单号在并发环境下的唯一性和有序性，从最基础的数据库自增到分布式环境下的雪花算法或 Redis 自增机制，开发者可以根据实际需求选择合适的方案。

通过本文的讲解和实际示例，读者可以学到如何使用 Java 解决订单号自动获取的并发问题，以及在不同场景下采用的不同技术手段。希望这些内容能帮助开发者设计出高效、稳定的订单号生成系统。

扩展阅读：

☀️建议/推荐你

无论你是计算机专业的学生，还是对编程有兴趣的小伙伴，都建议直接毫无顾忌的学习此专栏「滚雪球学Java」，bug菌郑重承诺，凡是学习此专栏的同学，均能获取到所需的知识和技能，全网最快速入门Java编程，就像滚雪球一样，越滚越大，指数级提升。

码字不易，如果这篇文章对你有所帮助，帮忙给bug菌来个一键三连(关注、点赞、收藏) ，您的支持就是我坚持写作分享知识点传播技术的最大动力。同时也推荐大家关注我的硬核公众号:「猿圈奇妙屋」；以第一手学习bug菌的首发干货，不仅能学习更多技术硬货，还可白嫖最新BAT大厂面试真题、4000G Pdf技术书籍、万份简历/PPT模板、技术文章Markdown文档等海量资料，你想要的我都有！

📣关于我

--End

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S11#重启人生