SpringBoot整合kafka到底怎么使用？ （简单案例介绍——存放104协议解析报文信息）

已于 2022-12-17 20:42:24 修改
阅读量1.2k 收藏 3
点赞数
文章标签： kafka spring boot java
于 2022-12-10 12:22:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nsx_truth/article/details/128160350
版权

前言

由于业务要求，我需要将104协议的报文内容解析后传到kafka里，然后程序也是一个SpringBoot项目，所以本篇文章我想说一说我是如何将那些数据传到kafka中并判断其是否消费，至于104协议的报文内容的解析和通信在此不去介绍，涉及到netty的知识。

主要讲生产者怎么发送到kafka，以及用命令来判断消息消费下来了，然后将消费后的数据利用反射机制来将数据保存到mysql中

步骤

1、安装kafka

下载链接

****下载链接****
解压安装包

 tar -zxvf kafka_2.13-3.3.1.tgz -C  /opt/module/

修改解压后的文件名称

mv kafka_2.13-3.3.1/ kafka

修改server.properties 和 zookeeper.properties 配置文件

cd config/

server.properties ：
在这里插入图片描述
在这里插入图片描述
其中zookeeper.connect 的地址名字按需求而定

zookeeper.properties：
在这里插入图片描述

配置环境变量

vim etc/profile

#KAFKA_HOME
export KAFKA_HOME=/opt/module/kafka
export PATH=$PATH:$KAFKA_HOME/bin

刷新一下环境变量

source /etc/profile

然后重点，先启动zookeeper再启动kafka (要在kafka目录下输入命令)

#启动zookeeper服务
bin/zookeeper-server-start.sh -daemon config/zookeeper.properties
#启动kafka服务
bin/kafka-server-start.sh -daemon config/server.properties

2、导入kafka的依赖

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

3、配置yml文件

server:
  port: 8082

# 数据库数据源
spring:
  datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://...:3306/abc
      username: root
      password: root

kafka:
  producer:
    bootstrap-servers: 127.0.0.1:9092
    retries: 3
    acks: all
    max-block-ms: 6000
    batch-size: 4096
    linger-ms: 1000
    buffer-memory: 33554432
    max-request-size: 1048576
    client-id: 自定义名字
    compression-type: gzip
  consumer:
    bootstrap-servers: 127.0.0.1:9092
    enable-auto-commit: true
    auto-commit-interval-ms: 1000
    max-poll-records: 100
    group-id: 自定义名字
    session-timeout-ms: 120000
    request-timeout-ms: 120000
    auto-offset-reset: latest

5、编写生产者配置类

用于启动项目后加载配置文件里的参数建立一个生产者服务

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class KafkaProducerConfiguration {

    @Value("${kafka.producer.bootstrap-servers}")
    private String bootstrapServers;

    @Value("${kafka.producer.retries}")
    private Integer retries;

    @Value("${kafka.producer.acks}")
    private String acks;

    @Value("${kafka.producer.max-block-ms}")
    private Integer maxBlockMs;

    @Value("${kafka.producer.batch-size}")
    private Integer batchSize;

    @Value("${kafka.producer.linger-ms}")
    private Integer lingerMs;

    @Value("${kafka.producer.buffer-memory}")
    private Integer bufferMemory;

    @Value("${kafka.producer.max-request-size}")
    private Integer maxRequestSize;

    @Value("${kafka.producer.client-id}")
    private String clientId;

    @Value("${kafka.producer.compression-type}")
    private String compressionType;

    /**
     * 不包含事务 producerFactory
     * @return
     */
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> props = new HashMap<>();
        //kafka 集群地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        //重试次数
        props.put(ProducerConfig.RETRIES_CONFIG, retries);
        //应答级别
        //acks=0 把消息发送到kafka就认为发送成功
        //acks=1 把消息发送到kafka leader分区，并且写入磁盘就认为发送成功
        //acks=all 把消息发送到kafka leader分区，并且leader分区的副本follower对消息进行了同步就任务发送成功
        props.put(ProducerConfig.ACKS_CONFIG, acks);
        //KafkaProducer.send() 和 partitionsFor() 方法的最长阻塞时间 单位 ms
        props.put(ProducerConfig.MAX_BLOCK_MS_CONFIG, maxBlockMs);
        //批量处理的最大大小 单位 byte
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
        //发送延时,当生产端积累的消息达到batch-size或接收到消息linger.ms后,生产者就会将消息提交给kafka
        props.put(ProducerConfig.LINGER_MS_CONFIG, lingerMs);
        //生产者可用缓冲区的最大值 单位 byte
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
        //每条消息最大的大小
        props.put(ProducerConfig.MAX_REQUEST_SIZE_CONFIG, maxRequestSize);
        //客户端ID
        props.put(ProducerConfig.CLIENT_ID_CONFIG, clientId);
        //Key 序列化方式
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //Value 序列化方式
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //消息压缩：none、lz4、gzip、snappy，默认为 none。
        props.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, compressionType);
        //自定义分区器
