Spring 框架下如何调用kafka

最新推荐文章于 2024-06-02 19:29:15 发布
最新推荐文章于 2024-06-02 19:29:15 发布
阅读量953 收藏
点赞数 1
分类专栏： 立体仓库 PLC 文章标签： spring java 后端 kafka wms
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xdpcxq/article/details/128182638
版权

1、Spring 项目代码结构如下：

2、数据库资源配置文件如下：

#sql配置文件
spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver
#.19為測試地址，.13為正式地址
spring.datasource.url=jdbc:sqlserver://172.12.100.19:1433;DatabaseName=data
spring.datasource.username=wms1234
spring.datasource.password=wms1234
spring.datasource.hikari.connection-timeout=20000
spring.datasource.hikari.connection-test-query=SELECT 1 
#mybatis配置
mybatis.mapper-locations=classpath:mapper/*.xml
#配置映射的实体类
mybatis.type-aliases-package=com.device.search.dao

3、Kafaka实现类源码 

package com.device.search.kafka;

import java.io.File;
import java.io.IOException;
import java.security.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;

import com.aliyun.api.internal.mapping.Converter;
import com.aliyun.api.internal.parser.json.JsonConverter;
import com.device.search.dao.AimerBoxlistDao;
import com.device.search.dao.AimerPackboxDao;
import com.device.search.dao.AimerToWms2BDao;
import com.device.search.model.EdiOutErpData;
import com.device.search.model.PackListData;
import com.device.search.service.AimerBoxlistService;
import com.device.search.service.AimerPackboxService;
import com.device.search.service.AimerToWms2BService;
import com.device.search.utils.TimeUtil;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.google.gson.Gson;
import com.qimen.api.request.DeliveryorderBatchcreateRequest;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.device.search.model.SendData;
public class PackListSendThread implements Runnable {

  private static Logger logger = LoggerFactory.getLogger(PackListSendThread.class);
  private final KafkaProducer<String, String> producer;
  private final String topic;
  public static String packListBack_flag="0";
  private AimerPackboxService aimerPackboxService;
  private AimerBoxlistService aimerBoxlistService;
  private AimerToWms2BService aimerToWms2BService;
  private  final String log_path="d:\\log\\PackListBack\\";
  private  final String err_log="PackListBack_err_";
  private  final String rsp_log="PackListBack_rsp_";
  private  final String req_log="PackListBack_req_";
  public PackListSendThread(String brokers, String topic, AimerPackboxService aimerPackboxService, AimerBoxlistService aimerBoxlistService, AimerToWms2BService aimerToWms2BService)
  {
    Properties prop = createProducerConfig(brokers);
    this.producer = new KafkaProducer<String, String>(prop);
    this.topic = topic;
    this.aimerBoxlistService=aimerBoxlistService;
    this.aimerPackboxService=aimerPackboxService;
    this.aimerToWms2BService=aimerToWms2BService;
  }

  private static Properties createProducerConfig(String brokers) {
    Properties props = new Properties();
    props.put("bootstrap.servers", brokers);
    props.put("acks", "all");
    props.put("retries", 0);
    props.put("batch.size", 16384);
    props.put("linger.ms", 1);
    props.put("buffer.memory", 33554432);
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    return props;
  }

  @Override
  public void run() {
    System.out.println("Produces 3 messages");
    while (true) {
       try {
//         if (packListBack_flag == "0") {
//           continue;
//         }
         synchronized (this) {
           if (packListBack_flag == "0") {
             continue;
           }
         }
         List<AimerPackboxDao> listPackbox = aimerPackboxService.findbyid("N");
         for (int i = 0; i < listPackbox.size(); i++)
         {
           String finalBox_no = listPackbox.get(i).getBoxCode();
           String sotype="SC";
           PackListData packListData = new PackListData();

           packListData.setWarehouseID(listPackbox.get(i).getWhsId());
           packListData.setCARTONID(finalBox_no);
           packListData.setConsigneeid(listPackbox.get(i).getCustom());
           packListData.setWaveno(listPackbox.get(i).getTicno());
           packListData.setGrossweight(listPackbox.get(i).getWeight());
           packListData.setCartontype(listPackbox.get(i).getBoxType());
           packListData.setPackno(listPackbox.get(i).getPackPort());
           packListData.setPackwho(listPackbox.get(i).getOperator());

           packListData.setStarttime(listPackbox.get(i).getCreateDate());
           packListData.setEndtime(listPackbox.get(i).getDoneDate()); //20220428
           //2022.04.08 toC箱单增加运单号和承运商
           packListData.setCarrierid(listPackbox.get(i).getCysname());
           packListData.setDeliverno(listPackbox.get(i).getMailno());

           List<AimerBoxlistDao> listBoxlist = aimerBoxlistService.findbyboxno(finalBox_no);
           long shipqty=0;
           if (listBoxlist.size()<=0)//没有箱明细报错
           {
             logger.error("回传箱明细：没有箱明细数据"+finalBox_no);
             aimerPackboxService.update_boxno_err(finalBox_no,finalBox_no+"回传箱明细：没有箱明细数据");
             continue;
           }
           String ordno=listBoxlist.get(0).getOrdno();
           List<AimerToWms2BDao> listAimerToWms2BDao = aimerToWms2BService.find2bOrdnoUsr02(ordno,"2");
           if (listAimerToWms2BDao.size()<=0)//没有listAimerToWms2BDao
           {
             logger.error("Aimer_to_wms明细：没有出库数据"+finalBox_no);
             aimerPackboxService.update_boxno_err(finalBox_no,finalBox_no+":"+ordno+"Aimer_to_wms明细：没有出库数据");
             continue;
           }

           List<EdiOutErpData> listReturnBoxlist = new ArrayList<EdiOutErpData>();
           for (AimerBoxlistDao aimerBoxlistDao :listBoxlist)
           {
             //20220402  循环查询箱号对应每个单据的操作号,有一个箱号里多个单子。
             List<AimerToWms2BDao> aimerToWms2BDaoList = aimerToWms2BService.find2bOrdnoUsr02(aimerBoxlistDao.getOrdno(),"2");
             if (aimerToWms2BDaoList.size()<=0)//没有listAimerToWms2BDao
             {
               logger.error("Aimer_to_wms明细：没有出库数据11"+finalBox_no);
               aimerPackboxService.update_boxno_err(finalBox_no,finalBox_no+":"+aimerBoxlistDao.getOrdno()+"Aimer_to_wms明细1：没有出库数据");
               continue;
             }
              shipqty = (long) (shipqty +  Double.parseDouble(aimerBoxlistDao.getBoxQty()));
              EdiOutErpData ediOutErpData = new EdiOutErpData();
              ediOutErpData.setSku(aimerBoxlistDao.getBarCode());
              ediOutErpData.setQty(aimerBoxlistDao.getBoxQty());
              ediOutErpData.setSoreference1(aimerToWms2BDaoList.get(0).getUsr02());
              //toC出库箱单明细操作好通过KAFKA回传 --2022.04.08
               if(listAimerToWms2BDao.get(0).getOtype().equals("全渠道O2O") || listAimerToWms2BDao.get(0).getOtype().equals("全渠道o2o")){
                 ediOutErpData.setSoreference1(aimerToWms2BDaoList.get(0).getOrdno());
               }
              ediOutErpData.setNotes(aimerToWms2BDaoList.get(0).getOrdno());
              listReturnBoxlist.add(ediOutErpData);
           }
           if (listAimerToWms2BDao.get(0).getUsr01()!=null)//202203029
           {
             if (listAimerToWms2BDao.get(0).getUsr01().equals("B2BCK"))
             {
               sotype = "SC";
             }
             if (listAimerToWms2BDao.get(0).getUsr01().equals("DBCK"))
             {
               sotype = "SC";
             }
             if (listAimerToWms2BDao.get(0).getUsr01().equals("SQDCK"))
             {
               sotype = "OT";
             }
           }
           //toC出库箱单明细通过KAFKA回传 --2022.04.08
           if(listAimerToWms2BDao.get(0).getOtype().equals("全渠道O2O") || listAimerToWms2BDao.get(0).getOtype().equals("全渠道o2o")){
             sotype = "SO";
           }
           packListData.setSOType(sotype);
           packListData.setShippedQty(shipqty);
           packListData.setItemData(listReturnBoxlist);
           SendData sendData = new SendData();
           sendData.setopr_type("add");
           long time = System.currentTimeMillis();
           sendData.settimestamp(Long.toString(time));
           sendData.setPackListData(packListData);

           String msg = new Gson().toJson(sendData);

           File file=new File(log_path+ TimeUtil.convertDay(new Date()));
           if(!file.exists()){//如果文件夹不存在
             file.mkdirs();//创建文件夹
           }
           String req_filename=log_path+TimeUtil.convertDay(new Date())+"\\"+ req_log+packListData.getCARTONID() +"_" +TimeUtil.convertDate(new Date())+".xml" ;
           TimeUtil.OutJson(msg,req_filename);

           producer.send(new ProducerRecord<String, String>(topic, msg), new Callback()
           {
             public void onCompletion(RecordMetadata metadata, Exception e)
             {
               String resString = new Gson().toJson(metadata);
               if (e != null)
               {
                 String req_filename=log_path+TimeUtil.convertDay(new Date())+"\\"+ err_log+packListData.getCARTONID() +"_" +TimeUtil.convertDate(new Date())+".xml" ;
                 try {
                   TimeUtil.OutJson(resString,req_filename);
                 } catch (IOException ioException) {
                   ioException.printStackTrace();
                 }
                 e.printStackTrace();
               }
               String req_filename=log_path+TimeUtil.convertDay(new Date())+"\\"+ rsp_log+packListData.getCARTONID() +"_" +TimeUtil.convertDate(new Date())+".xml" ;
               try {
                 TimeUtil.OutJson(resString,req_filename);
               } catch (IOException ioException) {
                 ioException.printStackTrace();
               }
               System.out.println("Sent:" + msg + ", Partition: " + metadata.partition() + ", Offset: "
                       + metadata.offset());
               aimerPackboxService.update_boxno(finalBox_no);
             }
           });
         }
         // closes producer
         //producer.close();
         Thread.sleep(3000);
       }catch (Exception ex)
       {
         String req_filename=log_path+TimeUtil.convertDay(new Date())+"\\"+ rsp_log+"eRR_" +TimeUtil.convertDate(new Date())+".xml" ;
         try {
           TimeUtil.OutJson(ex.getMessage(),req_filename);
         } catch (IOException e) {
           e.printStackTrace();
         }
         continue;
       }
    }
  }
}

!chen
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
在java代码中使用kafka(springboot整合kafka)
jerry764的博客
09-06 8559
java代码maven项目实现kafka的连接及生产者、消费者的创建，以及消息的发布和订阅
spring kafka使用
JehuXie的博客
12-07 966
1，pom.xml中添加依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.kafka&lt;/groupId&gt; &lt;artifactId&gt;spring-kafka&lt;/artifactId&gt; &lt;/dependency&gt; &lt;!-- https://mvnreposit...
spring接入kafka
weixin_43139183的博客
10-14 904
spring接入kafka
Spring集成Kafka
ALiangXLogic的博客
06-12 4940
Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。
Springboot整合kafka简单使用
m0_56353506的博客
06-02 2159
Kafka 是一个开源的分布式流处理平台，最初由 LinkedIn 开发并贡献给 Apache 软件基金会。它设计用于构建高性能、持久性、可伸缩和容错的实时数据管道和流处理应用程序。发布-订阅模型：Kafka 使用发布-订阅模型，其中消息生产者将消息发布到主题（topic），而消息消费者从主题订阅消息。这种模型可以支持多个消费者同时消费消息，并且具有良好的扩展性。主题（Topic）：主题是消息的逻辑分类，相当于一个消息队列。消息被发布到主题，并且消费者从主题订阅消息。分区（Partition）
配置
chongxiting3307的博客
11-19 447
#################consumer的配置参数（开始）################# #如果'enable.auto.commit'为true，则消费者偏移自动提交给Kafka的频率（以毫秒为单位），默认值为5000。 spring.kafka.consumer.auto-c...
Spring整合Kafka
qq_51118755的博客
02-04 3704
Apache Kafka发源于LinkedIn，于2011年成为Apache的孵化项目，随后于2012年成为Apache的主要项目之一。-Kafka使用Scala和Java进行编写。Apache Kafka是一个快速、可扩展的、高吞吐、可容错的分布式发布订阅消息系统。Kafka具有高吞吐量、内置分区、支持数据副本和容错的特性，适合在大规模消息处理场景中使用。
如何在spring 集成kafka？
chuandaoxinchang的专栏
03-26 2399
如何使用spring集成kafka？ 因在公司的JAVA Web项目中要使用kafka作为消息队列，加之spring集成了kafka，就希望直接调用spring 集成的，未采用原生态的kafka。 1.pom依赖项 &lt;dependency&gt; &lt;groupId&gt;org.springframework.kafka&lt;/g...
22.Spring Cloud整合RabbitMQ或Kafka消息驱动
06-05
在Spring Cloud框架中，整合RabbitMQ或Kafka作为消息驱动是常见的微服务间通信方式。这两种技术都是流行的消息中间件，用于实现异步处理、解耦和扩展性。下面将详细阐述它们在Spring Cloud中的应用。 首先，...
SpringCloud与Kafka消息中间件集成教程
最新发布
07-13
Spring Cloud 是一个基于Spring Boot的框架，旨在提供一系列开箱即用的工具和服务，帮助开发者轻松构建和部署微服务架构的应用程序。它集合了许多常用的服务组件和技术栈，使开发者能够在构建分布式系统时减少对底层...
spring-kafka源代码
05-02
Spring Kafka是Spring框架的一部分，专为集成Apache Kafka而设计，提供了一套轻量级且强大的API，使得在Java应用中使用Kafka变得更加简单。本文将围绕Spring Kafka的源代码进行深度解析，帮助开发者更好地理解和运用...
Spring 集成 Kafka的配置文件及代码讲解
04-12
在本文中，我们将深入探讨如何将Spring框架与Apache Kafka集成，以便实现在Spring应用中发送和接收消息。Kafka是一个高吞吐量、分布式的发布/订阅消息系统，而Spring框架是Java开发中最广泛使用的应用框架之一。通过...
springboot - 2.7.3版本 - （七）整合Kafka
09-30
在`springboot-kafka`目录下，可能包含了一个示例项目，你可以通过导入IDE进行编译和运行，以了解Spring Boot与Kafka集成的实践操作。 通过以上步骤，你已经掌握了如何在Spring Boot 2.7.3中集成Apache Kafka的基本...
SpringBoot对接kafka,批量、并发、异步获取消息,并动态、批量插入库表
qq_35989920的博客
06-19 4162
因业务发展需要，需要对接kafka，快速批量接收消息日志，避免消息日志累积过多，必须做到数据处理后，动态插入到库表(相同表结构，不同表名)下，并且还要支持批量事务提交,实现消息快速消费。(注意：源码文章最后有获取方式)
spring 中kafka的基本使用
wodebokecsdn的博客
07-25 2926
springboot中使用kafka，批量消费，到业务处理
Windows环境下springboot集成kafka消息队列，生产者消费者，简单应用
greenapple222的博客
12-27 814
springboot中kafka生产者，消费者发送接收消息
Spring-Kafka系列(1)——Kafka集群部署与常用命令
SpringBoy的博客
05-19 1294
一、Kafka集群部署 1.1 部署Zookeeper Kafka依赖zookeeper对Kafka服务器broker进行监控，所以需要先部署zookeeper，部署可见 https://blog.csdn.net/Numb_ZL/article/details/123168037?spm=1001.2014.3001.5502 1.2 Kafka基本参数介绍 参数 含义 broker.id=0 类似于zookeeper的myid log.dirs=/home/kafka/logs 指定
Spring整合kafka
程序三两行
04-17 1916
ssm项目使用kafka 只用spring-kafka依赖就行注入KafkaTemplate模板消息发送监听消息消费测试发送。
spring boot 怎样集成kafka
09-19
### 回答1： Spring Boot 可以使用 Spring for Apache Kafka 库来集成 Kafka。Spring for Apache Kafka 是一个基于 Spring 框架的库，提供了简单的 Java 模板，以及一些可以用来简化开发的工具和抽象层。 ### 回答2： 要在Spring Boot中集成Kafka，需要进行以下步骤： 1. 添加Kafka依赖：在`pom.xml`文件中添加Kafka依赖项。可以使用Spring Boot提供的`spring-kafka`库。可以在Maven仓库中找到适用于Spring Boot的最新版本依赖。 2. 配置Kafka连接：在`application.properties`中添加Kafka连接配置。配置信息包括Kafka服务器的地址和端口号。 3. 创建Kafka生产者：使用`KafkaTemplate`类创建一个Kafka生产者。KafkaTemplate提供了发送消息到Kafka主题的便捷方法。 4. 创建Kafka消费者：使用`@KafkaListener`注解标记一个方法作为Kafka消费者。在方法中，可以通过指定要监听的Kafka主题和消费者组来接收Kafka消息。 5. 发送消息到Kafka：通过调用Kafka生产者的`send()`方法来发送消息到Kafka主题。可以在需要的地方调用该方法来发送消息。 6. 接收Kafka消息：通过Kafka消费者的`@KafkaListener`注解标记的方法来接收Kafka消息。当有新的消息到达时，被标记的方法将被自动调用。 7. 处理Kafka消息：在Kafka消费者的标记方法中，可以根据接收到的消息进行相应的处理。可以将消息保存到数据库、打印到日志文件或进行其他业务逻辑处理。 通过以上步骤，就可以在Spring Boot中成功集成Kafka。在应用程序运行时，可以发送和接收Kafka消息，并根据业务需求进行相应的处理。 ### 回答3： Spring Boot可以通过使用Spring Kafka来集成Kafka。 首先，要在pom.xml文件中添加Spring Kafka的依赖项。可以在dependency部分添加以下代码： ```xml <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> ``` 然后，需要配置Kafka的连接属性。可以在application.properties或application.yml中添加以下配置： ```properties spring.kafka.bootstrap-servers=localhost:9092 ``` 接下来，创建一个KafkaProducer，用于向Kafka发送消息。可以使用@Autowired注解将KafkaTemplate注入到代码中，然后使用send方法发送消息。例如： ```java @Autowired private KafkaTemplate<String, String> kafkaTemplate; public void sendMessage(String topic, String message) { kafkaTemplate.send(topic, message); } ``` 要创建一个KafkaConsumer，用于从Kafka接收消息，可以使用@KafkaListener注解将消费者方法注入到代码中。例如： ```java @KafkaListener(topics = "myTopic") public void receiveMessage(String message) { System.out.println("Received message: " + message); } ``` 最后，可以在启动类上使用@EnableKafka注解启用Kafka支持。例如： ```java @SpringBootApplication @EnableKafka public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 这样，Spring Boot就成功集成了Kafka。可以使用KafkaTemplate发送消息，使用@KafkaListener接收消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

!chen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值