本文借助主流SpringMVC框架向大家介绍如何在具体应用中简单快捷的使用kafka。kafka、maven以及SpringMVC在现在的企业级应用中都占据着非常重要的地位,所以本文将三者结合起来也可以方便大家进一步熟悉基于Maven的SpringMVC框架搭建。
项目展示
国际惯例,首先先向大家展示一下项目最终的运行效果:
当项目正常启动后,在浏览器中输入:http://127.0.0.1:8080/kafkaSpringMVC/welcome 进入欢迎界面:
然后点击Send a Message 进入消息发送页面:
从上面可以看出,发送的消息是当前系统的时间(当然你也可以修改成为自己感冒的消息),点击Submit后将消息发送到kafka集群服务器,然后自动返回到Welcome欢迎界面。在欢迎界面点击Get a Message:
从上述界面中我们可以看见页面中已经获取到了刚才发送的消息,点击RETURN HOME,返回欢迎界面,好啦项目展示就这么简单。
开发环境
操作系统:MacOS 10.12.3(同样适用于Linux系统和Windows系统)
JDK: java version "1.8.0_121"
开发平台:Eclipse Neon.2 Release (4.6.2)
WEB容器:wildfly-8.1.0.Final
zookeeper: zookeeper-3.4.9
kafka: kafka-2.10-0.10.2.0
maven: Eclipse Neon.2 Release(4.6.2)自带maven工具,版本为3.3.9
项目框架
项目框架如下图所示:
项目开发流程
首先搭建Maven Web Project框架,搭建过程可参考我的另一篇随笔maven web框架搭建,大家也可以在网上搜索更多的文章来学习,这里就不在重复描述啦。本项目命名为:kafkaSpringMVC。
框架搭建完成后,下面就需要引入Spring MVC 所需要的jar包和kafka客户端开发需要的jar包。本示例采用的Spring 版本为4.3.6.REALEASE,使用的kafka客户端版本为0.10.2.0。下面通过修改pom.xml文件来引入外部依赖包:
pom.xml
1
2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
3 4.0.0
4 com.unionpay
5 kafkaSpringMVC
6 war
7 0.0.1-SNAPSHOT
8 kafkaSpringMVC Maven Webapp
9 http://maven.apache.org
10
11
12 4.3.6.RELEASE
13
14
15
16
17 junit
18 junit
19 3.8.1
20 test
21
22
23
24 org.springframework
25 spring-core
26 ${springframework}
27
28
29
30 org.springframework
31 spring-context
32 ${springframework}
33
34
35
36 org.springframework
37 spring-tx
38 ${springframework}
39
40
41
42 org.springframework
43 spring-webmvc
44 ${springframework}
45
46
47
48 org.springframework
49 spring-web
50 ${springframework}
51
52
53
54 org.springframework
55 spring-jms
56 ${springframework}
57
58
59
60 org.apache.kafka
61 kafka-clients
62 0.10.2.0
63
64
65
66
67 kafkaSpringMVC
68
69
写完pom.xml文件后,保存。然后右键项目名称,选择Maven->Update Project... 更新项目,引入jar包。
Update Project完成后,可以在maven依赖包里看见刚才引入的本项目需要的jar包:
接下来编写web.xml文件:
web.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2
3 xmlns="http://java.sun.com/xml/ns/javaee"
4 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
5 id="WebApp_ID" version="3.0">
6
7
8 contextConfigLocation
9 classpath:kafka-beans.xml
10
11
12
13 org.springframework.web.context.ContextLoaderListener
14
15
16
17 springDispatcherServlet
18 org.springframework.web.servlet.DispatcherServlet
19
20 contextConfigLocation
21 classpath:spring-mvc-dispatcher.xml
22
23 1
24
25
26
27 springDispatcherServlet
28 /
29
30
31
简单明了,从web.xml描述来看,MVC映射是通过spring-mvc-dispatcher.xml文件说明的,而项目中用到的所有的model 则是通过kafka-beans.xml文件注入的。那么下面分别在resources文件夹下建立这两个xml配置文件:
spring-mvc-dispatcher.xml
就这么简单。由于kafka-beans.xml主要作用是配置注入的beans,所以按照程序,还是先建立好Model才符合逻辑。
在src/main/java路径下分别建立三个package包:com.unionpay.producer、com.unionpay.consumer、com.unionpay.controller。从字面意思很容易理解,producer包主要用于存放生产者,consumer包主要用于存放消费者,controller包主要用于存放逻辑控制类。
完成后在com.unionpay.producer包下建立KafkaProducerDemo.java文件(最好不要命名为Producer或者KafkaProducer,这样会与引入的jar包中原有的类重名):
KafkaProducerDemo.java
1 package com.unionpay.producer;2
3 import java.util.Properties;4
5 import org.apache.kafka.clients.producer.KafkaProducer;6 import org.apache.kafka.clients.producer.ProducerRecord;7
8 public classKafkaProducerDemo {9
10 Properties properties;11
12 publicKafkaProducerDemo(Properties properties) {13 super();14 this.properties =properties;15 }16
17 publicProperties getProperties() {18 returnproperties;19 }20
21 public voidsetProperties(Properties properties) {22 this.properties =properties;23 }24
25 public voidsendMessage(String msg) {26
27 KafkaProducer producer = new KafkaProducer(properties);28
29 ProducerRecord record = new ProducerRecord(properties.getProperty("topic"),30 msg);31 producer.send(record);32
33 producer.close();34
35 }36
37 }
Properties属性主要是为了配置KafkaProducer类,具体信息通过Spring注入,这样可以显得更加高大上和灵活。后面的配置文件中我们可以看得到具体的配置信息。
同样,在com.unionpay.consumer包下面新建类KafkaConsumerDemo.java:
1 package com.unionpay.consumer;2
3 import java.util.Arrays;4 import java.util.Properties;5
6 import org.apache.kafka.clients.consumer.ConsumerRecord;7 import org.apache.kafka.clients.consumer.ConsumerRecords;8 import org.apache.kafka.clients.consumer.KafkaConsumer;9
10 public classKafkaConsumerDemo {11
12 privateProperties props;13
14 publicKafkaConsumerDemo(Properties props) {15 super();16 this.props =props;17 }18
19 publicProperties getProps() {20 returnprops;21 }22
23 public voidsetProps(Properties props) {24 this.props =props;25 }26
27 publicString receive(){28
29 KafkaConsumer consumer = new KafkaConsumer(props);30 consumer.subscribe(Arrays.asList(props.getProperty("topic")));31
32 String msg = "";33 while(true){34 ConsumerRecords consumerRecords = consumer.poll(100);35 for(ConsumerRecordconsumerRecord:consumerRecords){36 msg +=consumerRecord.value();37 }38 consumer.close();39 returnmsg;40 }41 }42
43 }
也是基于同样的原因,KafkaConsumer的配置信息properties也是通过Spring配置文件注入。
当Producer和Consumer编写完成后,就可以编写kafka-beans.xml文件啦:
kafka-beans.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
4 xmlns:mvc="http://www.springframework.org/schema/mvc"
5 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
6 http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsd
7 http://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
8
9
10
11
12
13
14
15
16
17 my-replicated-topic
18 127.0.0.1:9092
19 all
20 org.apache.kafka.common.serialization.StringSerializer21
22 org.apache.kafka.common.serialization.StringSerializer23
24 33554432
25
26
27
28
29
30
31
32
33 my-replicated-topic
34 127.0.0.1:9092
35 group1
36 true
37 1000
38 30000
39 org.apache.kafka.common.serialization.StringDeserializer40
41 org.apache.kafka.common.serialization.StringDeserializer42
43
44
45
46
47
kafka的主要配置一共有三种:broker、producer和consumer,对于客户端来说就是后两种啦。而后两种的配置项从官方文件可以知道,每个都至少有30多种配置内容。通过上面这种注入配置方式的话,在中随便添加配置内容,是不是很灵活呢^_^
下面在com.unionpay.controller包下编写Controller类,控制业务逻辑:
KafkaController.java
package com.unionpay.controller;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;
import com.unionpay.consumer.KafkaConsumerDemo;
import com.unionpay.producer.KafkaProducerDemo;
@Controllerpublic classKafkaController {
@Resource(name= "kafkaProducerDemo")
KafkaProducerDemo producer;
@Resource(name= "kafkaConsumerDemo")
KafkaConsumerDemo consumer;
@RequestMapping(value= "/welcome")publicModelAndView welcome() {
System.out.println("--------welcome--------");
ModelAndView mv= newModelAndView();
mv.setViewName("welcome");returnmv;
}
@RequestMapping(value= "/sendmessage", method =RequestMethod.GET)publicModelAndView sendMessage() {
System.out.println("--------sendmessage--------");
Date date= newDate();
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String now=sdf.format(date);
ModelAndView mv= newModelAndView();
mv.addObject("time", now);
mv.setViewName("kafka_send");returnmv;
}
@RequestMapping(value= "/onsend", method =RequestMethod.POST)public ModelAndView onsend(@RequestParam("message") String msg) {
System.out.println("--------onsend--------");
producer.sendMessage(msg);
ModelAndView mv= newModelAndView();
mv.setViewName("welcome");returnmv;
}
@RequestMapping(value= "/receive")publicModelAndView receive() {
System.out.println("--------receive--------");
String msg=consumer.receive();
ModelAndView mv= newModelAndView();
mv.addObject("msg", msg);
mv.setViewName("kafka_receive");returnmv;
}
}
到目前为止,我们的MVC中已经完成了两个啦(M and C),下面编写最后的三个JSP文件。从解析配置文件(spring-mvc-dispatcher.xml)来看,我们的JSP页面应该建立在/WEB-INF/views/目录下,所以我们首先在/WEB-INF/目录下建立views文件夹。然后在该文件夹下面建立三个jsp文件:
welcome.jsp
1
2 pageEncoding="UTF-8"%>
3
4
5
6
7
welcome8
9
10
Welcome
11
Send a Message
12
Get a Message
13
14
kafka_send.jsp
1
2 pageEncoding="UTF-8"%>
3
4
5
6
7
kafka_send8
9
10
Send a Message
11
12 MessageText:${time}
13
14
15
16
17
RETURN HOME
18
19
20
kafka-receive.jsp
1
2 pageEncoding="UTF-8"%>
3
4
5
6
7
kafka_receive8
9
10
11
Kafka_Reveive!!!
12
Receive Message : ${msg}
13
RETURN HOME
14
15
啊,终于大功告成啦。下面就要品尝我们的劳动果实啦。将项目部署在容器里,然后首先启动zookeeper集群服务器,然后启动kafka集群服务器:
//启动zookeeper集群服务器
cd ~/DevelopEnvironment/zookeeper-3.4.9-kafka/bin
./zkServer.sh start//启动kafka集群服务器
cd ~/DevelopEnvironment/kafka_2.10-0.10.2.0/bin
./kafka-server-start.sh ../config/server.properties
./kafka-server-start.sh ../config/server-1.properties
./kafka-server-start.sh ../config/server-2.properties
然后通过Eclipse启动容器:
从上面终端打印出来的信息可以知道,部署成功啦。下面就要轮回到本文开头啦,在网页地址栏中输入:http://127.0.0.1:8080/kafkaSpringMVC/welcome 进入欢迎界面,然后按照开始描述的操作进行操作,看看能否成功发送和接受消息呢?
怎么样,你成功了吗?反正我是成功了,也希望你也成功啦。如果出现什么错误的话也千万别着急,去根据报错信息找找原因,因为你也马上就要成功啦。
参考文献