//        props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, MyPartitioner.class.getName());
        return new DefaultKafkaProducerFactory<>(props);
    }

    /**
     * 包含事务 producerFactory
     * @return
     */
    public ProducerFactory<String, String> producerFactoryWithTransaction() {
        DefaultKafkaProducerFactory<String, String> defaultKafkaProducerFactory = (DefaultKafkaProducerFactory<String, String>) producerFactory();
        //设置事务Id前缀
        defaultKafkaProducerFactory.setTransactionIdPrefix("tx");
        return defaultKafkaProducerFactory;
    }

    /**
     * 不包含事务 kafkaTemplate
     * @return
     */
    @Bean("kafkaTemplateWithNoTransaction")
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }

    /**
     * 包含事务 kafkaTemplate
     * @return
     */
    @Bean
    public KafkaTemplate<String, String> kafkaTemplateWithTransaction() {
        return new KafkaTemplate<>(producerFactoryWithTransaction());
    }

    /**
     * 以该方式配置事务管理器：就不能以普通方式发送消息，只能通过 kafkaTemplate.executeInTransaction 或
     * 在方法上加 @Transactional 注解来发送消息，否则报错
     * @param producerFactory
     * @return
     */
//    @Bean
//    public KafkaTransactionManager<Integer, String> kafkaTransactionManager(ProducerFactory<Integer, String> producerFactory) {
//        return new KafkaTransactionManager<>(producerFactory);
//    }

}

4、编写生产者

用来编写发送消息的方法和启动项目后初始化创造一个MessageProducer，以便其他地方可以调用它，来发送消息

package com.axinite.iec104.kafka.producer;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.common.errors.TimeoutException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.kafka.core.KafkaOperations;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.kafka.support.SendResult;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

import javax.annotation.PostConstruct;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;


@Service
@Slf4j
public class MessageProducer {

    @Qualifier("kafkaTemplateWithNoTransaction")
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @Qualifier("kafkaTemplateWithTransaction")
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplateWithTransaction;

    public static IotMessageProducer messageProducer;
    public static KafkaTemplate<String, String> staticKafkaTemplate;

    @PostConstruct
    public void init(){

        messageProducer = new IotMessageProducer();
        staticKafkaTemplate = this.kafkaTemplate;
    }

    /**
     * 发送消息（同步）
     * @param topic 主题
     * @param key 键
     * @param message 值
     */
    public void sendMessageSync(String topic, String key, String message) throws InterruptedException, ExecutionException, TimeoutException, java.util.concurrent.TimeoutException {
        //可以指定最长等待时间，也可以不指定
        staticKafkaTemplate.send(topic, message).get(10, TimeUnit.SECONDS);
        log.info("sendMessageSync => topic: {}, key: {}, message: {}", topic, key, message);
    }

    /**
     * 发送消息并获取结果
     * @param topic
     * @param message
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public void sendMessageGetResult(String topic, String key, String message) throws ExecutionException, InterruptedException {
        SendResult<String, String> result = staticKafkaTemplate.send(topic, key, message).get();
        log.info("sendMessageSync => topic: {}, key: {}, message: {}", topic, key, message);
        log.info("The partition the message was sent to: " + result.getRecordMetadata().partition());
    }

    /**
     * 发送消息（异步）
     * @param topic 主题
     * @param message 消息内容
     */
    public void sendMessageAsync(String topic, String message) {
        ListenableFuture<SendResult<String, String>> future = staticKafkaTemplate.send(topic, message);
        //添加回调
        future.addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                log.error("sendMessageAsync failure! topic : {}, message: {}", topic, message);
            }

