分布式消息系统jafka快速起步（转）

Jafka 是一个开源的/性能良好的分布式消息系统。在上一篇文章中有所简单介绍。
下面是一篇简单的入门文档。更多详细的文档参考wiki。

Step 1: 下载最新的安装包

完整的安装指南在这里。
最新的发行版地址在：https://github.com/adyliu/jafka/downloads

$wget https://github.com/downloads/adyliu/jafka/jafka-1.0.tgz 
$tar xzf jafka-1.0.tgz 
$cd jafka-1.0 

可选配置，设置一个环境变量。 $export $JAFKA_HOME=/opt/apps/jafka-1.0 以下假设所有操作目录都在$JAFKA_HOME下。

Step 2: 启动服务端

这里启动一个单进程的服务端，使用默认的配置启动即可。由于一些路径使用了相对路径，因此需要在jafka的主目录下运行。

$bash bin/server-single.sh config/server-single.properties 

默认情况下，无需任何配置即可运行服务端。这时服务端会将9092端口绑定到所有网卡上。

Step 3: 发送消息

使用自带的小命令行就可以发送简单的文本消息。

$bin/producer-console.sh --broker-list 0:localhost:9092 --topic demo 
> Welcome to jafka 
> 中文中国 

producer-console.sh有一些参数，这可以通过执行下面的命令得到。 $bin/producer-console.sh

发送消息只需要在提示符号'>'输入文本即可，没有出错意味着发送成功，直接回车或者输入CTRL+C退出程序。

Step 4: 启动消费者

现在是时候消费刚才发送的消息。

同样Jafka自带一个小程序能够消费简单的文本消息。

$bin/simple-consumer-console.sh --topic demo --server jafka://localhost:9092 
[1] 26: Welcome to jafka 
[2] 48: 中文中国 

连接上服务端后，立即就看到有消息消费了。默认情况下simple-consumer-console.sh输出消息的序号（实际上不存在）以及消息的下一个偏移量(offset)。

解压缩后只需要执行上面三条命令就可以完成简单的消息发送和接受演示。这就是一个简单的消息系统。

Step 5: 手动编码

我们希望利用提供的API手动编码能够发送和接受一些消息。

消息发送者

首先写一个简单的消息发送者。

public static void main(String[] args) throws Exception {
    Properties props = new Properties();
    props.put("broker.list", "0:127.0.0.1:9092");
    props.put("serializer.class", StringEncoder.class.getName());
    //
    ProducerConfig config = new ProducerConfig(props);
    Producer<String, String> producer = new Producer<String, String>(config);
    //
    StringProducerData data = new StringProducerData("demo");
    for(int i=0;i<1000;i++) {
        data.add("Hello world #"+i);
    }
    //
    try {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            producer.send(data);
        }
        long cost = System.currentTimeMillis() - start;
        System.out.println("send 100000 message cost: "+cost+" ms");
    } finally {
        producer.close();
    }
}

看起来有点复杂，我们简单分解下。

配置参数

首先需要配置服务端的地址。一个jfaka服务端地址格式如下：

brokerId:host:port 

• brokerId 用于标识服务进程，这在一个集群里面是全局唯一的
• host/port 用户描述服务监听的ip地址和端口，默认情况下会在所有网卡的9092端口监听数据。

配置完服务端信息后，我们需要提供一个消息编码。

消息编码用于将任意消息类型编码成字节数组，这些字节数组就是我们的消息体。 

默认情况下Jafka解析字节数组编码，也就是原封不动的发送出去。这里简单替换下，使用字符串UTF-8编码。

构造消息客户端

使用上面简单的参数就可以构造出来一个简单的消息发送客户端。

消息发送客户端(Producer)用于管理与服务端之间的连接，并将消息按照指定的编码方式发送给服务端。 

构造消息

用于使用字符串编码，因此这里只能发送字符串的数据。每一个消息数据包都可以带有多条消息，只需要满足一个消息数据包的大小不超过默认的1M即可。比如下面就构造发往主题为demo的100条消息的数据包：

StringProducerData data = new StringProducerData("demo");
for(int i=0;i<1000;i++) {
data.add("Hello world #"+i);
} 

发送消息

最后发送消息只需要调用producer.send()即可。上述例子中循环发送100次。

下面是某次发送的结果：

$bin/run-console.sh demo.client.StaticBrokerSender
send 100000 message cost: 685 ms 

消息接受者

接受消息的逻辑非常简单，只需要配置服务端的地址，然后从偏移量0开始顺序消费消息即可。

下面的逻辑是简单的将接受的消息以UTF-8的字符串展示。

