业务中需要使用到异步消息队列，为了快速搭建一个消息中间件，这里选了kafka，一方面是kafka搭建比较简单，而且这个中间件比较成熟，而且对于大数据量的消息支持很好，下面首先说说kafka的安装，我这里演示一下在linux上如何搭建kafka，

1、首先安装zookeeper，kafka的启动需要依赖zookeeper，zookeeper安装比较简单，基本上就是上传压缩包，解压，然后启动即可，

然后使用这个命令看看zookeeper是否启动成功：

2、安装kafka，kafka的安装相对于其他中间件的安装是非常简单的，但这里有个版本问题要注意，如果使用的是2.X之前的版本，就算你的配置和我这里说的全部一样可能还是会报出一些奇怪的错误，我之前遇到过，低版本的安装起来需要依赖scala，大家可网上查阅，我这里使用的是2.11的版本，

3、解压完毕，进入config文件，对配置文件稍做修改，主要的修改地方我做了标注，

其中这三个地方的配置要注意，如果是集群的话，在第一个配置的地方需要对应的写上集群中其他节点的id,另外两个配置是外网访问的配置，因为要在项目中使用kafka所以要配置本机的外网IP，

4、配置完毕就可以启动了，首先是kafka的启动，我们进入bin目录，或是上层目录，使用后台启动的方式：

nohup ./bin/kafka-server-start.sh config/server.properties

检查一下进程可以看到kafka启动了，
、
5、怎么使用kafka了，使用起来很简单，我们可以直接再开几个窗口验证一下，首先创建一个topic，基于这个topic我们就可以发消息了，我这里已经创建过了，

./bin/kafka-topics.sh --create --zookeeper 192.168.111.132:2181 --replication-factor 1 --partitions 1 --topic hello

6、然后，通过bin中提供的配置文件，打开一个消息发送者的窗口发送一条消息，

./kafka-console-producer.sh --broker-list localhost:9092 --topic hello

这时候就可以输入消息了，

7、接下来我们打开一个窗口，通过如下命令接收消息，

./kafka-console-consumer.sh --zookeeper 192.168.111.132:2181 --topic hello --from-beginning

可以看到，消息已经接收到了，

注意，上面在启动接收消息的命令时候可能启动失败，主要是会检查本机的IP和当前的用户名是否映射了，这里如果没有配置，可以通过 vi /etc/hosts这个命令配置一下，然后重启一下网络就好了，

为了能够确保外网可以成功访问2181和9092这两个端口，建议在防火墙的配置文件中加入这两个端口号配置， vi /etc/sysconfig/iptables，这里我已经加上了，

接下来就是springboot整合kafka的使用，比较简单，我这里直接贴上相关代码，

pom文件:

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework.kafka/spring-kafka -->
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
			<version>2.1.11.RELEASE</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
		<dependency>
			<groupId>org.apache.kafka</groupId>
			<artifactId>kafka-clients</artifactId>
			<version>1.1.0</version>
		</dependency>
		
		<dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>

application.properties：

server.port=8089

spring.datasource.jdbc-url=jdbc:mysql://localhost:3306/babaytun?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#first.datasource.type=com.alibaba.druid.pool.DruidDataSource 


#============== kafka ===================
# 指定kafka 代理地址，可以多个
spring.kafka.bootstrap-servers=192.168.111.132:9092

#=============== provider  =======================

spring.kafka.producer.retries=0
# 每次批量发送消息的数量
spring.kafka.producer.batch-size=16384
spring.kafka.producer.buffer-memory=33554432

# 指定消息key和消息体的编解码方式
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

#=============== consumer  =======================
# 指定默认消费者group id
spring.kafka.consumer.group-id=test-hello-group

spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.consumer.enable-auto-commit=true
spring.kafka.consumer.auto-commit-interval=100

# 指定消息key和消息体的编解码方式
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

接下来一个是用于消息发送的类，一个是消息监听的类，大家应该比较熟悉消息中间件的使用套路了吧，

package com.congge.kafka;

import java.util.Date;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

@Component
public class KfkaProducer {
	
	private static Logger logger = LoggerFactory.getLogger(KfkaProducer.class);
	
	@Autowired
	private KafkaTemplate<String, String> kafkaTemplate;
	
	private Gson gson = new GsonBuilder().create();
	
	//发送消息方法
    public void send() {
    	for(int i=0;i<5;i++){
    		Message message = new Message();
            message.setId(System.currentTimeMillis());
            message.setMsg(UUID.randomUUID().toString()+ "---" +i);
            message.setSendTime(new Date());
            logger.info("发送消息 ----->>>>>  message = {}", gson.toJson(message));
            kafkaTemplate.send("hello", gson.toJson(message));
    	}
    }

	
}

package com.congge.kafka;

import java.util.Optional;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

@Component
public class KafkaReceiver {
	
	private static Logger logger = LoggerFactory.getLogger(KafkaReceiver.class);
	
	@KafkaListener(topics = {"hello"})
    public void listen(ConsumerRecord<?, ?> record) {
        Optional<?> kafkaMessage = Optional.ofNullable(record.value());
        if (kafkaMessage.isPresent()) {
            Object message = kafkaMessage.get();
            logger.info("----------------- record =" + record);
            logger.info("------------------ message =" + message);
        }

    }

	
}

下面是一个测试controller，模拟请求接口，发送消息，

@Controller
public class KafkaTestController {

	@Autowired
	private KfkaProducer producer;
	
	@RequestMapping("/testSendMsg")
	@ResponseBody
	public String testSendMsg(){
		producer.send();
		return "success";
	}
	
}

然后启动项目，去浏览器请求一下，从控制台可以看到，消息发送成功，监听器也成功收到消息并打印日志，

同时从kafka服务器的consumer的消费端控制台也可以看到成功接收到消息，

基本上到这里，kafka从搭建到和springboot的基本整合使用就完了，有需要的同学可以进行参考，主要是搭建kafka的过程，虽然看起来确实简单，但也还是亲自动手试试更能体会到其使用的妙处，单节点搭建成功了以后搭建集群问题就不大了！感谢观看