            @Override
            public void onSuccess(SendResult<String, String> stringStringSendResult) {
                log.info("sendMessageAsync success! topic: {}, message: {}", topic, message);
            }
        });
    }

    /**
     * 可以将消息组装成 Message 对象和 ProducerRecord 对象发送
     * @param topic
     * @param key
     * @param message
     * @throws InterruptedException
     * @throws ExecutionException
     * @throws TimeoutException
     */
    public void testMessageBuilder(String topic, String key, String message) throws InterruptedException, ExecutionException, TimeoutException {
        // 组装消息
        Message msg = MessageBuilder.withPayload(message)
                .setHeader(KafkaHeaders.MESSAGE_KEY, key)
                .setHeader(KafkaHeaders.TOPIC, topic)
                .setHeader(KafkaHeaders.PREFIX,"kafka_")
                .build();
        //同步发送
        staticKafkaTemplate.send(msg).get();
    }

    /**
     * 以事务方式发送消息
     * @param topic
     * @param key
     * @param message
     */
    public void sendMessageInTransaction(String topic, String key, String message) {
        kafkaTemplateWithTransaction.executeInTransaction(new KafkaOperations.OperationsCallback<String, String, Object>() {
            @Override
            public Object doInOperations(KafkaOperations<String, String> kafkaOperations) {
                kafkaOperations.send(topic, key, message);
                //出现异常将会中断事务，消息不会发送出去
                throw new RuntimeException("exception");
            }
        });
    }

}

我这里使用@PostConstruct初始化是为了启动启动类后，先加载并初始化，由于我项目需要做netty的服务端通信，那么启动后会调用客户端的run方法，如下:

@Component
public class Iec104TcpServerSlaveTest implements ApplicationRunner{

	/**
	 * 
	* @Title: test   
	* @Description: 测试 iec104 协议TCP传输方式服务端做从机服务
	* @param @throws Exception 
	* @return void   
	* @throws
	 */

	@Override
	public void run(ApplicationArguments args) throws Exception {
		System.out.println("我启动了没？");
		Iec104Config iec104Config  = new Iec104Config();
		iec104Config.setFrameAmountMax((short) 1);
		iec104Config.setTerminnalAddress((short) 1);
		Iec104SlaveFactory.createTcpServerSlave(2404).setDataHandler(new SysDataHandler()).setConfig(iec104Config).run();
		Thread.sleep(1000000);
	}

}

因为接口实现了ApplicationRunner接口，那么启动类启动后最后会运行这个run方法去启动服务端，运行后它会执行里面的Check104Handler去检查104报文，那么我如何去使用这个MessageProducer将报文解析后的数据传到kafka? 就需要将在Check104Handler引入它，但是我试了使用@Autowired会找不到这个MessageProducer，不知原因是什么，我认为大概是由于这个run方法没执行完毕，注入不了这个MessageProducer，因为服务端一直在跑，这个run方法执行时调用Check104Handler中还没有注入不这个MessageProducer。所以由于不能使用@Autowired，我使用了@PostConstruct提前加载注入到容器并初始化，以下是它的使用：

package com.axinite.iec104.server.handler;

import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.axinite.iec104.analysis.protocol104.Analysis;
import com.axinite.iec104.common.Iec104Constant;
import com.axinite.iec104.enums.EmsEnergyEnum;
import com.axinite.iec104.enums.MobileEnergyEnum;
import com.axinite.iec104.kafka.producer.MessageProducer;
import com.axinite.iec104.util.ByteUtil;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;

import static io.netty.buffer.ByteBufUtil.appendPrettyHexDump;
import static io.netty.util.internal.StringUtil.NEWLINE;

/**
 * 
* @ClassName: Check104Handler  
* @Description: 检查104报文 
 */
@Component
public class Check104Handler extends ChannelInboundHandlerAdapter {
	
	private static final Logger LOGGER = LoggerFactory.getLogger(ChannelInboundHandlerAdapter.class);


