前言

上一篇文章,介绍了Pulsar的生产者,消费者以及Topic的入门概念,最后留了疑问
1 有没有UI工具能够动态的一手掌握管理Pulsar
2 如何操作Pulsar的Topic,创建租户,namespace等

消息队列Pulsar入门(一) 生产者/消费者/Topic详解,附源码演示

Pulsar Manager

docker启动

docker run --name pulsar-manager -dit -p 9527:9527 -p 7750:7750 -e SPRING_CONFIGURATION_FILE=/pulsar-manager/pulsar-manager/application.properties  apachepulsar/pulsar-manager

浏览器访问

http://部署机器IP:9527

内置登录账号

请注意Pulsar Manage启动后,登陆界面需输入账号密码,这里的账号密码需要手动内置,执行以下shell

CSRF_TOKEN=$(curl http://localhost:7750/pulsar-manager/csrf-token)
curl \

   -H 'X-XSRF-TOKEN: $CSRF_TOKEN' \

   -H 'Cookie: XSRF-TOKEN=$CSRF_TOKEN;' \

   -H "Content-Type: application/json" \

   -X PUT http://localhost:7750/pulsar-manager/users/superuser \

   -d '{"name": "admin", "password": "apachepulsar", "description": "test", "email": "username@test.org"}'

账号登陆

输入刚才内置的账号密码 admin/apachepulsar 直接登陆即可
然后将我们的pulsar环境信息添加进去就可以了
随便点点可以看到之前我们操作过的topic各种信息

Topic详解

Pulsar对topic的命名有如下规则，
{persistent|non-persistent}://tenant/namespace/topic,具体意义看上一篇文章
默认是persistent://public/default/topic
直接尝试跑程序程序创建,是会报错的,我们通过刚才的Pulsar manage先创建好命名空间 namespace_test4(也可以命令行,代码等创建,这里只演示PulsarManage)

/**
 * 报错
 * 向租户sample 命名空间 namespace_test4  topic topic-haha1 发送消息
 * 注意namespace需手动先创建好,否则会报错 olicies not found for sample/namespace_test4 namespace
 */
@Test
public void testProduce322() throws Exception {
    Producer<String> producer = client.newProducer(Schema.STRING)
            .topic("persistent://sample/namespace_test4/topic-haha1")
            .enableBatching(false)
            .create();
    producer.send("向租户sample 命名空间 namespace_test2  topic topic-haha1 发送消息");
    System.in.read();
}

测试namespace

1 向租户public 命名空间namespace_test1 topic topic-demo1 发送消息
  然后消费者设置 persistent://public/namespace_test1/topic-demo1 与topic-demo1消费
  看看那个会消费？？ 只有persistent://public/namespace_test1/topic-demo1会消费,因为指定了namespace

/**
 * 向租户public 命名空间 namespace_test1 topic topic-demo1 发送消息
 */
@Test
public void testProduce1() throws Exception {
    Producer<String> producer = client.newProducer(Schema.STRING)
            .topic("persistent://public/namespace_test1/topic-demo1")
            .enableBatching(false)
            .create();
    producer.send("111");
    System.in.read();
}

/**
 * 测试消费
 * 只会打印出 Message received my-subscription2 因为指定了 namespace
 */
@Test
public void testConsumer1() throws IOException {
    MessageListener myMessageListener = (consumer, msg) -> {
        try {
            System.out.println("Message received my-subscription1 : " + new String(msg.getData()));
            consumer.acknowledge(msg);
        } catch (Exception e) {
            consumer.negativeAcknowledge(msg);
        }
    };
    Consumer consumer = client.newConsumer()
            .topic("topic-demo1")
            .subscriptionName("my-subscription1")
            .messageListener(myMessageListener)
            .subscribe();

    MessageListener myMessageListener2 = (consumer2, msg) -> {
        try {
            System.out.println("Message received my-subscription2 : " + new String(msg.getData()));
            consumer2.acknowledge(msg);
        } catch (Exception e) {
            consumer2.negativeAcknowledge(msg);
        }
    };
    Consumer consumer2 = client.newConsumer()
            .topic("persistent://public/namespace_test1/topic-demo1")
            .subscriptionName("my-subscription2")
            .messageListener(myMessageListener2)
            .subscribe();

    System.in.read();
}

验证默认persistent://public/default/topic

往topic hh_xixi1 发送一条消息,然后有三个消费者
hh_xixi1     会消费
persistent://public/default/hh_xixi1      会消费 符合默认
non-persistent://public/default/hh_xixi1   不会消费 因为是non-persistent

/**
 * 默认是persistent://public/default/topic
 */
@Test
public void testProduce3() throws Exception {
    Producer<String> producer = client.newProducer(Schema.STRING)
            .topic("hh_xixi1")
            .enableBatching(false)
            .create();
    producer.send("hh-xixi1");
    System.in.read();
}


/**
 * 测试消费
 * 也就是默认是 persistent://public/default/topic
 * 只会打印 my-subscription1 my-subscription2  不可打印 my-subscription3 因为设置接受的是非久化接收 non-persistent
 */
@Test
public void testConsumer4() throws IOException {
    MessageListener myMessageListener = (consumer, msg) -> {
        try {
            System.out.println("Message received my-subscription1 : " + new String(msg.getData()));
            consumer.acknowledge(msg);
        } catch (Exception e) {
            consumer.negativeAcknowledge(msg);
        }
    };
    Consumer consumer = client.newConsumer()
            .topic("hh_xixi1")
            .subscriptionName("my-subscription1")
            .messageListener(myMessageListener)
            .subscribe();


    MessageListener myMessageListener2 = (consumer2, msg) -> {
        try {
            System.out.println("Message received my-subscription2 : " + new String(msg.getData()));
            consumer2.acknowledge(msg);
        } catch (Exception e) {
            consumer2.negativeAcknowledge(msg);
        }
    };
    Consumer consumer2 = client.newConsumer()
            //验证默认是 persistent://public/default/topic
            .topic("persistent://public/default/hh_xixi1")
            .subscriptionName("my-subscription2")
            .messageListener(myMessageListener2)
            .subscribe();


    MessageListener myMessageListener3 = (consumer3, msg) -> {
        try {
            System.out.println("Message received my-subscription3 : " + new String(msg.getData()));
            consumer3.acknowledge(msg);
        } catch (Exception e) {
            consumer3.negativeAcknowledge(msg);
        }
    };
    Consumer consumer3 = client.newConsumer()
            //非持久化
            .topic("non-persistent://public/default/hh_xixi1")
            .subscriptionName("my-subscription3")
            .messageListener(myMessageListener3)
            .subscribe();

    System.in.read();
}