JAVA封装消息中间件调用二（kafka消费者篇）
上一遍我简单介绍了kafka的生成者使用，调用方式比较简单，今天我给大家分享下封装kafka消费者,作为中间件，我们做的就是最大程度的解耦，使业务方接入我们依赖程度降到最低。
第一步，我们先配置一个消费者核心类
package com.meiren.message.kafka.consumer; import com.meiren.message.kafka.beans.ConsumerProperty; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; import org.apache.kafka.clients.consumer.KafkaConsumer; import java.util.List; import java.util.Properties; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** * Created by zhangwentao on 2017/5/18. */ public class ConsumerHandler { private final KafkaConsumer<String, String> consumer; private ExecutorService executors; public ConsumerHandler(ConsumerProperty consumerProperty, List<String> topics) { Properties props = new Properties(); props.put("bootstrap.servers", consumerProperty.getBrokerList()); props.put("group.id", consumerProperty.getGroupId()); props.put("enable.auto.commit", consumerProperty.getEnableAutoCommit()); props.put("auto.commit.interval.ms", consumerProperty.getAutoCommitInterval()); props.put("session.timeout.ms", consumerProperty.getSessionTimeout()); props.put("key.deserializer", consumerProperty.getKeySerializer()); props.put("value.deserializer", consumerProperty.getValueSerializer()); consumer = new KafkaConsumer<String, String>(props); consumer.subscribe(topics); } public void execute(int workerNum) { executors = new ThreadPoolExecutor(workerNum, workerNum, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(1000), new ThreadPoolExecutor.CallerRunsPolicy()); Thread t = new Thread(new Runnable(){//启动一个子线程来监听kafka消息 public void run(){ while (true) { ConsumerRecords<String, String> records = consumer.poll(200); for (final ConsumerRecord record : records) { System.out.println("监听到kafka消息。。。。。。"); executors.submit(new ConsumerWorker(record)); } } }}); t.start(); } public void shutdown() { if (consumer != null) { consumer.close(); } if (executors != null) { executors.shutdown(); } try { if (!executors.awaitTermination(10, TimeUnit.SECONDS)) { System.out.println("Timeout.... Ignore for this case"); } } catch (InterruptedException ignored) { System.out.println("Other thread interrupted this shutdown, ignore for this case."); Thread.currentThread().interrupt(); } } }
这个核心类有3个部分组成：1.构造方法（生成一个消费者配置，订阅topic），2.开启多线程监听消费者 3.关闭线程是和消费者
public ConsumerHandler(ConsumerProperty consumerProperty, List<String> topics)
consumerProperty是消费者配置信息类，包含了消费者的配置属性和topic
public class ConsumerProperty { private String brokerList; private String groupId; private String enableAutoCommit="true"; private String autoCommitInterval="1000"; private String sessionTimeout="30000"; private String keySerializer="org.apache.kafka.common.serialization.StringDeserializer"; private String valueSerializer="org.apache.kafka.common.serialization.StringDeserializer"; /** * topic以及消费的实现类 */ private List<MessageContainer> messageContainers;
2.监听消费者信息
public void execute(int workerNum) { } 这段代码的入参是线程数，开启一个线程池ThreadPoolExecutor，建立一个长连接，每200毫秒去kafka服务器拉取消息，每拉到一个消息，就分配给一个线程类ConsumerWorker去处理这个消息
这里要特别注意是，监听kafka的过程需要另起一个线程去监听，不然主线程会一直在while(true)里面阻塞掉。
3.关闭线程池和消费者（一般情况下会一直处于监听状态）
第二步，我们设置服务启动的时候去监听
public class PropertyFactory { public static ProducerProperty producerProperty; public static ConsumerProperty consumerProperty; public ProducerProperty getProducerProperty() { return producerProperty; } public void setProducerProperty(ProducerProperty producerProperty) { this.producerProperty = producerProperty; } public ConsumerProperty getConsumerProperty() { return consumerProperty; } public void setConsumerProperty(ConsumerProperty consumerProperty) { this.consumerProperty = consumerProperty; } ConsumerHandler consumer=null; @PostConstruct public void startListerConsumer(){ consumer= new ConsumerListener(consumerProperty).startListen(); } @PreDestroy public void shutDown(){ if(consumer!=null){ consumer.shutdown(); } } }
这是一个属性工程的bean,当这个bean被创建完成后,会执行startListerConsumer（）方法(@PostConstruct的含义就是在bean被创建之后执行) ，startListerConsumer的作用开启监听
ConsumerHandler consumers = new ConsumerHandler( consumerProperty, topics); consumers.execute(workerNum);
另外，我们看到这个beanFactory有2个属性ProducerProperty 和ConsumerProperty ，这个2个分别是消费者个和生产者的配置，是bean在初始化的时候注入进去的
这里重点介绍一下说ConsumerProperty 的messageContainers属性，它是一个集合对象，包含需要订阅的topic和处理该Topic的实现了MessageListener接口的实现类
public class MessageContainer { private String topic; private MessageListener messageHandle; }
public interface MessageListener { public void onMessage(ConsumerMessageBO message); }
上面说到监听到每个消息都会分配一个ConsumerWorker去处理消息，我们看看具ConsumerWorker的
public class ConsumerWorker implements Runnable { private ConsumerRecord<String, String> consumerRecord; public ConsumerWorker(ConsumerRecord record) { this.consumerRecord = record; } public void run() { ConsumerMessageBO consumerMessageBO= JSONObject.parseObject(consumerRecord.value(),ConsumerMessageBO.class); consumerMessageBO.setOffset(consumerRecord.offset()); consumerMessageBO.setPartition(consumerRecord.partition()); for(MessageContainer messageContainer: PropertyFactory.consumerProperty.getMessageContainers()){ if(consumerRecord.topic().equals(messageContainer.getTopic())){ messageContainer.getMessageHandle().onMessage(consumerMessageBO); } } }
根据监听到topic，然后和ConsumerProperty 的messageContainers属性的topic进行比对，找到对应topic处理的实现类调用其onMessage方法
我们JAVA的核心代码基本已经写完了
第三步、业务方接入我们封装的部分
新建一个spring-kafka.xml文件
<bean id="consumerProperty" class="com.meiren.message.kafka.beans.ConsumerProperty">
<property name="brokerList" value="${kafka.bootstrap.servers}"/>
<property name="groupId" value="${kafka.group.id}"/>
<property name="messageContainers" >
<list>
<ref bean="smsMessageContainer"></ref>
<ref bean="emailMessageContainer"></ref>
</list>
</property>
</bean>
<bean id="producerProperty" class="com.meiren.message.kafka.beans.ProducerProperty">
<property name="brokerList" value="${kafka.bootstrap.servers}"/>
</bean>
<bean id ="emailMessageHandler" class="com.meiren.message.kafka.handle.EmailMessageHandler"/>
<bean id ="smsMessageHandler" class="com.meiren.message.kafka.handle.SmsMessageHandler"/>
<bean id="smsMessageContainer" class="com.meiren.message.kafka.beans.MessageContainer">
<constructor-arg value="sms_async_send"/>
<property name="messageHandle" ref="smsMessageHandler"></property>
</bean>
<bean id ="emailMessageContainer" class="com.meiren.message.kafka.beans.MessageContainer">
<constructor-arg value="email_async_send"/>
<property name="messageHandle" ref="emailMessageHandler"></property>
</bean>
<!--配置工厂类 -->
<bean class="com.meiren.message.kafka.beans.PropertyFactory">
<property name="consumerProperty" ref="consumerProperty"/>
<property name="producerProperty" ref="producerProperty"/>
</bean>
</beans>
这个配置文件对应的就是PropertyFactory的属性，其实就是消费者个和生产者的配置。
我们配置好这个文件后，我们需要一个消息实现类
public class SmsMessageHandler implements MessageListener{ public static final Logger log= LoggerFactory.getLogger(SmsMessageHandler.class); @Autowired private SmsSendLogDao smsSendLogDao; public void onMessage(ConsumerMessageBO consumerMessageBO) { } }catch (Exception e){ System.out.println("转换消息异常:"+e.getMessage()); } }
只要实现了MessageListener接口，并且在spring-kafka.xm配置好对应的topic就可以了
<bean id="smsMessageContainer" class="com.meiren.message.kafka.beans.MessageContainer">
<constructor-arg value="sms_async_send"/>
<property name="messageHandle" ref="smsMessageHandler"></property>
</bean>
整个接入就完成了，由于这是第一版本，所以封装的程度还不算很好，但是也基本符合应用（一个配置文件，一个实现类），有不足之处将会在后面版本进行完善迭代。
至此我们已经将kafka集成spring的功能简单实现了，下一篇我将介绍消息队列（kafka）的一些实际应用。