	/**
	 * 拦截系统消息
	 */
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		ByteBuf result = (ByteBuf) msg;
//		log(result);
		byte[] bytes = new byte[result.readableBytes()];
		result.readBytes(bytes);
		LOGGER.info("接收到的报文: " + ByteUtil.byteArrayToHexString(bytes));
		String content = ByteUtil.byteArrayToHexString(bytes);
		String aa = Analysis.analysis(content);
		LOGGER.info("------------报文详细信息------------");
		System.out.println(aa);
		MessageProducer.messageProducer.sendMessageGetResult(EmsEnergyConstants.KAFKA_EMS_INFO,"test", aa);
		}

		if (bytes.length < Iec104Constant.APCI_LENGTH || bytes[0] != Iec104Constant.HEAD_DATA) {
			LOGGER.error("报文无效");
			ReferenceCountUtil.release(result);
		} else {
			result.writeBytes(bytes);
			ctx.fireChannelRead(msg);
		}
	}

	public static void log(ByteBuf buffer) {
		int length = buffer.readableBytes();
		int rows = length / 16 + (length % 15 == 0 ? 0 : 1) + 4;
		StringBuilder buf = new StringBuilder(rows * 80 * 2)
				.append("read index:").append(buffer.readerIndex())
				.append(" write index:").append(buffer.writerIndex())
				.append(" capacity:").append(buffer.capacity())
				.append(NEWLINE);
		appendPrettyHexDump(buf, buffer);
		System.out.println(buf.toString());
	}
}

主要代码：

 MessageProducer.messageProducer.sendMessageGetResult("test","test", aa);

5、启动完程序，使用命令去检查数据是否消费下来

注意： 启动程序的前提是，你本地已经先启动了zookeeper，然后再启动了kafka，如下命令（注意它的先后顺序，zookeeper先，kafka后）

在kafka的根目录下输入以下命令

#在kafka的根目录下输入以下命令

#启动zookeeper服务 (先开启zk，再开kafka）
bin/zookeeper-server-start.sh -daemon config/zookeeper.properties

#启动kafka服务
bin/kafka-server-start.sh -daemon config/server.properties

然后启动consumer服务去查看你的topic

#启动consumer服务
bin/kafka-console-consumer.sh --bootstrap-server ip:port --topic test

数据内容我就不放了

6、将消费的数据入库

1、编写消费者配置类

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
import org.springframework.kafka.listener.ConsumerAwareListenerErrorHandler;
import org.springframework.kafka.listener.ListenerExecutionFailedException;
import org.springframework.messaging.Message;

import java.util.HashMap;
import java.util.Map;

@Slf4j
@Configuration
public class KafkaConsumerConfiguration {

    @Value("${kafka.consumer.bootstrap-servers}")
    private String bootstrapServers;

    @Value("${kafka.consumer.enable-auto-commit}")
    private Boolean enableAutoCommit;

    @Value("${kafka.consumer.auto-commit-interval-ms}")
    private Integer autoCommitIntervalMs;

    @Value("${kafka.consumer.max-poll-records}")
    private Integer maxPollRecords;

    @Value("${kafka.consumer.group-id}")
    private String groupId;

    @Value("${kafka.consumer.session-timeout-ms}")
    private Integer sessionTimeoutMs;

    @Value("${kafka.consumer.request-timeout-ms}")
    private Integer requestTimeoutMs;

