Kafka

安装kafka

mkdir kafka
cd kafka/
上传kafka到Linux
tar -zxvf kafka_2.12-2.1.0.tgz
mv kafka_2.12-2.1.0 kafka
cd kafka/
cd config/

• vim server.properties

  broker.id=0
  port=9092
  host.name=192.168.174.128
  advertised.host.name=192.168.174.128
  log.dirs=/usr/local/kafka_2.12/kafka-logs
  num.partitions=2

启动kafka

cd …/bin/
./kafka-server-start.sh …/config/server.properties &

启动kafka之前要先启动zookeeper

kafka常用命令

查看topic列表命令：
./kafka-topics.sh --zookeeper 192.168.174.128:2181 --list

创建topic主题命令：（创建名为test的topic， 2个分区分别存放数据，数据备份总共1份）
./kafka-topics.sh --zookeeper 192.168.174.128:2181 --create --topic test --partitions 2 --replication-factor 1
–zookeeper 为zk服务列表
–create 命令后
–topic 为创建topic 并指定 topic name
–partitions 为指定分区数量
–replication-factor 为指定副本集数量

查看某个group（消费者指定的group）下消息消费进度
当消费者启动的时候，消费者指定的group会注册到zookeeper上，可以通过以下命令查看该group的消息消费进度：
./kafka-consumer-groups.sh --bootstrap-server 192.168.174.128:9092 --describe --group testGroup

LAG就是表示待消费的消息堆积

SpringBoot整合kafka

生产者消费者都需要添加依赖

		<dependency>
		    <groupId>org.springframework.kafka</groupId>
		    <artifactId>spring-kafka</artifactId>
		</dependency>

消费者

application.properties

server.servlet.context-path=/consumser
server.port=8002

spring.kafka.bootstrap-servers=192.168.174.128:9092

## consumer 消息的签收机制：手工签收
spring.kafka.consumer.enable-auto-commit=false
spring.kafka.listener.ack-mode=manual
# 该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理：
# latest（默认值）在偏移量无效的情况下，消费者将从最新的记录开始读取数据（在消费者启动之后生成的记录）
# earliest ：在偏移量无效的情况下，消费者将从起始位置读取分区的记录
spring.kafka.consumer.auto-offset-reset=earliest
## 序列化配置
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
#并行度
spring.kafka.listener.concurrency=5

KafkaConsumerService

import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.stereotype.Component;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component
public class KafkaConsumerService {

	@KafkaListener(groupId = "testGroup", topics = "test")
	public void onMessage(ConsumerRecord<String, Object> record, Acknowledgment acknowledgment, Consumer<?, ?> consumer) {
		log.info("消费端接收消息: {}", record.value());
		//	收工签收机制
		acknowledgment.acknowledge();
	}

}

生产者

application.properties

server.servlet.context-path=/producer
server.port=8001

## Spring 整合 kafka
spring.kafka.bootstrap-servers=192.168.174.128:9092
## kafka producer 发送消息失败时的一个重试的次数
spring.kafka.producer.retries=0
## 批量发送数据的配置 
spring.kafka.producer.batch-size=16384
## 设置kafka 生产者内存缓存区的大小（32M）
spring.kafka.producer.buffer-memory=33554432
## kafka消息的序列化配置
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

# acks=0 ： 生产者在成功写入消息之前不会等待任何来自服务器的响应。
# acks=1 ： 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应。
# acks=-1: 表示分区leader必须等待消息被成功写入到所有的ISR副本(同步副本)中才认为producer请求成功。这种方案提供最高的消息持久性保证，但是理论上吞吐率也是最差的。

## 	这个是kafka生产端最重要的选项
spring.kafka.producer.acks=1

KafkaProducerService

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

import lombok.extern.slf4j.Slf4j;

/**
 * 	$KafkaProducerService
 * @author Alienware
 *
 */
@Slf4j
@Component
public class KafkaProducerService {

	@Autowired
	private KafkaTemplate<String, Object> kafkaTemplate;
	
	public void sendMessage(String topic, Object object) {
		
		ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send(topic, object);
		
		future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
			@Override
			public void onSuccess(SendResult<String, Object> result) {
				log.info("发送消息成功: " + result.toString());
			}

			@Override
			public void onFailure(Throwable throwable) {
				log.error("发送消息失败: " + throwable.getMessage());
			}
		});
		
	}

}

测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {

	@Autowired
	private KafkaProducerService kafkaProducerService;
	
	@Test
	public void send() {
		String topic = "test";
		for(int i=0; i < 10; i ++) {
			kafkaProducerService.sendMessage(topic, "hello kafka" + i);
		}
		
	}	
	
}

生产者日志输出

消费者日志输出