Pulsar源码解析-分区Producer创建的底层实现

上一篇介绍过
Pulsar源码解析-非分区Topic的Producer底层实现原理

差别不大，主要在客户端，回到创建Producer时的代码

    private <T> CompletableFuture<Producer<T>> createProducerAsync(String topic,
                                                                   ProducerConfigurationData conf,
                                                                   Schema<T> schema,
                                                                   ProducerInterceptors interceptors) {
        CompletableFuture<Producer<T>> producerCreatedFuture = new CompletableFuture<>();

        getPartitionedTopicMetadata(topic).thenAccept(metadata -> {

            ProducerBase<T> producer;
            if (metadata.partitions > 0) {
            	// 分区Topic创建
                producer = newPartitionedProducerImpl(topic, conf, schema, interceptors, producerCreatedFuture,
                        metadata);
            } else {
                producer = newProducerImpl(topic, -1, conf, schema, interceptors, producerCreatedFuture);
            }

            producers.add(producer);
        }).exceptionally(ex -> {
        });

        return producerCreatedFuture;
    }

具体在newPartitionedProducerImpl中

public class PartitionedProducerImpl<T> extends ProducerBase<T> {

    public PartitionedProducerImpl(PulsarClientImpl client, String topic, ProducerConfigurationData conf, int numPartitions,
            CompletableFuture<Producer<T>> producerCreatedFuture, Schema<T> schema, ProducerInterceptors interceptors) {
        super(client, topic, conf, producerCreatedFuture, schema, interceptors);
        // 收集每个生产者的集合
        this.producers = Lists.newArrayListWithCapacity(numPartitions);
        this.topicMetadata = new TopicMetadataImpl(numPartitions);
        this.routerPolicy = getMessageRouter();
        stats = client.getConfiguration().getStatsIntervalSeconds() > 0 ? new ProducerStatsRecorderImpl() : null;
		
        int maxPendingMessages = Math.min(conf.getMaxPendingMessages(),
                conf.getMaxPendingMessagesAcrossPartitions() / numPartitions);
        conf.setMaxPendingMessages(maxPendingMessages);
		// 关键
        start();
		// 分区更新后自动发现
        if (conf.isAutoUpdatePartitions()) {
            topicsPartitionChangedListener = new TopicsPartitionChangedListener();
            partitionsAutoUpdateTimeout = client.timer()
                .newTimeout(partitionsAutoUpdateTimerTask, conf.getAutoUpdatePartitionsIntervalSeconds(), TimeUnit.SECONDS);
        }
    }
}

关键在start();

private void start() {
        AtomicReference<Throwable> createFail = new AtomicReference<Throwable>();
        AtomicInteger completed = new AtomicInteger();
        // 根据分区数创建对应数量Producer
        for (int partitionIndex = 0; partitionIndex < topicMetadata.numPartitions(); partitionIndex++) {
            String partitionName = TopicName.get(topic).getPartition(partitionIndex).toString();
            ProducerImpl<T> producer = client.newProducerImpl(partitionName, partitionIndex,
                    conf, schema, interceptors, new CompletableFuture<>());
            producers.add(producer);
            producer.producerCreatedFuture().handle((prod, createException) -> {
            	// 有任何一个失败都是失败
                if (createException != null) {
                    setState(State.Failed);
                    createFail.compareAndSet(null, createException);
                }
                // 最后一个分区创建完成
                if (completed.incrementAndGet() == topicMetadata.numPartitions()) {
                    if (createFail.get() == null) {
                    	// 标记分区Producer Ready
                        setState(State.Ready);
                        producerCreatedFuture().complete(PartitionedProducerImpl.this);
                    } else {
                        closeAsync().handle((ok, closeException) -> {
                            producerCreatedFuture().completeExceptionally(createFail.get());
                            client.cleanupProducer(this);
                            return null;
                        });
                    }
                }

                return null;
            });
        }

    }

看完上面这个相信大家都明白了，非分区topic的生产者只创建一个，分区Topic的生产者有多少分区数，创建多少生产者。
创建的区别就这么多，别的还有不同例如：发送时要选择一个分区发，有对应的路由策略。如果Close，则要遍历producer列表关闭每一个。

总结：Producer创建的核心还是在上一篇，不同点就是分区topic的Producer会创建对应分区数了的Producer。

Pulsar源码解析-非分区Topic的Producer底层实现原理