    @Value("${kafka.consumer.auto-offset-reset}")
    private String autoOffsetReset;

    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        //设置 consumerFactory
        factory.setConsumerFactory(consumerFactory());
        //设置是否开启批量监听
        factory.setBatchListener(false);
        //设置消费者组中的线程数量
        factory.setConcurrency(1);
        return factory;
    }
    /**
     * consumerFactory
     * @return
     */
    public ConsumerFactory<String, Object> consumerFactory() {
        Map<String, Object> props = new HashMap<>();
        //kafka集群地址
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        //自动提交 offset 默认 true
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
        //自动提交的频率 单位 ms
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitIntervalMs);
        //批量消费最大数量
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPollRecords);
        //消费者组
        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        //session超时，超过这个时间consumer没有发送心跳,就会触发rebalance操作
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeoutMs);
        //请求超时
        props.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, requestTimeoutMs);
        //Key 反序列化类
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //Value 反序列化类
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //当kafka中没有初始offset或offset超出范围时将自动重置offset
        //earliest:重置为分区中最小的offset
        //latest:重置为分区中最新的offset(消费分区中新产生的数据)
        //none:只要有一个分区不存在已提交的offset,就抛出异常
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        //设置Consumer拦截器
//        props.put(ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG, MyConsumerInterceptor.class.getName());
        return new DefaultKafkaConsumerFactory<>(props);
    }

    /**
     * 消费异常处理器
     * @return
     */
    @Bean
    public ConsumerAwareListenerErrorHandler consumerAwareListenerErrorHandler() {
        return new ConsumerAwareListenerErrorHandler() {
            @Override
            public Object handleError(Message<?> message, ListenerExecutionFailedException exception, Consumer<?, ?> consumer) {
                //打印消费异常的消息和异常信息
                log.error("consumer failed! message: {}, exceptionMsg: {}, groupId: {}", message, exception.getMessage(), exception.getGroupId());
                return null;
            }
        };
    }
}

2、编写监听主题消费入库的方法

import com.cspg.kafka.domain.constants.EmsEnergyConstants;
import com.cspg.kafka.service.ems.EmsEnergyInfoService;
import com.cspg.kafka.service.ems.EmsEnergyTelemeterStatusService;
import com.cspg.kafka.service.ems.EmsEnergyTelesignStatusService;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class EmsEnergyConsumer {

    @Autowired
    private EmsEnergyInfoService emsEnergyInfoService;

    @Autowired
    private EmsEnergyTelesignStatusService telesignStatusService;

    @Autowired
    private EmsEnergyTelemeterStatusService telemeterStatusService;

    /**
     * 配网自动化系统基本信息
     * @param record
     */
    @KafkaListener(topics = EmsEnergyConstants.KAFKA_EMS_INFO)
    @SneakyThrows
    public void consumerEmsInfo(ConsumerRecord<String, String> record) {
        log.info("kafka消费，配网自动化系统基本信息："+record.topic()+"-"+record.partition()+"-"+record.value());
        emsEnergyInfoService.saveEmsInfo(record.value());
        log.info("配网自动化系统基本信息,消费结束");
    }

    /**
     * 配网自动化系统遥信信息
     * @param record
     */
    @KafkaListener(topics = EmsEnergyConstants.KAFKA_EMS_Telesign_STATUS)
    @SneakyThrows
    public void consumerEmsEnergyTelesignStatus(ConsumerRecord<String, String> record) {
        log.info("kafka消费，配网自动化系统遥信信息："+record.topic()+"-"+record.partition()+"-"+record.value());
        telesignStatusService.saveTelesignStatus(record.value());
        log.info("配网自动化系统遥信信息,消费结束");
    }

    /**
     * 配网自动化系统遥测信息
     * @param record
     */
    @KafkaListener(topics = EmsEnergyConstants.KAFKA_EMS_Telemeter_STATUS)
    @SneakyThrows
    public void consumerEmsEnergyTelemeterStatus(ConsumerRecord<String, String> record) {
        log.info("kafka消费，配网自动化系统遥测信息："+record.topic()+"-"+record.partition()+"-"+record.value());
        telemeterStatusService.saveTelemeterStatus(record.value());
        log.info("配网自动化系统遥测信息,消费结束");
    }
}

其中@KafkaListener(topics = EmsEnergyConstants.KAFKA_EMS_Telemeter_STATUS)是指定topic的名字

3、反射入库

@Repository
public interface EmsEnergyInfoMapper extends BaseMapper<EmsEnergyInfo> {
}

import cn.hutool.core.date.LocalDateTimeUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cspg.kafka.domain.ems.EmsEnergyInfo;
import com.cspg.kafka.mapper.ems.EmsEnergyInfoMapper;
import com.cspg.kafka.service.ems.EmsEnergyInfoService;
import com.cspg.kafka.utils.FieldUtils;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.beanutils.ConvertUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ReflectionUtils;

import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.util.List;


