kafka初涉（docker安装以及Spring boot简单应用）

docker安装

这里推荐使用docker-compose安装

以下是docker-compose.yml

version: '3'
services:
  zookeeper:
    image: wurstmeister/zookeeper
    ports:
      - "2181:2181"
  kafka:
    image: wurstmeister/kafka
    depends_on: 
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      ALLOW_PLAINTEXT_LISTENER: "yes"
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092
      KAFKA_ADVERTISED_HOST_NAME: 172.31.245.238
      KAFKA_CREATE_TOPICS: "test:1:1"
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
    volumes:
      - ./kafka-log:/kafka

• ALLOW_PLAINTEXT_LISTENER 允许使用PLAINTEXT侦听器。
• depends_on: -zookeeper:kafka依赖于zookeeper
• KAFKA_ADVERTISED_LISTENERS 是指向Kafka代理的可用地址列表。 Kafka将在初次连接时将它们发送给客户。格式为 PLAINTEXT://host:port ，此处已将容器9092端口映射到宿主机9092端口，0.0.0.0为监听所有地址（未验证）
• KAFKA_ADVERTISED_HOST_NAME: 172.31.245.238 ：映射宿主机地址
• KAFKA_CREATE_TOPICS: "test:1:1" 预创建主题test, 分区数，分区副本数
• KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181 映射zookeeper

步骤

（1）创建以上yaml文件

（2）在该文件目录下，执行

docker-compose build
docker-compose up -d

SpringBoot简单应用实例

依赖：

    org.springframework.kafka
    spring-kafka

配置

###########【Kafka集群】###########
spring.kafka.bootstrap-servers=PLAINTEXT://172.31.245.238:9092
###########【初始化生产者配置】###########
# 重试次数
spring.kafka.producer.retries=0
# 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
spring.kafka.producer.acks=1
# 批量大小
spring.kafka.producer.batch-size=16384
# 提交延时
spring.kafka.producer.properties.linger.ms=0
# 当生产端积累的消息达到batch-size或接收到消息linger.ms后,生产者就会将消息提交给kafka
# linger.ms为0表示每接收到一条消息就提交给kafka,这时候batch-size其实就没用了

# 生产端缓冲区大小
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
# 自定义分区器
# spring.kafka.producer.properties.partitioner.class=com.felix.kafka.producer.CustomizePartitioner
?
###########【初始化消费者配置】###########
# 默认的消费组ID
spring.kafka.consumer.properties.group.id=defaultConsumerGroup
# 是否自动提交offset
spring.kafka.consumer.enable-auto-commit=true
# 提交offset延时(接收到消息后多久提交offset)
spring.kafka.consumer.auto.commit.interval.ms=1000
# 当kafka中没有初始offset或offset超出范围时将自动重置offset
# earliest:重置为分区中最小的offset;
# latest:重置为分区中最新的offset(消费分区中新产生的数据);
# none:只要有一个分区不存在已提交的offset,就抛出异常;
spring.kafka.consumer.auto-offset-reset=latest
# 消费会话超时时间(超过这个时间consumer没有发送心跳,就会触发rebalance操作)
spring.kafka.consumer.properties.session.timeout.ms=120000
# 消费请求超时时间
spring.kafka.consumer.properties.request.timeout.ms=180000
# Kafka提供的序列化和反序列化类
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
# 消费端监听的topic不存在时，项目启动会报错(关掉)
spring.kafka.listener.missing-topics-fatal=false
# 设置批量消费
# spring.kafka.listener.type=batch
# 批量消费每次最多消费多少条消息
# spring.kafka.consumer.max-poll-records=50

spring.kafka.bootstrap-servers=PLAINTEXT://172.31.245.238:9092，其中172.31.245.238为docker-compose的KAFKA_ADVERTISED_HOST_NAME参数。

生产者：

@RestController
@Slf4j
public class KafkaProducer {

    @Autowired
    private KafkaTemplate kafkaTemplate;

    // 直接发送字符串
    @GetMapping("/kafka/normal/{message}")
    public void sendMessage1(@PathVariable("message") String normalMessage) {
        kafkaTemplate.send("test", normalMessage);
    }

   // 将对象转化为json字符串再发送
    @GetMapping("/kafka/sendTopic2")
    public void sendMessage2() {
        User user = User.builder()
                .name("yuanwei")
                .password("1234")
                .age(12)
                .build();
        try{
            String message= JacksonUtil.objToJson(user);
            kafkaTemplate.send("test", message);
        }catch (Exception e){
            log.error(e.toString());
        }
    }
}

消费者：

@Component
@Slf4j
public class KafkaConsumer {
    // 消费监听
    @KafkaListener(topics = {"test"})
    public void onMessage1(ConsumerRecord record){
        // 消费的哪个topic、partition的消息,打印出消息内容
        System.out.println("简单消费："+record.topic()+"-"+record.partition()+"-"+record.value());
    }

    // 将消费到的json字符串转化为对象。
    @KafkaListener(topics = {"test"})
    public void onMessage2(ConsumerRecord record){
        // 消费的哪个topic、partition的消息,打印出消息内容
        System.out.println("对象1消费："+record.topic()+"-"+record.partition()+"-"+record.value());
        try{
            User user = (User)JacksonUtil.jsonToObj(new User(),(String)record.value());
            System.out.println("对象1消费："+record.topic()+"-"+record.partition()+"-"+user);
        }catch (Exception e){
            log.error(e.toString());
        }
    }
}

json转换工具类

public class JacksonUtil {
    /*
     * 001.json转换成对象
     * @param:传入对象，json字符串
     * @return:Object
     */
    public static Object jsonToObj(Object obj,String jsonStr) throws JsonParseException, JsonMappingException, IOException {
        ObjectMapper mapper = new ObjectMapper();
        return obj = mapper.readValue(jsonStr, obj.getClass());
    }
    /*
     * 002.对象转换成json
     * @param:传入对象
     * @return:json字符串
     */
    public static String objToJson(Object obj) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(obj);
    }
}

User对象

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String name;

    private String password;

    private Integer age;
}