dev

evps-comm-server/src/main/java/com/evps/comm/server/kafka/KafkaProducerService.java

@@ -18,129 +18,68 @@ public class KafkaProducerService {
 
     private final KafkaConfig config;
 
-    private final String EVPS_SERVICE_TOPIC = "evps-service";
-    private final String EVPS_ROUTE_TOPIC   = "evps-route";
-    private final String EVPS_NODE_TOPIC    = "evps-node";
-    private final String EVPS_PHASE_TOPIC   = "evps-phase";
-    private final String EVPS_SIGNAL_TOPIC  = "evps-signal";
-    private final String EVPS_EVENT_TOPIC   = "evps-event";
-
-    private KafkaTemplate<String, KafkaEvpsServiceDto> serviceProducer;
-    private KafkaTemplate<String, KafkaEvpsRouteDto> serviceRoute;
-    private KafkaTemplate<String, KafkaEvpsNodeDto> serviceNode;
-    private KafkaTemplate<String, KafkaEvpsPhaseDto> servicePhase;
-    private KafkaTemplate<String, KafkaEvpsSignalDto> serviceSignal;
-    private KafkaTemplate<String, KafkaEvpsEventDto> serviceEvent;
-
+    private KafkaTemplate<String, KafkaEvpsData> uticEvpsProducer;
 
     @PostConstruct
     void init() {
-        this.serviceProducer = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
-        this.serviceRoute = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
-        this.serviceNode = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
-        this.servicePhase = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
-        this.serviceSignal = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
-        this.serviceEvent = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
+        this.uticEvpsProducer = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
 
         log.info("[{}] ------------------", this.getClass().getSimpleName());
-        log.info("[{}]   serviceProducer: {}", this.getClass().getSimpleName(), this.serviceProducer);
-        log.info("[{}]      serviceRoute: {}", this.getClass().getSimpleName(), this.serviceRoute);
-        log.info("[{}]       serviceNode: {}", this.getClass().getSimpleName(), this.serviceNode);
-        log.info("[{}]      servicePhase: {}", this.getClass().getSimpleName(), this.servicePhase);
-        log.info("[{}]     serviceSignal: {}", this.getClass().getSimpleName(), this.serviceSignal);
-        log.info("[{}]      serviceEvent: {}", this.getClass().getSimpleName(), this.serviceEvent);
-    }
-    public void sendEvpsServiceTopic(KafkaEvpsServiceDto data) {
-        if (this.serviceProducer != null) {
-            try {
-                ListenableFuture<SendResult<String, KafkaEvpsServiceDto>> result = this.serviceProducer.send(EVPS_SERVICE_TOPIC, data.getServiceId(), data);
-                log.info("sendEvpsServiceTopic: {}, Key: {}, Data: {}", EVPS_SERVICE_TOPIC, data.getServiceId(), data);
-            }
-            catch (Exception e) {
-                log.error("sendEvpsServiceTopic: {}, {}: {}", EVPS_SERVICE_TOPIC, data.getServiceId(), e.toString());
-            }
-        }
+        log.info("[{}]   serviceProducer: {}", this.getClass().getSimpleName(), this.uticEvpsProducer);
     }
 
-    public void sendEvpsRouteTopic(KafkaEvpsRouteDto data) {
-        if (this.serviceRoute != null) {
+    public void sendEvpsServiceTopic(KafkaEvpsServiceDto data) {
+        if (this.uticEvpsProducer != null) {
             try {
-                ListenableFuture<SendResult<String, KafkaEvpsRouteDto>> result = this.serviceRoute.send(EVPS_ROUTE_TOPIC, data.getServiceId(), data);
-                log.info("sendEvpsRouteTopic: {}, Key: {}, Data: {}", EVPS_ROUTE_TOPIC, data.getServiceId(), data);
+                ListenableFuture<SendResult<String, KafkaEvpsData>> result = this.uticEvpsProducer.send(EvpsKafkaConst.KAFKA_EVPS_TOPIC_NAME, EvpsKafkaConst.KAFKA_EVPS_SERVICE, data);
+                log.info("sendEvpsServiceTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_SERVICE, data.getServiceId(), data);
             }
             catch (Exception e) {
-                log.error("sendEvpsRouteTopic: {}, {}: {}", EVPS_ROUTE_TOPIC, data.getServiceId(), e.toString());
+                log.error("sendEvpsServiceTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_SERVICE, data.getServiceId(), e.toString());
             }
         }
     }
 
     public void sendEvpsNodeTopic(KafkaEvpsNodeDto data) {
-        if (this.serviceNode != null) {
-            try {
-                ListenableFuture<SendResult<String, KafkaEvpsNodeDto>> result = this.serviceNode.send(EVPS_NODE_TOPIC, data.getServiceId(), data);
-                log.info("sendEvpsNodeTopic: {}, Key: {}, Data: {}", EVPS_NODE_TOPIC, data.getServiceId(), data);
-            }
-            catch (Exception e) {
-                log.error("sendEvpsNodeTopic: {}, {}: {}", EVPS_NODE_TOPIC, data.getServiceId(), e.toString());
-            }
-        }
-    }
-
-    public void sendEvpsPhaseTopic(KafkaEvpsPhaseDto data) {
-        if (this.servicePhase != null) {
+        if (this.uticEvpsProducer != null) {
             try {
-                ListenableFuture<SendResult<String, KafkaEvpsPhaseDto>> result = this.servicePhase.send(EVPS_PHASE_TOPIC, data.getServiceId(), data);
-                log.info("sendEvpsPhaseTopic: {}, Key: {}, Data: {}", EVPS_PHASE_TOPIC, data.getServiceId(), data);
+                ListenableFuture<SendResult<String, KafkaEvpsData>> result = this.uticEvpsProducer.send(EvpsKafkaConst.KAFKA_EVPS_TOPIC_NAME, EvpsKafkaConst.KAFKA_EVPS_NODE, data);
+                log.info("sendEvpsNodeTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_NODE, data.getServiceId(), data);
             }
             catch (Exception e) {
-                log.error("sendEvpsPhaseTopic: {}, {}: {}", EVPS_PHASE_TOPIC, data.getServiceId(), e.toString());
+                log.error("sendEvpsNodeTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_NODE, data.getServiceId(), e.toString());
             }
         }
     }
 
     public void sendEvpsSignalTopic(KafkaEvpsSignalDto data) {
-        if (this.serviceSignal != null) {
+        if (this.uticEvpsProducer != null) {
             try {
-                ListenableFuture<SendResult<String, KafkaEvpsSignalDto>> result = this.serviceSignal.send(EVPS_SIGNAL_TOPIC, data.getServiceId(), data);
-                log.info("sendEvpsSignalTopic: {}, Key: {}, Data: {}", EVPS_SIGNAL_TOPIC, data.getServiceId(), data);
+                ListenableFuture<SendResult<String, KafkaEvpsData>> result = this.uticEvpsProducer.send(EvpsKafkaConst.KAFKA_EVPS_TOPIC_NAME, EvpsKafkaConst.KAFKA_EVPS_SIGNAL, data);
+                log.info("sendEvpsSignalTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_SIGNAL, data.getServiceId(), data);
             }
             catch (Exception e) {
-                log.error("sendEvpsSignalTopic: {}, {}: {}", EVPS_SIGNAL_TOPIC, data.getServiceId(), e.toString());
+                log.error("sendEvpsSignalTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_SIGNAL, data.getServiceId(), e.toString());
             }
         }
     }
 
     public void sendEvpsEventTopic(KafkaEvpsEventDto data) {
-        if (this.serviceEvent != null) {
+        if (this.uticEvpsProducer != null) {
             try {
-                ListenableFuture<SendResult<String, KafkaEvpsEventDto>> result = this.serviceEvent.send(EVPS_EVENT_TOPIC, data.getServiceId(), data);
-                log.info("sendEvpsEventTopic: {}, Key: {}, Data: {}", EVPS_EVENT_TOPIC, data.getServiceId(), data);
+                ListenableFuture<SendResult<String, KafkaEvpsData>> result = this.uticEvpsProducer.send(EvpsKafkaConst.KAFKA_EVPS_TOPIC_NAME, EvpsKafkaConst.KAFKA_EVPS_EVENT, data);
+                log.info("sendEvpsEventTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_EVENT, data.getServiceId(), data);
             }
             catch (Exception e) {
-                log.error("sendEvpsEventTopic: {}, {}: {}", EVPS_EVENT_TOPIC, data.getServiceId(), e.toString());
+                log.error("sendEvpsEventTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_EVENT, data.getServiceId(), e.toString());
             }
         }
     }
 
     public void shutdown() {
         try {
-            if (this.serviceProducer != null) {
-                this.serviceProducer.destroy();
-            }
-            if (this.serviceRoute != null) {
-                this.serviceRoute.destroy();
-            }
-            if (this.serviceNode != null) {
-                this.serviceNode.destroy();
-            }
-            if (this.servicePhase != null) {
-                this.servicePhase.destroy();
-            }
-            if (this.serviceSignal != null) {
-                this.serviceSignal.destroy();
-            }
-            if (this.serviceEvent != null) {
-                this.serviceEvent.destroy();
+            if (this.uticEvpsProducer != null) {
+                this.uticEvpsProducer.destroy();
             }
         }
         catch(Exception e) {

evps-comm-server/src/main/java/com/evps/comm/server/kafka/KafkaProducerServiceOld.java

@@ -0,0 +1,107 @@
+package com.evps.comm.server.kafka;
+
+import com.evps.comm.server.config.KafkaConfig;
+import com.evps.common.kafka.dto.*;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.kafka.support.SendResult;
+import org.springframework.util.concurrent.ListenableFuture;
+
+import javax.annotation.PostConstruct;
+
+@Slf4j
+@AllArgsConstructor
+//@Service
+public class KafkaProducerServiceOld {
+
+    private final KafkaConfig config;
+
+    private KafkaTemplate<String, KafkaEvpsServiceDto> serviceProducer;
+    private KafkaTemplate<String, KafkaEvpsNodeDto> serviceNode;
+    private KafkaTemplate<String, KafkaEvpsSignalDto> serviceSignal;
+    private KafkaTemplate<String, KafkaEvpsEventDto> serviceEvent;
+
+
+    @PostConstruct
+    void init() {
+        this.serviceProducer = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
+        this.serviceNode = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
+        this.serviceSignal = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
+        this.serviceEvent = KafkaProducerFactory.createJsonTemplate(this.config.getBootstrapServers(), this.config.props);
+
+        log.info("[{}] ------------------", this.getClass().getSimpleName());
+        log.info("[{}]   serviceProducer: {}", this.getClass().getSimpleName(), this.serviceProducer);
+        log.info("[{}]       serviceNode: {}", this.getClass().getSimpleName(), this.serviceNode);
+        log.info("[{}]     serviceSignal: {}", this.getClass().getSimpleName(), this.serviceSignal);
+        log.info("[{}]      serviceEvent: {}", this.getClass().getSimpleName(), this.serviceEvent);
+    }
+    public void sendEvpsServiceTopic(KafkaEvpsServiceDto data) {
+        if (this.serviceProducer != null) {
+            try {
+                ListenableFuture<SendResult<String, KafkaEvpsServiceDto>> result = this.serviceProducer.send(EvpsKafkaConst.KAFKA_EVPS_SERVICE, data.getServiceId(), data);
+                log.info("sendEvpsServiceTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_SERVICE, data.getServiceId(), data);
+            }
+            catch (Exception e) {
+                log.error("sendEvpsServiceTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_SERVICE, data.getServiceId(), e.toString());
+            }
+        }
+    }
+
+    public void sendEvpsNodeTopic(KafkaEvpsNodeDto data) {
+        if (this.serviceNode != null) {
+            try {
+                ListenableFuture<SendResult<String, KafkaEvpsNodeDto>> result = this.serviceNode.send(EvpsKafkaConst.KAFKA_EVPS_NODE, data.getServiceId(), data);
+                log.info("sendEvpsNodeTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_NODE, data.getServiceId(), data);
+            }
+            catch (Exception e) {
+                log.error("sendEvpsNodeTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_NODE, data.getServiceId(), e.toString());
+            }
+        }
+    }
+
+    public void sendEvpsSignalTopic(KafkaEvpsSignalDto data) {
+        if (this.serviceSignal != null) {
+            try {
+                ListenableFuture<SendResult<String, KafkaEvpsSignalDto>> result = this.serviceSignal.send(EvpsKafkaConst.KAFKA_EVPS_SIGNAL, data.getServiceId(), data);
+                log.info("sendEvpsSignalTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_SIGNAL, data.getServiceId(), data);
+            }
+            catch (Exception e) {
+                log.error("sendEvpsSignalTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_SIGNAL, data.getServiceId(), e.toString());
+            }
+        }
+    }
+
+    public void sendEvpsEventTopic(KafkaEvpsEventDto data) {
+        if (this.serviceEvent != null) {
+            try {
+                ListenableFuture<SendResult<String, KafkaEvpsEventDto>> result = this.serviceEvent.send(EvpsKafkaConst.KAFKA_EVPS_EVENT, data.getServiceId(), data);
+                log.info("sendEvpsEventTopic: {}, Key: {}, Data: {}", EvpsKafkaConst.KAFKA_EVPS_EVENT, data.getServiceId(), data);
+            }
+            catch (Exception e) {
+                log.error("sendEvpsEventTopic: {}, {}: {}", EvpsKafkaConst.KAFKA_EVPS_EVENT, data.getServiceId(), e.toString());
+            }
+        }
+    }
+
+    public void shutdown() {
+        try {
+            if (this.serviceProducer != null) {
+                this.serviceProducer.destroy();
+            }
+            if (this.serviceNode != null) {
+                this.serviceNode.destroy();
+            }
+            if (this.serviceSignal != null) {
+                this.serviceSignal.destroy();
+            }
+            if (this.serviceEvent != null) {
+                this.serviceEvent.destroy();
+            }
+        }
+        catch(Exception e) {
+            log.error("Failed to shutdown: {}", e.getMessage());
+        }
+    }
+
+}

evps-common/src/main/java/com/evps/common/kafka/dto/EvpsKafkaConst.java

@@ -0,0 +1,14 @@
+package com.evps.common.kafka.dto;
+
+public class EvpsKafkaConst {
+
+    private EvpsKafkaConst() {}
+
+    public static final String KAFKA_EVPS_TOPIC_NAME = "utic-evps";
+
+    public static final String KAFKA_EVPS_SERVICE = "evps-service";
+    public static final String KAFKA_EVPS_NODE    = "evps-node";
+    public static final String KAFKA_EVPS_SIGNAL  = "evps-signal";
+    public static final String KAFKA_EVPS_EVENT   = "evps-event";
+
+}

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsData.java

@@ -0,0 +1,7 @@
+package com.evps.common.kafka.dto;
+
+/**
+* 긴급차량 kafka Data
+*/
+public interface KafkaEvpsData {
+}

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsEventDto.java

@@ -12,7 +12,7 @@ import lombok.NoArgsConstructor;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsEventDto {
+public class KafkaEvpsEventDto implements KafkaEvpsData {
 
     public static final int EVPS_EVENT_SERVICE_START = 0;
     public static final int EVPS_EVENT_VEHICLE_MOVE = 1;

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsNetPingDto.java

@@ -12,7 +12,7 @@ import lombok.NoArgsConstructor;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsNetPingDto {
+public class KafkaEvpsNetPingDto implements KafkaEvpsData {
 
     /**
     * 긴급차량 서비스 ID

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsNodeDto.java

@@ -12,7 +12,7 @@ import java.util.List;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsNodeDto {
+public class KafkaEvpsNodeDto implements KafkaEvpsData{
     /**
     * 긴급차량 서비스 ID
     */

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsPhaseDto.java

@@ -12,7 +12,7 @@ import java.util.List;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsPhaseDto {
+public class KafkaEvpsPhaseDto implements KafkaEvpsData{
 
     /**
      * 긴급차량 서비스 ID

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsRouteDto.java

@@ -15,7 +15,7 @@ import java.util.List;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsRouteDto {
+public class KafkaEvpsRouteDto implements KafkaEvpsData {
 
     /**
     * 긴급차량 서비스 ID

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsServiceDto.java

@@ -15,7 +15,7 @@ import java.util.List;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsServiceDto {
+public class KafkaEvpsServiceDto implements KafkaEvpsData {
 
     public static final int SERVICE_START = 1;
 

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsServiceEndDto.java

@@ -12,7 +12,7 @@ import lombok.NoArgsConstructor;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsServiceEndDto {
+public class KafkaEvpsServiceEndDto implements KafkaEvpsData {
 
     /**
     * 긴급차량 서비스 ID

evps-common/src/main/java/com/evps/common/kafka/dto/KafkaEvpsSignalDto.java

@@ -12,7 +12,7 @@ import java.util.List;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-public class KafkaEvpsSignalDto {
+public class KafkaEvpsSignalDto implements KafkaEvpsData {
 
     /**
     * 긴급차량 서비스 ID

evps-consumer/build.gradle

@@ -21,6 +21,8 @@ dependencies {
     implementation 'com.evps:evps-common:0.0.1'
     implementation 'org.springframework.kafka:spring-kafka'
 
+    implementation 'com.fasterxml.jackson.core:jackson-databind'
+
     // lombok 라이브러리 추가 시작
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'

evps-consumer/src/main/java/com/evps/consumer/service/KafkaConsumerService.java

@@ -1,6 +1,7 @@
 package com.evps.consumer.service;
 
-import com.evps.common.kafka.dto.*;
+import com.evps.common.kafka.dto.EvpsKafkaConst;
+import com.evps.common.kafka.dto.KafkaEvpsData;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.kafka.clients.consumer.Consumer;
@@ -16,44 +17,23 @@ import org.springframework.kafka.support.serializer.JsonDeserializer;
 
 import java.util.Collection;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 
 @Slf4j
 @RequiredArgsConstructor
 public class KafkaConsumerService {
 
-    private final String EVPS_SERVICE_TOPIC = "evps-service";
-    private final String EVPS_ROUTE_TOPIC   = "evps-route";
-    private final String EVPS_NODE_TOPIC    = "evps-node";
-    private final String EVPS_PHASE_TOPIC   = "evps-phase";
-    private final String EVPS_SIGNAL_TOPIC  = "evps-signal";
-    private final String EVPS_EVENT_TOPIC   = "evps-event";
-
     private final String bootstrapServers;
     private final String groupId;
 
     private ConcurrentMessageListenerContainer<String, String> kafkaListenerContainer;
 
-    private ConcurrentMessageListenerContainer<String, KafkaEvpsServiceDto> serviceListenerContainer;
-    private ConcurrentMessageListenerContainer<String, KafkaEvpsRouteDto> routeListenerContainer;
-    private ConcurrentMessageListenerContainer<String, KafkaEvpsNodeDto> nodeListenerContainer;
-    private ConcurrentMessageListenerContainer<String, KafkaEvpsPhaseDto> phaseListenerContainer;
-    private ConcurrentMessageListenerContainer<String, KafkaEvpsSignalDto> signalListenerContainer;
-    private ConcurrentMessageListenerContainer<String, KafkaEvpsEventDto> eventListenerContainer;
+    private ConcurrentMessageListenerContainer<String, KafkaEvpsData> uticEvpsListenerContainer;
 
     public void start() {
         log.info("Starting Kafka Consumer: bootstrapServers: {}, group: {}", this.bootstrapServers, this.groupId);
 
-        HashSet<String> topics = new HashSet<>();
-        topics.add(EVPS_SERVICE_TOPIC);
-        topics.add(EVPS_ROUTE_TOPIC);
-        topics.add(EVPS_NODE_TOPIC);
-        topics.add(EVPS_PHASE_TOPIC);
-        topics.add(EVPS_SIGNAL_TOPIC);
-        topics.add(EVPS_EVENT_TOPIC);
-
-        ContainerProperties containerProperties = new ContainerProperties(topics.toArray(new String[0]));
+        ContainerProperties containerProperties = new ContainerProperties(EvpsKafkaConst.KAFKA_EVPS_TOPIC_NAME);
         containerProperties.setGroupId(this.groupId+"Z");
         containerProperties.setPollTimeout(5000);
         //containerProperties.setAckMode(ContainerProperties.AckMode.MANUAL);
@@ -72,115 +52,40 @@ public class KafkaConsumerService {
         });
         ConsumerFactory<String, String> consumerFactory = new DefaultKafkaConsumerFactory<>(getConsumerStringPropertiesMap());
         this.kafkaListenerContainer = new ConcurrentMessageListenerContainer<>(consumerFactory, containerProperties);
-        this.kafkaListenerContainer.setBeanName("consumer");
+        this.kafkaListenerContainer.setBeanName("uticEvpsListenerContainer");
         this.kafkaListenerContainer.setConcurrency(1);
         this.kafkaListenerContainer.setErrorHandler((thrownException, data) -> {
-            log.error("kafkaListenerContainer error: {}", thrownException.getMessage());
+            log.error("uticEvpsListenerContainer error: {}", thrownException.getMessage());
             this.kafkaListenerContainer.stop();
+            this.kafkaListenerContainer.start();
         });
         this.kafkaListenerContainer.start();
 
-
-        ContainerProperties serviceContainerProperties = new ContainerProperties(EVPS_SERVICE_TOPIC);
-        serviceContainerProperties.setGroupId(this.groupId);
-        serviceContainerProperties.setPollTimeout(5000);
-        serviceContainerProperties.setMessageListener(new KafkaEvpsServiceConsumerWorker());
-        serviceContainerProperties.setConsumerRebalanceListener(new ConsumerAwareRebalanceListener() {
-            @Override
-            public void onPartitionsRevokedBeforeCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
-            }
-            @Override
-            public void onPartitionsRevokedAfterCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
-            }
-            @Override
-            public void onPartitionsAssigned(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
-                consumer.seekToEnd(partitions);
-            }
-        });
-        ConsumerFactory<String, KafkaEvpsServiceDto> serviceFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap(), new StringDeserializer(), new JsonDeserializer<>(KafkaEvpsServiceDto.class, false));
-        this.serviceListenerContainer = new ConcurrentMessageListenerContainer<>(serviceFactory, serviceContainerProperties);
-        this.serviceListenerContainer.setBeanName("serviceListenerContainer");
-        this.serviceListenerContainer.setConcurrency(1);
-        this.serviceListenerContainer.setErrorHandler((thrownException, data) -> {
-            log.error("serviceListenerContainer error: {}", thrownException.getMessage());
-            this.serviceListenerContainer.stop();
-        });
-        this.serviceListenerContainer.start();
-
-
-//        ContainerProperties routeContainerProperties = new ContainerProperties(EVPS_ROUTE_TOPIC);
-//        routeContainerProperties.setGroupId(this.groupId);
-//        routeContainerProperties.setPollTimeout(5000);
-//        routeContainerProperties.setMessageListener(new KafkaEvpsRouteConsumerWorker());
-//        ConsumerFactory<String, KafkaEvpsRouteDto> routeFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
-//        this.routeListenerContainer = new ConcurrentMessageListenerContainer<>(routeFactory, routeContainerProperties);
-//        this.routeListenerContainer.setBeanName("routeListenerContainer");
-//        this.routeListenerContainer.setConcurrency(1);
-//        this.routeListenerContainer.setErrorHandler((thrownException, data) -> {
-//            log.error("routeListenerContainer error: {}", thrownException.getMessage());
-//            this.routeListenerContainer.stop();
+//        ContainerProperties containerProperties = new ContainerProperties(EvpsKafkaConst.KAFKA_EVPS_TOPIC_NAME);
+//        containerProperties.setGroupId(this.groupId);
+//        containerProperties.setPollTimeout(5000);
+//        containerProperties.setMessageListener(new KafkaUticEvpsConsumerWorker());
+//        containerProperties.setConsumerRebalanceListener(new ConsumerAwareRebalanceListener() {
+//            @Override
+//            public void onPartitionsRevokedBeforeCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+//            }
+//            @Override
+//            public void onPartitionsRevokedAfterCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+//            }
+//            @Override
+//            public void onPartitionsAssigned(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+//                consumer.seekToEnd(partitions);
+//            }
 //        });
-//        this.routeListenerContainer.start();
-//
-//
-        ContainerProperties nodeContainerProperties = new ContainerProperties(EVPS_NODE_TOPIC);
-        nodeContainerProperties.setGroupId(this.groupId);
-        nodeContainerProperties.setPollTimeout(5000);
-        nodeContainerProperties.setMessageListener(new KafkaEvpsNodeConsumerWorker());
-        ConsumerFactory<String, KafkaEvpsNodeDto> nodeFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
-        this.nodeListenerContainer = new ConcurrentMessageListenerContainer<>(nodeFactory, nodeContainerProperties);
-        this.nodeListenerContainer.setBeanName("nodeListenerContainer");
-        this.nodeListenerContainer.setConcurrency(1);
-        this.nodeListenerContainer.setErrorHandler((thrownException, data) -> {
-            log.error("nodeListenerContainer error: {}", thrownException.getMessage());
-            this.nodeListenerContainer.stop();
-        });
-        this.nodeListenerContainer.start();
-//
-//
-//        ContainerProperties phaseContainerProperties = new ContainerProperties(EVPS_PHASE_TOPIC);
-//        phaseContainerProperties.setGroupId(this.groupId);
-//        phaseContainerProperties.setPollTimeout(5000);
-//        phaseContainerProperties.setMessageListener(new KafkaEvpsPhaseConsumerWorker());
-//        ConsumerFactory<String, KafkaEvpsPhaseDto> phaseFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
-//        this.phaseListenerContainer = new ConcurrentMessageListenerContainer<>(phaseFactory, phaseContainerProperties);
-//        this.phaseListenerContainer.setBeanName("phaseListenerContainer");
-//        this.phaseListenerContainer.setConcurrency(1);
-//        this.phaseListenerContainer.setErrorHandler((thrownException, data) -> {
-//            log.error("phaseListenerContainer error: {}", thrownException.getMessage());
-//            this.phaseListenerContainer.stop();
+//        ConsumerFactory<String, KafkaEvpsData> serviceFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap(), new StringDeserializer(), new JsonDeserializer<>(KafkaEvpsData.class, false));
+//        this.uticEvpsListenerContainer = new ConcurrentMessageListenerContainer<>(serviceFactory, containerProperties);
+//        this.uticEvpsListenerContainer.setBeanName("uticEvpsListenerContainer");
+//        this.uticEvpsListenerContainer.setConcurrency(1);
+//        this.uticEvpsListenerContainer.setErrorHandler((thrownException, data) -> {
+//            log.error("uticEvpsListenerContainer error: {}", thrownException.getMessage());
+//            this.uticEvpsListenerContainer.stop();
 //        });
-//        this.phaseListenerContainer.start();
-//
-//
-        ContainerProperties signalContainerProperties = new ContainerProperties(EVPS_SIGNAL_TOPIC);
-        signalContainerProperties.setGroupId(this.groupId);
-        signalContainerProperties.setPollTimeout(5000);
-        signalContainerProperties.setMessageListener(new KafkaEvpsSignalConsumerWorker());
-        ConsumerFactory<String, KafkaEvpsSignalDto> signalFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
-        this.signalListenerContainer = new ConcurrentMessageListenerContainer<>(signalFactory, signalContainerProperties);
-        this.signalListenerContainer.setBeanName("signalListenerContainer");
-        this.signalListenerContainer.setConcurrency(1);
-        this.signalListenerContainer.setErrorHandler((thrownException, data) -> {
-            log.error("signalListenerContainer error: {}", thrownException.getMessage());
-            this.signalListenerContainer.stop();
-        });
-        this.signalListenerContainer.start();
-
-
-        ContainerProperties eventContainerProperties = new ContainerProperties(EVPS_EVENT_TOPIC);
-        eventContainerProperties.setGroupId(this.groupId);
-        eventContainerProperties.setPollTimeout(5000);
-        eventContainerProperties.setMessageListener(new KafkaEvpsEventConsumerWorker());
-        ConsumerFactory<String, KafkaEvpsEventDto> eventFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
-        this.eventListenerContainer = new ConcurrentMessageListenerContainer<>(eventFactory, eventContainerProperties);
-        this.eventListenerContainer.setBeanName("eventListenerContainer");
-        this.eventListenerContainer.setConcurrency(1);
-        this.eventListenerContainer.setErrorHandler((thrownException, data) -> {
-            log.error("eventListenerContainer error: {}", thrownException.getMessage());
-            this.eventListenerContainer.stop();
-        });
-        this.eventListenerContainer.start();
+//        this.uticEvpsListenerContainer.start();
     }
 
     public Map<String, Object> getConsumerPropertiesMap() {
@@ -220,23 +125,8 @@ public class KafkaConsumerService {
     }
     public void shutdown() {
         try {
-            if (this.serviceListenerContainer != null) {
-                this.serviceListenerContainer.stop();
-            }
-            if (this.routeListenerContainer != null) {
-                this.routeListenerContainer.stop();
-            }
-            if (this.phaseListenerContainer != null) {
-                this.phaseListenerContainer.stop();
-            }
-            if (this.nodeListenerContainer != null) {
-                this.nodeListenerContainer.stop();
-            }
-            if (this.signalListenerContainer != null) {
-                this.signalListenerContainer.stop();
-            }
-            if (this.eventListenerContainer != null) {
-                this.eventListenerContainer.stop();
+            if (this.uticEvpsListenerContainer != null) {
+                this.uticEvpsListenerContainer.stop();
             }
         }
         catch(Exception ignored) {

evps-consumer/src/main/java/com/evps/consumer/service/KafkaConsumerServiceOld.java

@@ -0,0 +1,213 @@
+package com.evps.consumer.service;
+
+import com.evps.common.kafka.dto.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.serialization.StringDeserializer;
+import org.springframework.kafka.core.ConsumerFactory;
+import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
+import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
+import org.springframework.kafka.listener.ConsumerAwareRebalanceListener;
+import org.springframework.kafka.listener.ContainerProperties;
+import org.springframework.kafka.support.serializer.JsonDeserializer;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+@Slf4j
+@RequiredArgsConstructor
+public class KafkaConsumerServiceOld {
+
+    private final String bootstrapServers;
+    private final String groupId;
+
+    private ConcurrentMessageListenerContainer<String, String> kafkaListenerContainer;
+
+    private ConcurrentMessageListenerContainer<String, KafkaEvpsServiceDto> serviceListenerContainer;
+    private ConcurrentMessageListenerContainer<String, KafkaEvpsNodeDto> nodeListenerContainer;
+    private ConcurrentMessageListenerContainer<String, KafkaEvpsSignalDto> signalListenerContainer;
+    private ConcurrentMessageListenerContainer<String, KafkaEvpsEventDto> eventListenerContainer;
+
+    public void start() {
+        log.info("Starting Kafka Consumer: bootstrapServers: {}, group: {}", this.bootstrapServers, this.groupId);
+
+        HashSet<String> topics = new HashSet<>();
+
+        topics.add(EvpsKafkaConst.KAFKA_EVPS_SERVICE);
+        topics.add(EvpsKafkaConst.KAFKA_EVPS_NODE);
+        topics.add(EvpsKafkaConst.KAFKA_EVPS_SIGNAL);
+        topics.add(EvpsKafkaConst.KAFKA_EVPS_EVENT);
+
+        ContainerProperties containerProperties = new ContainerProperties(topics.toArray(new String[0]));
+        containerProperties.setGroupId(this.groupId+"Z");
+        containerProperties.setPollTimeout(5000);
+        //containerProperties.setAckMode(ContainerProperties.AckMode.MANUAL);
+        containerProperties.setMessageListener(new KafkaConsumerWorker());
+        containerProperties.setConsumerRebalanceListener(new ConsumerAwareRebalanceListener() {
+            @Override
+            public void onPartitionsRevokedBeforeCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+            }
+            @Override
+            public void onPartitionsRevokedAfterCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+            }
+            @Override
+            public void onPartitionsAssigned(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+                consumer.seekToEnd(partitions);
+            }
+        });
+        ConsumerFactory<String, String> consumerFactory = new DefaultKafkaConsumerFactory<>(getConsumerStringPropertiesMap());
+        this.kafkaListenerContainer = new ConcurrentMessageListenerContainer<>(consumerFactory, containerProperties);
+        this.kafkaListenerContainer.setBeanName("consumer");
+        this.kafkaListenerContainer.setConcurrency(1);
+        this.kafkaListenerContainer.setErrorHandler((thrownException, data) -> {
+            log.error("kafkaListenerContainer error: {}", thrownException.getMessage());
+            this.kafkaListenerContainer.stop();
+        });
+        this.kafkaListenerContainer.start();
+
+
+        ContainerProperties serviceContainerProperties = new ContainerProperties(EvpsKafkaConst.KAFKA_EVPS_SERVICE);
+        serviceContainerProperties.setGroupId(this.groupId);
+        serviceContainerProperties.setPollTimeout(5000);
+        serviceContainerProperties.setMessageListener(new KafkaEvpsServiceConsumerWorker());
+        serviceContainerProperties.setConsumerRebalanceListener(new ConsumerAwareRebalanceListener() {
+            @Override
+            public void onPartitionsRevokedBeforeCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+            }
+            @Override
+            public void onPartitionsRevokedAfterCommit(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+            }
+            @Override
+            public void onPartitionsAssigned(Consumer<?, ?> consumer, Collection<TopicPartition> partitions) {
+                consumer.seekToEnd(partitions);
+            }
+        });
+        ConsumerFactory<String, KafkaEvpsServiceDto> serviceFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap(), new StringDeserializer(), new JsonDeserializer<>(KafkaEvpsServiceDto.class, false));
+        this.serviceListenerContainer = new ConcurrentMessageListenerContainer<>(serviceFactory, serviceContainerProperties);
+        this.serviceListenerContainer.setBeanName("serviceListenerContainer");
+        this.serviceListenerContainer.setConcurrency(1);
+        this.serviceListenerContainer.setErrorHandler((thrownException, data) -> {
+            log.error("serviceListenerContainer error: {}", thrownException.getMessage());
+            this.serviceListenerContainer.stop();
+        });
+        this.serviceListenerContainer.start();
+
+
+//        ContainerProperties routeContainerProperties = new ContainerProperties(EVPS_ROUTE_TOPIC);
+//        routeContainerProperties.setGroupId(this.groupId);
+//        routeContainerProperties.setPollTimeout(5000);
+//        routeContainerProperties.setMessageListener(new KafkaEvpsRouteConsumerWorker());
+//        ConsumerFactory<String, KafkaEvpsRouteDto> routeFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
+//        this.routeListenerContainer = new ConcurrentMessageListenerContainer<>(routeFactory, routeContainerProperties);
+//        this.routeListenerContainer.setBeanName("routeListenerContainer");
+//        this.routeListenerContainer.setConcurrency(1);
+//        this.routeListenerContainer.setErrorHandler((thrownException, data) -> {
+//            log.error("routeListenerContainer error: {}", thrownException.getMessage());
+//            this.routeListenerContainer.stop();
+//        });
+//        this.routeListenerContainer.start();
+//
+//
+        ContainerProperties nodeContainerProperties = new ContainerProperties(EvpsKafkaConst.KAFKA_EVPS_NODE);
+        nodeContainerProperties.setGroupId(this.groupId);
+        nodeContainerProperties.setPollTimeout(5000);
+        nodeContainerProperties.setMessageListener(new KafkaEvpsNodeConsumerWorker());
+        ConsumerFactory<String, KafkaEvpsNodeDto> nodeFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
+        this.nodeListenerContainer = new ConcurrentMessageListenerContainer<>(nodeFactory, nodeContainerProperties);
+        this.nodeListenerContainer.setBeanName("nodeListenerContainer");
+        this.nodeListenerContainer.setConcurrency(1);
+        this.nodeListenerContainer.setErrorHandler((thrownException, data) -> {
+            log.error("nodeListenerContainer error: {}", thrownException.getMessage());
+            this.nodeListenerContainer.stop();
+        });
+        this.nodeListenerContainer.start();
+
+        ContainerProperties signalContainerProperties = new ContainerProperties(EvpsKafkaConst.KAFKA_EVPS_SIGNAL);
+        signalContainerProperties.setGroupId(this.groupId);
+        signalContainerProperties.setPollTimeout(5000);
+        signalContainerProperties.setMessageListener(new KafkaEvpsSignalConsumerWorker());
+        ConsumerFactory<String, KafkaEvpsSignalDto> signalFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
+        this.signalListenerContainer = new ConcurrentMessageListenerContainer<>(signalFactory, signalContainerProperties);
+        this.signalListenerContainer.setBeanName("signalListenerContainer");
+        this.signalListenerContainer.setConcurrency(1);
+        this.signalListenerContainer.setErrorHandler((thrownException, data) -> {
+            log.error("signalListenerContainer error: {}", thrownException.getMessage());
+            this.signalListenerContainer.stop();
+        });
+        this.signalListenerContainer.start();
+
+
+        ContainerProperties eventContainerProperties = new ContainerProperties(EvpsKafkaConst.KAFKA_EVPS_EVENT);
+        eventContainerProperties.setGroupId(this.groupId);
+        eventContainerProperties.setPollTimeout(5000);
+        eventContainerProperties.setMessageListener(new KafkaEvpsEventConsumerWorker());
+        ConsumerFactory<String, KafkaEvpsEventDto> eventFactory = new DefaultKafkaConsumerFactory<>(getConsumerPropertiesMap());
+        this.eventListenerContainer = new ConcurrentMessageListenerContainer<>(eventFactory, eventContainerProperties);
+        this.eventListenerContainer.setBeanName("eventListenerContainer");
+        this.eventListenerContainer.setConcurrency(1);
+        this.eventListenerContainer.setErrorHandler((thrownException, data) -> {
+            log.error("eventListenerContainer error: {}", thrownException.getMessage());
+            this.eventListenerContainer.stop();
+        });
+        this.eventListenerContainer.start();
+    }
+
+    public Map<String, Object> getConsumerPropertiesMap() {
+        Map<String, Object> properties = new HashMap<>();
+        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, this.bootstrapServers);
+        properties.put(ConsumerConfig.GROUP_ID_CONFIG, this.groupId);
+        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
+        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 1);
+        properties.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "10000");
+        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");
+        properties.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, "100");
+        properties.put(ConsumerConfig.CHECK_CRCS_CONFIG, false);
+        properties.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 1);
+        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
+        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
+        properties.put(JsonDeserializer.TRUSTED_PACKAGES, "*");
+
+        return properties;
+    }
+
+    public Map<String, Object> getConsumerStringPropertiesMap() {
+        Map<String, Object> properties = new HashMap<>();
+        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, this.bootstrapServers);
+        properties.put(ConsumerConfig.GROUP_ID_CONFIG, this.groupId);
+        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
+        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 1);
+        properties.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "10000");
+        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");
+        properties.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, "100");
+        properties.put(ConsumerConfig.CHECK_CRCS_CONFIG, false);
+        properties.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 1);
+        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
+        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
+        properties.put(JsonDeserializer.TRUSTED_PACKAGES, "*");
+
+        return properties;
+    }
+    public void shutdown() {
+        try {
+            if (this.serviceListenerContainer != null) {
+                this.serviceListenerContainer.stop();
+            }
+            if (this.nodeListenerContainer != null) {
+                this.nodeListenerContainer.stop();
+            }
+            if (this.signalListenerContainer != null) {
+                this.signalListenerContainer.stop();
+            }
+            if (this.eventListenerContainer != null) {
+                this.eventListenerContainer.stop();
+            }
+        }
+        catch(Exception ignored) {
+        }
+    }
+}

evps-consumer/src/main/java/com/evps/consumer/service/KafkaEvpsPhaseConsumerWorker.java

@@ -1,18 +0,0 @@
-package com.evps.consumer.service;
-
-import com.evps.common.kafka.dto.KafkaEvpsPhaseDto;
-import lombok.AllArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.springframework.kafka.listener.MessageListener;
-
-@Slf4j
-@AllArgsConstructor
-public class KafkaEvpsPhaseConsumerWorker implements MessageListener<String, KafkaEvpsPhaseDto> {
-
-    @Override
-    public void onMessage(ConsumerRecord<String, KafkaEvpsPhaseDto> record) {
-        log.info("EvpsPhase: Key: {}, Data: {}", record.key(), record.value());
-    }
-
-}

evps-consumer/src/main/java/com/evps/consumer/service/KafkaEvpsRouteConsumerWorker.java

@@ -1,18 +0,0 @@
-package com.evps.consumer.service;
-
-import com.evps.common.kafka.dto.KafkaEvpsRouteDto;
-import lombok.AllArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.springframework.kafka.listener.MessageListener;
-
-@Slf4j
-@AllArgsConstructor
-public class KafkaEvpsRouteConsumerWorker implements MessageListener<String, KafkaEvpsRouteDto> {
-
-    @Override
-    public void onMessage(ConsumerRecord<String, KafkaEvpsRouteDto> record) {
-        log.info("EvpsRoute: Key: {}, Data: {}", record.key(), record.value());
-    }
-
-}

evps-consumer/src/main/java/com/evps/consumer/service/KafkaUticEvpsConsumerWorker.java

@@ -0,0 +1,45 @@
+package com.evps.consumer.service;
+
+import com.evps.common.kafka.dto.*;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.springframework.kafka.listener.MessageListener;
+
+@Slf4j
+@AllArgsConstructor
+public class KafkaUticEvpsConsumerWorker implements MessageListener<String, String> {
+
+    private static ObjectMapper mapper = new ObjectMapper();
+
+    @Override
+    public void onMessage(ConsumerRecord<String, String> record) {
+
+        try {
+            if (EvpsKafkaConst.KAFKA_EVPS_EVENT.equals(record.key())) {
+                KafkaEvpsEventDto data = mapper.readValue(record.value(), KafkaEvpsEventDto.class);
+                log.info("EvpsEvent: {}", data);
+            }
+            else if (EvpsKafkaConst.KAFKA_EVPS_SIGNAL.equals(record.key())) {
+                KafkaEvpsSignalDto data = mapper.readValue(record.value(), KafkaEvpsSignalDto.class);
+                log.info("EvpsSignal: {}", data);
+            }
+            else if (EvpsKafkaConst.KAFKA_EVPS_NODE.equals(record.key())) {
+                KafkaEvpsNodeDto data = mapper.readValue(record.value(), KafkaEvpsNodeDto.class);
+                log.info("EvpsNode: {}", data);
+            }
+            else if (EvpsKafkaConst.KAFKA_EVPS_SERVICE.equals(record.key())) {
+                KafkaEvpsServiceDto data = mapper.readValue(record.value(), KafkaEvpsServiceDto.class);
+                log.info("EvpsService: {}", data);
+            }
+            else {
+                log.error("Unknown Utic Evps Kafka Key: {}, {}", record.key(), record.value());
+            }
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}