@Service
@Slf4j
@Transactional(rollbackFor = Exception.class)
public class EmsEnergyInfoServiceImpl extends ServiceImpl<EmsEnergyInfoMapper, EmsEnergyInfo>  implements EmsEnergyInfoService {

    @Autowired
    private EmsEnergyInfoService emsEnergyInfoService;

    @Autowired
    private EmsEnergyInfoMapper emsEnergyInfoMapper;

    @SneakyThrows
    @Override
    public void saveEmsInfo(String message){
        EmsEnergyInfo result = new EmsEnergyInfo();
        JSONArray infoArray = JSONArray.parseArray(message);
        for (int i=0; i<infoArray.size(); i++){
            JSONObject info = infoArray.getJSONObject(i);
            String filedName = info.getString("field");
            String filedValue = info.getString("value");
            //下划线转驼峰
            String humpFileName = FieldUtils.lineToHump(filedName);
            //利用反射保存字段值
            Class<EmsEnergyInfo> emsEnergyInfoClass = EmsEnergyInfo.class;
            //获取对应字段
            Field infoField = emsEnergyInfoClass.getDeclaredField(humpFileName);
            ReflectionUtils.makeAccessible(infoField);
            if (filedValue != null && filedValue.length() != 0){
                    ReflectionUtils.setField(infoField, result, ConvertUtils.convert(filedValue, infoField.getType()));
            }
        }
        saveObject(EmsEnergyInfo.class.getName(), result);
    }

    private void saveObject(String tableClassName, Object object) {
        log.info("准备入库，表名：{},对象结构：{}",tableClassName, object.toString());
        tableClassName = tableClassName.substring(tableClassName.lastIndexOf(".") + 1);
        System.out.println(tableClassName == "EmsEnergyInfo");
        if (tableClassName.equals("EmsEnergyInfo")){
            EmsEnergyInfo emsEnergyInfo = (EmsEnergyInfo) object;
            int emsEnergyInfoCount = emsEnergyInfoService.count();
            if(emsEnergyInfoCount == 1) {
                List<EmsEnergyInfo> emsEnergyInfos = emsEnergyInfoMapper.selectList(null);
                QueryWrapper<EmsEnergyInfo> emsEnergyInfoQueryWrapper = new QueryWrapper<>();
                // 基本信息只有一条记录，同时为了避免id不等于，所以需获取数据后读取id
                emsEnergyInfoQueryWrapper.eq("ems_id", emsEnergyInfos.get(0).getEmsId());
                emsEnergyInfoService.update(emsEnergyInfo,emsEnergyInfoQueryWrapper);
            } else {
                emsEnergyInfoService.save(emsEnergyInfo);
            }
        }
    }
}

其中FieldUtils.lineToHump里的写法

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FieldUtils {

    private static Pattern linePattern = Pattern.compile("_(\\w)");


    /** 下划线转驼峰 */
    public static String lineToHump(String str) {
        str = str.toLowerCase();
        Matcher matcher = linePattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
        }
        matcher.appendTail(sb);
        return sb.toString();
    }


    private static Pattern humpPattern = Pattern.compile("[A-Z]");

    /** 驼峰转下划线 */
    public static String humpToLine(String str) {
        Matcher matcher = humpPattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
        }
        matcher.appendTail(sb);
        return sb.toString();
    }
}

7、放些kafka常用的命令

#启动producer服务
bin/kafka-console-producer.sh --bootstrap-server ip:port --topic first

#启动kafka服务
bin/kafka-server-start.sh -daemon config/server.properties

#启动zookeeper服务 (先开启zk，再开kafka）
bin/zookeeper-server-start.sh -daemon config/zookeeper.properties

#停止服务
bin/kafka-server-stop.sh
bin/zookeeper-server-stop.sh 

#启动consumer服务
bin/kafka-console-consumer.sh --bootstrap-server ip:port --topic topic名字

#查看当前有哪些topic
bin/kafka-topics.sh --bootstrap-server ip:port --list

#重头打印所有消费后的数据
bin/kafka-console-consumer.sh --bootstrap-server ip:port --from-beginning --topic topic名字

留言