SimpleConsumer consumer = new SimpleConsumer("127.0.0.1", 9092);
//
long offset = 0;
while (true) {
    FetchRequest request = new FetchRequest("test", 0, offset);
    for (MessageAndOffset msg : consumer.fetch(request)) {
        System.out.println(Utils.toString(msg.message.payload(), "UTF-8"));
        offset = msg.offset;
    }
}

---

整合ZooKeeper

Jafka 使用zookeeper进行自动broker寻址以及消费者负载均衡。

(1)启动zookeeper服务

测试时可以使用一个单进程的zookeeper用于替换zookeeper集群。

$bin/zookeeper-server.sh config/zookeeper.properties 

(2)启动Jafka服务端

$bin/server-single.sh config/server.properties 
[2012-04-24 12:29:56,526] INFO Starting Jafka server (com.sohu.jafka.server.Server.java:68)
[2012-04-24 12:29:56,532] INFO starting log cleaner every 60000 ms (com.sohu.jafka.log.LogManager.java:155)
[2012-04-24 12:29:56,552] INFO connecting to zookeeper: 127.0.0.1:2181 (com.sohu.jafka.server.Zookeeper.java:80)
[2012-04-24 12:29:56,568] INFO Starting ZkClient event thread. (com.github.zkclient.ZkEventThread.java:64)

服务端启动后自动向zookeeper注册服务端的信息，例如ip地址、端口、已存在的消息等。

(3)启动消息发送者

$bin/producer-console.sh --zookeeper localhost:2181 --topic demo
Enter you message and exit with empty string.
> Jafka second day
> Jafka use zookeeper to search brokers and consumers                                       
> 

和上面启动的消息发送者类似，只不过这里使用zookeeper配置自动寻找服务端，而不是指定服务端地址。

(4)启动消息接受者

$bin/consumer-console.sh --zookeeper localhost:2181 --topic demo --from-beginning
Jafka second day
Jafka use zookeeper to search brokers and consumers

这时候很快就看到刚才发送的消息了。

由于使用zookeeper作为配置中心，因此可以启动更多的服务端、消息发送者、消息接受者。只需要保证都连接zookeeper，并且所有的服务端都有唯一的brokerId(位于server.properties中).

(5)API使用

上面是使用自带的程序发送简单的文本消息。这里利用API来进行开发。

发送消息

   public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.put("zk.connect", "localhost:2181");
        props.put("serializer.class", StringEncoder.class.getName());
        //
        ProducerConfig config = new ProducerConfig(props);
        Producer<String, String> producer = new Producer<String, String>(config);
        //
        StringProducerData data = new StringProducerData("demo");
        for(int i=0;i<100;i++) {
            data.add("Hello world #"+i);
        }
        //
        try {
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100; i++) {
                producer.send(data);
            }
            long cost = System.currentTimeMillis() - start;
            System.out.println("send 10000 message cost: "+cost+" ms");
        } finally {
            producer.close();
        }
    }

和不使用zookeeper的消息发送者对比，只需要将服务端配置信息替换成zookeeper连接地址即可。其它完全一致。

接收消息

接受消息看起来稍微有点复杂，简单来说是如下几步：

• 配置zookeeper以及客户端groupid
• 与服务端的连接
• 创建消息流
• 启动线程池消费消息

public static void main(String[] args) throws Exception {

Properties props = new Properties();
    props.put("zk.connect", "localhost:2181");
    props.put("groupid", "test_group");
    //
    ConsumerConfig consumerConfig = new ConsumerConfig(props);
    ConsumerConnector connector = Consumer.create(consumerConfig);
    //
    Map<String, List<MessageStream<String>>> topicMessageStreams = connector.createMessageStreams(ImmutableMap.of("demo", 2), new StringDecoder());
    List<MessageStream<String>> streams = topicMessageStreams.get("demo");
    //
    ExecutorService executor = Executors.newFixedThreadPool(2);
    final AtomicInteger count = new AtomicInteger();
    for (final MessageStream<String> stream : streams) {
        executor.submit(new Runnable() {

public void run() {
                for (String message : stream) {
                    System.out.println(count.incrementAndGet() + " => " + message);
                }
            }
        });
    }
    //
    executor.awaitTermination(1, TimeUnit.HOURS);
} 

所有消息的消费方式几乎都相同，只是消费的topic名称不同而已。

---

是不是很简单，动手试试吧

https://github.com/adyliu/jafka/wiki/quickstart.zh_CN

http://www.blogjava.net/xylz/archive/2012/05/11/377938.html