Zookeeper实现分布式队列

常见的消息队列有:RabbitMQ，RocketMQ，Kafka等。Zookeeper作为一个分布式的小文件管理系统，同样能实现简单的队列功能。Zookeeper不适合存储大数据量存储，官方并不推荐作为队列使用，但由于实现简单，集群搭建较为便利，因此在一些吞吐量不高的小型系统中还是比较好用的。

本案例设立一个订单生产者，两个订单消费者，订单生产者将下单信息存入Zookeeper队列，两个消费者监听队列，共同消费订单。以此模拟下单业务，使用队列来提升订单系统的可用性及处理订单的吞吐量。

1.项目依赖

在Spring Boot工程中，使用Apache Curator作为操作Zookeeper的API。Apache Curator大大简化了ZooKeeper客户端的使用，并为常见的分布式协同服务提供了高质量的实现。

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.7</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.70</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.在resource目录下创建一个zookeeper.properties,配置zookeeper服务端的连接信息

# 初始化sleep的时间，用于计算之后的每次重试的sleep时间
zk.baseSleepTimeMS=1000
# 最大重试次数
zk.maxRetries=1
# zk服务端地址
zk.connectString=127.0.0.1:2181
# 会话超时时间，单位毫秒
zk.sessionTimeoutMs=1000
# 连接超时时间，单位毫秒
zk.connectionTimeoutMs=1000
zk.queueName=/order

3.封装zookeeper工具类

public class ZKQueueUtils {
    private static int baseSleepTimeMS;
    private static int maxRetries;
    private static  String connectString;
    private static CuratorFramework client;
    private static int sessionTimeoutMs;
    private static int connectionTimeoutMs;
    private static DistributedQueue<String>  queue;
    private static  String queueName;

    // 初始化连接
    static{
        ClassPathResource classPathResource = new ClassPathResource("zookeeper.properties");
        Properties properties = new Properties();
        try {
            properties.load(classPathResource.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
         baseSleepTimeMS = Integer.valueOf(properties.getProperty("zk.baseSleepTimeMS"));
         maxRetries = Integer.valueOf(properties.getProperty("zk.maxRetries"));
         connectString = properties.getProperty("zk.connectString");
         sessionTimeoutMs =  Integer.valueOf(properties.getProperty("zk.sessionTimeoutMs"));
         connectionTimeoutMs =  Integer.valueOf(properties.getProperty("zk.connectionTimeoutMs"));
         queueName=properties.getProperty("zk.queueName");
        initClient();
        if(queueName != null && !"".equals(queueName))
        createQueue();

    }


    public static CuratorFramework getClient(){
        return ZKQueueUtils.client;
    }

    public  static void initClient(){


        RetryPolicy retryPolicy = new ExponentialBackoffRetry(baseSleepTimeMS,maxRetries);
        ZKQueueUtils.client = CuratorFrameworkFactory.newClient(connectString, sessionTimeoutMs, connectionTimeoutMs, retryPolicy);
        ZKQueueUtils.client.start();
    }

    public static void closeClient(){
        ZKQueueUtils.client.close();
    }

    /**
     * 创建队列
     * @param
     */
    public static void createQueue(){
        QueueBuilder<String> builder = QueueBuilder.builder(client, null, createQueueSerializer(), queueName);
        queue = builder.buildQueue();
        try {
            queue.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 创建队列
     * @param
     */
    public static DistributedQueue getQueue(){

        return queue;
    }

    public static void setQueueData(String data){
        try {
            queue.put(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void closeQueue(){
        try {
            queue.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private static QueueSerializer<String> createQueueSerializer() {
        return new QueueSerializer<String>(){
            @Override
            public byte[] serialize(String item) {
                return item.getBytes();
            }
            @Override
            public String deserialize(byte[] bytes) {
                return new String(bytes);
            }

        };
    }
}

4.创建订单消费者

@RestController
@RequestMapping("/order")
public class OrderController {
    private static final int count = 1000;
    @RequestMapping("/add")
    public String addOrder(){
        // 模拟下单
        for (int i = 0; i < count; i++) {
            Map map = new HashMap<>();
            map.put("orderId", UUID.randomUUID().toString());
            map.put("volumn", new Random().nextInt(100) + 1);
            map.put("instrumentID","ag"+i);
            map.put("price",count * i);
            map.put("dataTime",new Date());
            map.put("seq",i);
            // 订单对象存入队列
            ZKQueueUtils.setQueueData(JSON.toJSONString(map));
        }
        return "success";
    }
}

5.创建两个消费者

两个消费者代码相同，同时启动两个main方法即可。consumeMessage为消费者消费消息时，所执行的回调方法。builder.lockPath()方法，在两个消费者同时消费时会进行加锁操作，确保每个消息只能被一个消费者消费。并且，当其中一个消费者消费过程中发生错误时，该消息将重回队列。使用lockPath()方法会降低性能，但能减少消息丢失的概率。

public class Consumer1 {
    public static void main(String[] args) {
        DistributedQueue<String> queue = null;
        try {
        CuratorFramework client = ZKQueueUtils.getClient();
        QueueBuilder<String> builder = QueueBuilder.builder(client, new QueueConsumer<String>() {
            @Override
            public void consumeMessage(String s) throws Exception {
//                Map map = JSON.parseObject(s, Map.class);
                System.out.println(s);
            }

            @Override
            public void stateChanged(CuratorFramework curatorFramework, ConnectionState connectionState) {

            }
        }, createQueueSerializer(), "/order");
        queue = builder.lockPath("/orderlock").buildQueue();
            queue.start();
            // 阻塞进程
            System.in.read();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(queue != null) {
                    queue.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6.测试

消费者1：

消费2：

 

经过测试，1000笔订单两个消费者可同时进行消费，且不会重复消费，6-7秒即可完成，性能还是相对不错的。

之前有用ZK的顺序节点和监听机制自己实现分布式队列，但效果并不好，欢迎有经验的大牛们指点和一同讨论~

本案例源码:zookeeper-queue: zookeeper实现分布式队列