这篇代码比较多，但是说的很详细，当然还有些类没放全，那些都是自定义的东西，比如实体类、topic的constants类啊… 有些注解可能爆红，因为我使用matis-plus，最后再加上我的pom吧，按情况加啊，有些没必要

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>18.0</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.83</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.2.4</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>com.vaadin.external.google</groupId>
                <artifactId>android-json</artifactId>
                <version>0.0.20131108.vaadin1</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.0</version>
            </dependency>
            <dependency>
                <groupId>org.influxdb</groupId>
                <artifactId>influxdb-java</artifactId>
                <version>2.15</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.83</version>
            </dependency>
            <dependency>
                <groupId>com.auth0</groupId>
                <artifactId>java-jwt</artifactId>
                <version>3.10.3</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-jwt</artifactId>
                <version>1.0.9.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>
            <!--knife4j接口文档 -->
            <dependency>
                <groupId>com.github.xiaoymin</groupId>
                <artifactId>knife4j-spring-boot-starter</artifactId>
                <version>2.0.7</version>
            </dependency>
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.5.8</version>
            </dependency>
        </dependencies>
            <dependency>
      <groupId>commons-codec</groupId>
      <artifactId>commons-codec</artifactId>
      <version>1.15</version>
    </dependency>
    <!-- kafka -->
    <dependency>
      <groupId>org.springframework.kafka</groupId>
      <artifactId>spring-kafka</artifactId>
    </dependency>
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.9.4</version>
    </dependency>
