Java API方式调用Kafka各种协议的方法

众所周知，kafka自己实现了一套二进制协议(binary protocol)用于各种功能的实现，比如发送消息，获取消息，提交位移以及创建topic等。具体协议规范参见：kafka协议  这套协议的具体使用流程为：

1.客户端创建对应协议的请求

2.客户端发送请求给对应的broker

3.broker处理请求，并发送response给客户端

虽然kafka提供的大量的脚本工具用于各种功能的实现，但很多时候我们还是希望可以把某些功能以编程的方式嵌入到另一个系统中。这时使用java api的方式就显得异常地灵活了。本文我将尝试给出java api底层框架的一个范例，同时也会针对“创建topic”和“查看位移”这两个主要功能给出对应的例子。 需要提前说明的是，本文给出的范例并没有考虑kafka集群开启安全的情况。另外kafka的kip4应该一直在优化命令行工具以及各种管理操作，有兴趣的读者可以关注这个kip。

本文中用到的api依赖于kafka-clients，所以如果你使用maven构建的话，请加上：

<dependency>
  <groupid>org.apache.kafka</groupid>
  <artifactid>kafka-clients</artifactid>
  <version>0.10.2.0</version>
</dependency>

如果是gradle，请加上：

compile group: 'org.apache.kafka', name: 'kafka-clients', version: '0.10.2.0'

底层框架

/**
   * 发送请求主方法
   * @param host     目标broker的主机名
   * @param port     目标broker的端口
   * @param request    请求对象
   * @param apikey    请求类型
   * @return       序列化后的response
   * @throws ioexception
   */
  public bytebuffer send(string host, int port, abstractrequest request, apikeys apikey) throws ioexception {
    socket socket = connect(host, port);
    try {
      return send(request, apikey, socket);
    } finally {
      socket.close();
    }
  }

  /**
   * 发送序列化请求并等待response返回
   * @param socket      连向目标broker的socket
   * @param request      序列化后的请求
   * @return         序列化后的response
   * @throws ioexception
   */
  private byte[] issuerequestandwaitforresponse(socket socket, byte[] request) throws ioexception {
    sendrequest(socket, request);
    return getresponse(socket);
  }

  /**
   * 发送序列化请求给socket
   * @param socket      连向目标broker的socket
   * @param request      序列化后的请求
   * @throws ioexception
   */
  private void sendrequest(socket socket, byte[] request) throws ioexception {
    dataoutputstream dos = new dataoutputstream(socket.getoutputstream());
    dos.writeint(request.length);
    dos.write(request);
    dos.flush();
  }

  /**
   * 从给定socket处获取response
   * @param socket      连向目标broker的socket
   * @return         获取到的序列化后的response
   * @throws ioexception
   */
  private byte[] getresponse(socket socket) throws ioexception {
    datainputstream dis = null;
    try {
      dis = new datainputstream(socket.getinputstream());
      byte[] response = new byte[dis.readint()];
      dis.readfully(response);
      return response;
    } finally {
      if (dis != null) {
        dis.close();
      }
    }
  }

  /**
   * 创建socket连接
   * @param hostname     目标broker主机名
   * @param port       目标broker服务端口, 比如9092
   * @return         创建的socket连接
   * @throws ioexception
   */
  private socket connect(string hostname, int port) throws ioexception {
    return new socket(hostname, port);
  }

  /**
   * 向给定socket发送请求
   * @param request    请求对象
   * @param apikey    请求类型, 即属于哪种请求
   * @param socket    连向目标broker的socket
   * @return       序列化后的response
   * @throws ioexception
   */
  private bytebuffer send(abstractrequest request, apikeys apikey, socket socket) throws ioexception {
    requestheader header = new requestheader(apikey.id, request.version(), "client-id", 0);
    bytebuffer buffer = bytebuffer.allocate(header.sizeof() + request.sizeof());
    header.writeto(buffer);
    request.writeto(buffer);
    byte[] serializedrequest = buffer.array();
    byte[] response = issuerequestandwaitforresponse(socket, serializedrequest);
    bytebuffer responsebuffer = bytebuffer.wrap(response);
    responseheader.parse(responsebuffer);
    return responsebuffer;
  }

有了这些方法的铺垫，我们就可以创建具体的请求了。

创建topic

/**
   * 创建topic
   * 由于只是样例代码，有些东西就硬编码写到程序里面了(比如主机名和端口)，各位看官自行修改即可
   * @param topicname       topic名
   * @param partitions      分区数
   * @param replicationfactor   副本数
   * @throws ioexception
   */
  public void createtopics(string topicname, int partitions, short replicationfactor) throws ioexception {
    map<string, createtopicsrequest.topicdetails> topics = new hashmap<>();
    // 插入多个元素便可同时创建多个topic
    topics.put(topicname, new createtopicsrequest.topicdetails(partitions, replicationfactor));
    int creationtimeoutms = 60000;
    createtopicsrequest request = new createtopicsrequest.builder(topics, creationtimeoutms).build();
    bytebuffer response = send("localhost", 9092, request, apikeys.create_topics);
    createtopicsresponse.parse(response, request.version());
  }

查看位移

/**
   * 获取某个consumer group下的某个topic分区的位移
   * @param groupid      group id
   * @param topic       topic名
   * @param parititon     分区号
   * @throws ioexception
   */
  public void getoffsetforpartition(string groupid, string topic, int parititon) throws ioexception {
    topicpartition tp = new topicpartition(topic, parititon);
    offsetfetchrequest request = new offsetfetchrequest.builder(groupid, singletonlist(tp))
        .setversion((short)2).build();
    bytebuffer response = send("localhost", 9092, request, apikeys.offset_fetch);
    offsetfetchresponse resp = offsetfetchresponse.parse(response, request.version());
    offsetfetchresponse.partitiondata partitiondata = resp.responsedata().get(tp);
    system.out.println(partitiondata.offset);
  }

/**
   * 获取某个consumer group下所有topic分区的位移信息
   * @param groupid      group id
   * @return         (topic分区 --> 分区信息)的map
   * @throws ioexception
   */
  public map<topicpartition, offsetfetchresponse.partitiondata> getalloffsetsforgroup(string groupid) throws ioexception {
    offsetfetchrequest request = new offsetfetchrequest.builder(groupid, null).setversion((short)2).build();
    bytebuffer response = send("localhost", 9092, request, apikeys.offset_fetch);
    offsetfetchresponse resp = offsetfetchresponse.parse(response, request.version());
    return resp.responsedata();
  }

okay, 上面就是“创建topic”和“查看位移”的样例代码，各位看官可以参考着这两个例子构建其他类型的请求。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。