Java Producer.send方法代码示例

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
public static void main(String[] args) throws PulsarClientException, InterruptedException, IOException {
    PulsarClient pulsarClient = PulsarClient.create("http://127.0.0.1:8080");

    Producer producer = pulsarClient.createProducer("persistent://my-property/use/my-ns/my-topic");

    while (true) {
        try {
            producer.send("my-message".getBytes());
            Thread.sleep(1000);

        } catch (Exception e) {
            e.printStackTrace();
            break;
        }
    }

    pulsarClient.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testMockBrokerService() throws Exception {
    // test default actions of mock broker service
    try {
        PulsarClient client = PulsarClient.create("http://127.0.0.1:" + WEB_SERVICE_PORT);

        ConsumerConfiguration conf = new ConsumerConfiguration();
        conf.setSubscriptionType(SubscriptionType.Exclusive);
        Consumer consumer = client.subscribe("persistent://prop/use/ns/t1", "sub1", conf);

        Producer producer = client.createProducer("persistent://prop/use/ns/t1");
        Thread.sleep(ASYNC_EVENT_COMPLETION_WAIT);
        producer.send("message".getBytes());
        Thread.sleep(ASYNC_EVENT_COMPLETION_WAIT);

        consumer.unsubscribe();

        producer.close();
        consumer.close();
        client.close();
    } catch (Exception e) {
        fail("None of the mocked operations should throw a client side exception");
    }
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testNamespaceSplitBundle() throws Exception {
    // Force to create a destination
    final String namespace = "prop-xyz/use/ns1";
    final String topicName = (new StringBuilder("persistent://")).append(namespace).append("/ds2").toString();
    Producer producer = pulsarClient.createProducer(topicName);
    producer.send("message".getBytes());
    publishMessagesOnPersistentTopic(topicName, 0);
    assertEquals(admin.persistentTopics().getList(namespace), Lists.newArrayList(topicName));

    try {
        admin.namespaces().splitNamespaceBundle(namespace, "0x00000000_0xffffffff", true);
    } catch (Exception e) {
        fail("split bundle shouldn't have thrown exception");
    }

    // bundle-factory cache must have updated split bundles
    NamespaceBundles bundles = bundleFactory.getBundles(NamespaceName.get(namespace));
    String[] splitRange = { namespace + "/0x00000000_0x7fffffff", namespace + "/0x7fffffff_0xffffffff" };
    for (int i = 0; i < bundles.getBundles().size(); i++) {
        assertEquals(bundles.getBundles().get(i).toString(), splitRange[i]);
    }

    producer.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException {
    // Create a Pulsar client instance. A single instance can be shared across many
    // producers and consumer within the same application
    PulsarClient client = PulsarClient.create(SERVICE_URL);

    // Here you get the chance to configure producer specific settings. eg:
    ProducerConfiguration conf = new ProducerConfiguration();

    // Enable compression
    conf.setCompressionType(CompressionType.LZ4);

    // Once the producer is created, it can be used for the entire application life-cycle
    Producer producer = client.createProducer(TOPIC_NAME, conf);
    log.info("Created Pulsar producer");

    // Send few test messages
    for (int i = 0; i < 10; i++) {
        String content = String.format("hello-pulsar-%d", i);

        // Build a message object
        Message msg = MessageBuilder.create().setContent(content.getBytes()).build();

        // Send a message (waits until the message is persisted)
        MessageId msgId = producer.send(msg);

        log.info("Published msg='{}' with msg-id={}", content, msgId);
    }

    client.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test(timeOut = 20000)
public void testSimpleTerminationReader() throws Exception {
    Producer producer = pulsarClient.createProducer(topicName);

    MessageId msgId1 = producer.send("test-msg-1".getBytes());
    MessageId msgId2 = producer.send("test-msg-2".getBytes());
    MessageId msgId3 = producer.send("test-msg-3".getBytes());

    MessageId lastMessageId = admin.persistentTopics().terminateTopicAsync(topicName).get();
    assertEquals(lastMessageId, msgId3);

    Reader reader = pulsarClient.createReader(topicName, MessageId.earliest, new ReaderConfiguration());

    Message msg1 = reader.readNext();
    assertEquals(msg1.getMessageId(), msgId1);

    Message msg2 = reader.readNext();
    assertEquals(msg2.getMessageId(), msgId2);

    Message msg3 = reader.readNext();
    assertEquals(msg3.getMessageId(), msgId3);

    Message msg4 = reader.readNext(100, TimeUnit.MILLISECONDS);
    assertNull(msg4);

    Thread.sleep(100);
    assertTrue(reader.hasReachedEndOfTopic());
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testSeek() throws Exception {
    final String topicName = "persistent://prop/use/ns-abc/testSeek";

    Producer producer = pulsarClient.createProducer(topicName);

    ConsumerConfiguration consumerConf = new ConsumerConfiguration();

    // Disable pre-fetch in consumer to track the messages received
    consumerConf.setReceiverQueueSize(0);
    org.apache.pulsar.client.api.Consumer consumer = pulsarClient.subscribe(topicName, "my-subscription",
            consumerConf);

    PersistentTopic topicRef = (PersistentTopic) pulsar.getBrokerService().getTopicReference(topicName);
    assertNotNull(topicRef);
    assertEquals(topicRef.getProducers().size(), 1);
    assertEquals(topicRef.getSubscriptions().size(), 1);

    List<MessageId> messageIds = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        String message = "my-message-" + i;
        MessageId msgId = producer.send(message.getBytes());
        messageIds.add(msgId);
    }

    PersistentSubscription sub = topicRef.getSubscription("my-subscription");
    assertEquals(sub.getNumberOfEntriesInBacklog(), 10);

    consumer.seek(MessageId.latest);
    assertEquals(sub.getNumberOfEntriesInBacklog(), 0);

    // Wait for consumer to reconnect
    Thread.sleep(500);
    consumer.seek(MessageId.earliest);
    assertEquals(sub.getNumberOfEntriesInBacklog(), 10);

    Thread.sleep(500);
    consumer.seek(messageIds.get(5));
    assertEquals(sub.getNumberOfEntriesInBacklog(), 5);
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testProducerException() throws Exception {
    assertEquals(admin.namespaces().getBacklogQuotaMap("prop/usc/quotahold"), Maps.newTreeMap());
    admin.namespaces().setBacklogQuota("prop/usc/quotahold",
            new BacklogQuota(10 * 1024, BacklogQuota.RetentionPolicy.producer_exception));
    final ClientConfiguration clientConf = new ClientConfiguration();
    clientConf.setStatsInterval(0, TimeUnit.SECONDS);
    final PulsarClient client = PulsarClient.create(adminUrl.toString(), clientConf);
    final String topic1 = "persistent://prop/usc/quotahold/except";
    final String subName1 = "c1except";
    boolean gotException = false;

    client.subscribe(topic1, subName1);
    ProducerConfiguration producerConfiguration = new ProducerConfiguration();
    producerConfiguration.setSendTimeout(2, TimeUnit.SECONDS);

    byte[] content = new byte[1024];
    Producer producer = client.createProducer(topic1, producerConfiguration);
    for (int i = 0; i < 10; i++) {
        producer.send(content);
    }

    Thread.sleep((TIME_TO_CHECK_BACKLOG_QUOTA + 1) * 1000);

    try {
        // try to send over backlog quota and make sure it fails
        producer.send(content);
        producer.send(content);
        Assert.fail("backlog quota did not exceed");
    } catch (PulsarClientException ce) {
        Assert.assertTrue(ce instanceof PulsarClientException.ProducerBlockedQuotaExceededException
                || ce instanceof PulsarClientException.TimeoutException, ce.getMessage());
        gotException = true;
    }

    Assert.assertTrue(gotException, "backlog exceeded exception did not occur");
    client.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testBrokerTopicStats() throws Exception {

    BrokerService brokerService = this.pulsar.getBrokerService();
    Field field = BrokerService.class.getDeclaredField("statsUpdater");
    field.setAccessible(true);
    ScheduledExecutorService statsUpdater = (ScheduledExecutorService) field.get(brokerService);
    // disable statsUpdate to calculate rates explicitly
    statsUpdater.shutdown();

    final String namespace = "prop/use/ns-abc";
    ProducerConfiguration producerConf = new ProducerConfiguration();
    Producer producer = pulsarClient.createProducer("persistent://" + namespace + "/topic0", producerConf);
    // 1. producer publish messages
    for (int i = 0; i < 10; i++) {
        String message = "my-message-" + i;
        producer.send(message.getBytes());
    }
    Metrics metric = null;

    // sleep 1 sec to caclulate metrics per second
    Thread.sleep(1000);
    brokerService.updateRates();
    List<Metrics> metrics = brokerService.getDestinationMetrics();
    for (int i = 0; i < metrics.size(); i++) {
        if (metrics.get(i).getDimension("namespace").equalsIgnoreCase(namespace)) {
            metric = metrics.get(i);
            break;
        }
    }
    assertNotNull(metric);
    double msgInRate = (double) metrics.get(0).getMetrics().get("brk_in_rate");
    // rate should be calculated and no must be > 0 as we have produced 10 msgs so far
    assertTrue(msgInRate > 0);
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test(dataProvider = "codec")
public void testCompression(CompressionType compressionType) throws Exception {
    final String topicName = "persistent://prop/use/ns-abc/topic0" + compressionType;

    // 1. producer connect
    ProducerConfiguration producerConf = new ProducerConfiguration();
    producerConf.setCompressionType(compressionType);
    Producer producer = pulsarClient.createProducer(topicName, producerConf);

    Consumer consumer = pulsarClient.subscribe(topicName, "my-sub");

    PersistentTopic topicRef = (PersistentTopic) pulsar.getBrokerService().getTopicReference(topicName);
    assertNotNull(topicRef);
    assertEquals(topicRef.getProducers().size(), 1);

    // 2. producer publish messages
    for (int i = 0; i < 10; i++) {
        String message = "my-message-" + i;
        producer.send(message.getBytes());
    }

    for (int i = 0; i < 10; i++) {
        Message msg = consumer.receive(5, TimeUnit.SECONDS);
        assertNotNull(msg);
        assertEquals(msg.getData(), ("my-message-" + i).getBytes());
    }

    // 3. producer disconnect
    producer.close();
    consumer.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testProducer() throws Exception {
    PulsarClient client = PulsarClient.create("pulsar://localhost:" + proxyConfig.getServicePort());
    Producer producer = client.createProducer("persistent://sample/test/local/producer-topic");

    for (int i = 0; i < 10; i++) {
        producer.send("test".getBytes());
    }

    client.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
private void publishMessagesOnPersistentTopic(String topicName, int messages, int startIdx) throws Exception {
    Producer producer = pulsarClient.createProducer(topicName);

    for (int i = startIdx; i < (messages + startIdx); i++) {
        String message = "message-" + i;
        producer.send(message.getBytes());
    }

    producer.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testDoubleTerminate() throws Exception {
    Producer producer = pulsarClient.createProducer(topicName);

    /* MessageId msgId1 = */producer.send("test-msg-1".getBytes());
    /* MessageId msgId2 = */producer.send("test-msg-2".getBytes());
    MessageId msgId3 = producer.send("test-msg-3".getBytes());

    MessageId lastMessageId = admin.persistentTopics().terminateTopicAsync(topicName).get();
    assertEquals(lastMessageId, msgId3);

    // Terminate it again
    lastMessageId = admin.persistentTopics().terminateTopicAsync(topicName).get();
    assertEquals(lastMessageId, msgId3);
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test
public void testAheadProducerOnHoldTimeout() throws Exception {
    assertEquals(admin.namespaces().getBacklogQuotaMap("prop/usc/quotahold"), Maps.newTreeMap());
    admin.namespaces().setBacklogQuota("prop/usc/quotahold",
            new BacklogQuota(10 * 1024, BacklogQuota.RetentionPolicy.producer_request_hold));
    final ClientConfiguration clientConf = new ClientConfiguration();
    clientConf.setStatsInterval(0, TimeUnit.SECONDS);
    final PulsarClient client = PulsarClient.create(adminUrl.toString(), clientConf);
    final String topic1 = "persistent://prop/usc/quotahold/holdtimeout";
    final String subName1 = "c1holdtimeout";
    boolean gotException = false;

    client.subscribe(topic1, subName1);
    ProducerConfiguration producerConfiguration = new ProducerConfiguration();
    producerConfiguration.setSendTimeout(2, TimeUnit.SECONDS);

    byte[] content = new byte[1024];
    Producer producer = client.createProducer(topic1, producerConfiguration);
    for (int i = 0; i < 10; i++) {
        producer.send(content);
    }

    Thread.sleep((TIME_TO_CHECK_BACKLOG_QUOTA + 1) * 1000);

    try {
        // try to send over backlog quota and make sure it fails
        producer.send(content);
        producer.send(content);
        Assert.fail("backlog quota did not exceed");
    } catch (PulsarClientException.TimeoutException te) {
        gotException = true;
    }

    Assert.assertTrue(gotException, "timeout did not occur");
    client.close();
}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
/**
 * Validation: 1. validates active-cursor after active subscription 2. validate active-cursor with subscription 3.
 * unconsumed messages should be present into cache 4. cache and active-cursor should be empty once subscription is
 * closed
 *
 * @throws Exception
 */
@Test
public void testActiveSubscriptionWithCache() throws Exception {
    final String topicName = "persistent://prop/use/ns-abc/topic2";
    final String subName = "sub2";

    Message msg;
    int recvQueueSize = 4;

    ConsumerConfiguration conf = new ConsumerConfiguration();
    conf.setSubscriptionType(SubscriptionType.Exclusive);
    conf.setReceiverQueueSize(recvQueueSize);

    // (1) Create subscription
    Consumer consumer = pulsarClient.subscribe(topicName, subName, conf);
    Producer producer = pulsarClient.createProducer(topicName);

    // (2) Produce Messages
    for (int i = 0; i < recvQueueSize / 2; i++) {
        String message = "my-message-" + i;
        producer.send(message.getBytes());
        msg = consumer.receive();
        consumer.acknowledge(msg);
    }

    PersistentTopic topicRef = (PersistentTopic) pulsar.getBrokerService().getTopicReference(topicName);

    // (3) Get Entry cache
    ManagedLedgerImpl ledger = (ManagedLedgerImpl) topicRef.getManagedLedger();
    Field cacheField = ManagedLedgerImpl.class.getDeclaredField("entryCache");
    cacheField.setAccessible(true);
    EntryCacheImpl entryCache = (EntryCacheImpl) cacheField.get(ledger);

    /************* Validation on non-empty active-cursor **************/
    // (4) Get ActiveCursor : which is list of active subscription
    Iterable<ManagedCursor> activeCursors = ledger.getActiveCursors();
    ManagedCursor curosr = activeCursors.iterator().next();
    // (4.1) Validate: active Cursor must be non-empty
    assertNotNull(curosr);
    // (4.2) Validate: validate cursor name
    assertEquals(subName, curosr.getName());
    // (4.3) Validate: entryCache should have cached messages
    assertTrue(entryCache.getSize() != 0);

    /************* Validation on empty active-cursor **************/
    // (5) Close consumer: which (1)removes activeConsumer and (2)clears the entry-cache
    consumer.close();
    Thread.sleep(1000);
    // (5.1) Validate: active-consumer must be empty
    assertFalse(ledger.getActiveCursors().iterator().hasNext());
    // (5.2) Validate: Entry-cache must be cleared
    assertTrue(entryCache.getSize() == 0);

}
 

import org.apache.pulsar.client.api.Producer; //导入方法依赖的package包/类
@Test(timeOut = 30000)
public void testAsyncPartitionedProducerConsumerQueueSizeOne() throws Exception {
    log.info("-- Starting {} test --", methodName);

    final int totalMsg = 100;
    final Set<String> produceMsgs = Sets.newHashSet();
    final Set<String> consumeMsgs = Sets.newHashSet();

    int numPartitions = 4;
    DestinationName dn = DestinationName.get("persistent://my-property/use/my-ns/my-partitionedtopic1");

    ConsumerConfiguration conf = new ConsumerConfiguration();
    conf.setReceiverQueueSize(1);

    admin.persistentTopics().createPartitionedTopic(dn.toString(), numPartitions);

    ProducerConfiguration producerConf = new ProducerConfiguration();
    producerConf.setMessageRoutingMode(MessageRoutingMode.RoundRobinPartition);
    Producer producer = pulsarClient.createProducer(dn.toString(), producerConf);

    Consumer consumer = pulsarClient.subscribe(dn.toString(), "my-partitioned-subscriber", conf);

    // produce messages
    for (int i = 0; i < totalMsg; i++) {
        String message = "my-message-" + i;
        produceMsgs.add(message);
        producer.send(message.getBytes());
    }

    log.info(" start receiving messages :");

    // receive messages
    CountDownLatch latch = new CountDownLatch(totalMsg);
    receiveAsync(consumer, totalMsg, 0, latch, consumeMsgs, executor);

    latch.await();

    // verify message produced correctly
    assertEquals(produceMsgs.size(), totalMsg);
    // verify produced and consumed messages must be exactly same
    produceMsgs.removeAll(consumeMsgs);
    assertTrue(produceMsgs.isEmpty());

    producer.close();
    consumer.unsubscribe();
    consumer.close();
    admin.persistentTopics().deletePartitionedTopic(dn.toString());

    log.info("-- Exiting {} test --", methodName);
}