༺鲸落༻
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Doris 数据集成 Kafka
04-26 1160
这是我们Doris 数据集成篇的第二篇，前面我们介绍过通过 Catalog进行集成的例子目前公司的很多数据服务都开始使用Doris 了，目前使用下来感觉还是很方便的，比起Hadoop 那一套少了很多运维的成本，而且整体的效率也不错，现在也要把ELK 那一套日志分析的替换掉，后面日志分析也走Doris。关于如何使用Doris做日志分析，可以参考之前的文章，不过第一步也不是日志分析，而是如何对接Kafka ，因为目前日志数据是在kafka 里的，这里我调研了一下使用Flink 和 Doris 的。
发送至kafka报文重复问题
wzx_hero的博客
12-14 319
kafka消费报错 ，报文类似：[{"v":"251","pid":"dd994","time":"2020/12/14 15:35:00"},{"$ref":"$[0]"}] 原因是生产者生产了同样的两份报文，导致消费时报错。 最后，采用在生产者端处理。
104-java数据结构与算法
weixin_45449911的博客
08-06 145
如图 一.数组 java中数组代表着一块连续的物理存储空间,遍历块,删除慢.其余特性略. 1.稀疏数组 (1)应用场景 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 (2)稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个不同的值 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 (3) 代码 略 略,后续再补充 ...
SpringBoot整合Kafka
IT深耕十余载，大道之简
02-29 545
注意：在实际应用中，你可能还需要考虑更多的配置，如Kafka的分区策略、消息的序列化/反序列化方式、消费者的并发度等。具体的配置和使用方式可以参考Kafka和SpringBoot的官方文档。在这里，“your-topic-name”是你要监听的Kafka主题名称，“your-group-id”是消费者的组ID。请替换“版本号”为当前可用的Kafka版本。
websocket+kafka+springcloud+springboot实现报文（json）传输，解析，推送
Xiao_Cai__的博客
10-31 1834
背景：
IEC104 规约流程详解
QwQfeifei的博客
07-15 3170
1.IEC104作为网络通信的一种约规，由客户端和服务器组成，默认的端口为2404： ...
kafka示例
sin_404的博客
07-16 214
前言：kafka比rabbitmq好用，真香（懒是阻碍学习的第一要素） 一、zookeeper准备（单机配置） 1.下载地址：https://zookeeper.apache.org/releases.html 2. 启动：./zkServer.sh start | ./zkServer.sh start-foreground 后台 关闭 ./skServer.sh stop 3.配置文件：zoo_sample.cfg 看网上教材要改成zoo.cfg，但实测不改也是默认配置文件 4.j...
电网104规约解包(java).rar
01-03
电网104规约解包java代码 项目是围绕电网规约101规约（DL/T634.5101-2002）和104规约（DL/T634.5104-2009），项目基于Java语言。 可以完成规约的内容解析工作和组装工作。可用于实际场景的把发送报文的生成等工作。
java 104规约监听，获取数据，解析数据，电网104规约
化名三爷
12-16 4785
5.监听收到数据后，我重写了一下toString()方法，吧我需要的数据整理了一下，系统自带的同String()方法,会打印所有的详细信息，读者根据自己需要区改动。4.项目基于springboot，如果存在自己没有的包，自行引入或者注释对应代码即可，不会影响实际功能。6.获取监听数据后，我是通过post请求将数据发送到客户端，然后客户端做处理的，读者自行参考，可注释。2.J60870ClientListener.java、监听。1.J60870Client.java、 主站连接。
消息队列——Kafka学习
JSai的博客
12-05 208
点对点消息传递模式 生产者发送一条消息到queue，只有一个消费者能收到。 发布-订阅消息传递模式 发布者发送到topic的消息，只有订阅了topic的订阅者才会收到消息。 Kafka中核心概念 Broker(代理) 是一个物理概念。 一台kafka服务器就可以称之为broker.一个集群由多个broker组成，一个broker可以有多个topic Topic(主题) 是一个逻辑概念。 每一条发送...
Spring Boot实践四 --Redis缓存和Kafka
造梦先森Kai的专栏
07-30 1071
随着时间的积累，应用的使用用户不断增加，数据规模也越来越大，往往数据库查询操作会成为影响用户使用体验的瓶颈，此时使用缓存往往是解决这一问题非常好的手段之一。Spring 3开始提供了强大的基于注解的缓存支持，可以通过注解配置方式低侵入的给原有Spring应用增加缓存功能，提高数据访问性能。
Kafka的Message格式
zjjcchina的博客
06-28 1256
而kafka broker的配置message.max.bytes的默认大小为1000012（Varints编码占3个字节），如果消息格式中与长度有关的字段采用Varints的编码的话， 绝大多数情况下都会节省空间，而v2版本的消息格式也正是这样做的。需要注意的是，Kafka的Record Batch通常具有比较大的体积（默认大小为16KB），因此可以将多个相关的消息打包在一起进行传输和处理，从而提高了消息的传输效率和吞吐量。在退化的情况下，我们可以有一个包含单个record的record batch。
SpringBoot整合kafka及ProtoBuf实现跨平台跨语言的信息交互
10-28
SpringBoot2.x整合Kafka实现消息中间件的发送及消费监听业务，其序列化方式采用ProtoBuf协议实现跨平台、跨语言的数据传输方式。
springboot整合kafka
06-23
springboot整合kafka的一个demo!附带window版本的zookeeper和kafka
SpringBoot 整合Kafka实现消息的发送和接收
08-27
kafka下载、安装、配置及完整运行代码
springboot整合kafka相关讲解
04-14
Kafka目前主要作为一个分布式的发布订阅式的消息系统使用，下面简单介绍一下kafka的基本机制
springboot整合kafka的发布/消费demo项目源码
08-18
使用springboot整合kafka，并进行基于kafka的发布订阅消息队列模式的消息发布与消费测试。
Kafka 3.x.x 入门到精通（04）——对标尚硅谷Kafka教程
最新发布
这里有一只小马吖
04-26 820
Kafka是一个由Scala和Java语言开发的，经典高吞吐量的分布式消息发布和订阅系统，也是大数据技术领域中用作数据交换的核心组件之一。以高吞吐，低延迟，高伸缩，高可靠性，高并发，且社区活跃度高等特性，从而备受广大技术组织的喜爱。
3节点ubuntu24.04服务器docker-compose方式部署高可用elk+kafka日志系统并接入nginx日志
qq_41905051的博客
04-23 969
3节点ubuntu24.04服务器docker-compose方式部署高可用elk+kafka日志系统并接入nginx日志
springboot整合kafka的使用
08-22
在使用SpringBoot整合Kafka的过程中，首先需要添加Kafka的配置。可以通过在application.properties或application.yml文件中添加spring.kafka.listener.ack-mode = manual配置来启用手动确认消息的模式。 接下来，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值