Commit @455962efec460ce8eabbaec87c550444f61dcd49

dsjang 2024-08-12

발송 성능 개선, 리포트 수신 관련 기능 개선

@455962efec460ce8eabbaec87c550444f61dcd49

aa4fc21

455962e

src/main/java/com/munjaon/server/config/RunnerConfiguration.java

--- src/main/java/com/munjaon/server/config/RunnerConfiguration.java

+++ src/main/java/com/munjaon/server/config/RunnerConfiguration.java


 import com.munjaon.server.util.ServiceUtil;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.configuration2.ex.ConfigurationException;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;

         System.setProperty("PROPS", serverConfig.getServerProperyFile());
         System.setProperty("ROOTPATH", serverConfig.getServerRootPath());
         PropertyLoader.load();
+
+        /* Serial queue 초기화 */
+        SerialQueuePool queueInstance = SerialQueuePool.getInstance();
         try {
-            String[] array = serverConfig.getStringArray("test.list");
-            if (array != null && array.length > 0) {
-                for (String s : array) {
-                    System.out.println("List : " + s);
-                }
-            }
-        } catch (ConfigurationException e) {
-            throw new RuntimeException(e);
+            SerialQueue serialQueue = new SerialQueue();
+            queueInstance.setSerialQueue(serialQueue);
+        } catch (Exception e) {
+            e.printStackTrace();
         }
+
         return args -> System.out.println("Runner Bean #1 : " + serverConfig.getServerProperyFile());
     }
 

             String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
             int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
 //            CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
-            CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
-            collectServerService.start();
+            CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
+            collectServer.start();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

             String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
             int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
 //            CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
-            CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
-            collectServerService.start();
+            CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
+            collectServer.start();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

             String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
             int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
 //            CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
-            CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
-            collectServerService.start();
+            CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
+            collectServer.start();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

             String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
             int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
 //            CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
-            CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
-            collectServerService.start();
+            CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
+            collectServer.start();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

             String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
             int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
 //            CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
-            CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
-            collectServerService.start();
+            CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
+            collectServer.start();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/enums/QueueTypeWorker.java

--- src/main/java/com/munjaon/server/queue/enums/QueueTypeWorker.java

+++ src/main/java/com/munjaon/server/queue/enums/QueueTypeWorker.java


 import lombok.Getter;
 
 import java.util.EnumSet;
+import java.util.List;
 
 @Getter
 public enum QueueTypeWorker {

         public int saveMessageToTable(BasicMessageDto data) {
             SmsQueueService smsQueueService = (SmsQueueService) QueueService.SMS_QUEUE_SERVICE.getService();
             return smsQueueService.saveMessageToTable(data);
+        }
+
+        @Override
+        public int saveMessageForList(List<BasicMessageDto> list) {
+            SmsQueueService smsQueueService = (SmsQueueService) QueueService.SMS_QUEUE_SERVICE.getService();
+            return smsQueueService.saveMessageForList(list);
         }
 
         @Override

         }
 
         @Override
+        public int saveMessageForList(List<BasicMessageDto> list) {
+            LmsQueueService lmsQueueService = (LmsQueueService) QueueService.LMS_QUEUE_SERVICE.getService();
+            return lmsQueueService.saveMessageForList(list);
+        }
+
+        @Override
         public void memoryEnQueue(BasicMessageDto data) {
             LmsQueueService lmsQueueService = (LmsQueueService) QueueService.LMS_QUEUE_SERVICE.getService();
             lmsQueueService.memoryEnQueue(data);

         public int saveMessageToTable(BasicMessageDto data) {
             MmsQueueService mmsQueueService = (MmsQueueService) QueueService.MMS_QUEUE_SERVICE.getService();
             return mmsQueueService.saveMessageToTable(data);
+        }
+
+        @Override
+        public int saveMessageForList(List<BasicMessageDto> list) {
+            MmsQueueService mmsQueueService = (MmsQueueService) QueueService.MMS_QUEUE_SERVICE.getService();
+            return mmsQueueService.saveMessageForList(list);
         }
 
         @Override

         }
 
         @Override
+        public int saveMessageForList(List<BasicMessageDto> list) {
+            KakaoAlarmQueueService kakaoAlarmQueueService = (KakaoAlarmQueueService) QueueService.KAT_QUEUE_SERVICE.getService();
+            return kakaoAlarmQueueService.saveMessageForList(list);
+        }
+
+        @Override
         public void memoryEnQueue(BasicMessageDto data) {
             KakaoAlarmQueueService kakaoAlarmQueueService = (KakaoAlarmQueueService) QueueService.KAT_QUEUE_SERVICE.getService();
             kakaoAlarmQueueService.memoryEnQueue(data);

         }
 
         @Override
+        public int saveMessageForList(List<BasicMessageDto> list) {
+            KakaoFriendQueueService kakaoFriendQueueService = (KakaoFriendQueueService) QueueService.KFT_QUEUE_SERVICE.getService();
+            return kakaoFriendQueueService.saveMessageForList(list);
+        }
+
+        @Override
         public void memoryEnQueue(BasicMessageDto data) {
             KakaoFriendQueueService kakaoFriendQueueService = (KakaoFriendQueueService) QueueService.KFT_QUEUE_SERVICE.getService();
             kakaoFriendQueueService.memoryEnQueue(data);

     public abstract void addQueue(WriteQueue queue);
     public abstract void pushQueue(BasicMessageDto data);
     public abstract int saveMessageToTable(BasicMessageDto data);
+    public abstract int saveMessageForList(List<BasicMessageDto> list);
 
     public abstract void memoryEnQueue(BasicMessageDto data);
     public abstract BasicMessageDto memoryDeQueue();

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/mapper/KatMapper.java

--- src/main/java/com/munjaon/server/queue/mapper/KatMapper.java

+++ src/main/java/com/munjaon/server/queue/mapper/KatMapper.java


 import com.munjaon.server.queue.dto.BasicMessageDto;
 import org.apache.ibatis.annotations.Mapper;
 
+import java.util.List;
+
 @Mapper
 public interface KatMapper {
     int insert(BasicMessageDto messageDto);
+    int insertForList(List<BasicMessageDto> list);
+    int insertGroupForList(List<BasicMessageDto> list);
 }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/mapper/KftMapper.java

--- src/main/java/com/munjaon/server/queue/mapper/KftMapper.java

+++ src/main/java/com/munjaon/server/queue/mapper/KftMapper.java


 import com.munjaon.server.queue.dto.BasicMessageDto;
 import org.apache.ibatis.annotations.Mapper;
 
+import java.util.List;
+
 @Mapper
 public interface KftMapper {
     int insert(BasicMessageDto messageDto);
+    int insertForList(List<BasicMessageDto> list);
+    int insertGroupForList(List<BasicMessageDto> list);
 }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/mapper/LmsMapper.java

--- src/main/java/com/munjaon/server/queue/mapper/LmsMapper.java

+++ src/main/java/com/munjaon/server/queue/mapper/LmsMapper.java


 import com.munjaon.server.queue.dto.BasicMessageDto;
 import org.apache.ibatis.annotations.Mapper;
 
+import java.util.List;
+
 @Mapper
 public interface LmsMapper {
     int insert(BasicMessageDto messageDto);
+    int insertForList(List<BasicMessageDto> list);
+    int insertGroupForList(List<BasicMessageDto> list);
 }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/mapper/MmsMapper.java

--- src/main/java/com/munjaon/server/queue/mapper/MmsMapper.java

+++ src/main/java/com/munjaon/server/queue/mapper/MmsMapper.java


 import com.munjaon.server.queue.dto.BasicMessageDto;
 import org.apache.ibatis.annotations.Mapper;
 
+import java.util.List;
+
 @Mapper
 public interface MmsMapper {
     int insert(BasicMessageDto messageDto);
+    int insertForList(List<BasicMessageDto> list);
+    int insertGroupForList(List<BasicMessageDto> list);
 }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/mapper/SmsMapper.java

--- src/main/java/com/munjaon/server/queue/mapper/SmsMapper.java

+++ src/main/java/com/munjaon/server/queue/mapper/SmsMapper.java


 import com.munjaon.server.queue.dto.BasicMessageDto;
 import org.apache.ibatis.annotations.Mapper;
 
+import java.util.List;
+
 @Mapper
 public interface SmsMapper {
     int insert(BasicMessageDto messageDto);
+    int insertForList(List<BasicMessageDto> list);
+    int insertGroupForList(List<BasicMessageDto> list);
 }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/pool/ReportQueue.java

--- src/main/java/com/munjaon/server/queue/pool/ReportQueue.java

+++ src/main/java/com/munjaon/server/queue/pool/ReportQueue.java


     }
 
     public boolean isTruncateQueue(int maxWriteCount) {
-        boolean truncate = false;
         synchronized (lockObject) {
             if (this.writeCounter >= maxWriteCount) {
                 if (this.writeCounter == this.readCounter) {
-                    truncate = true;
+                    return true;
                 }
+                return false;
             }
+            return false;
         }
-
-        return truncate;
     }
 
     public boolean isWriteLimit(int maxWriteCount) {
-        boolean isLimit = false;
         synchronized (lockObject) {
             if (this.writeCounter >= maxWriteCount) {
-                isLimit = true;
+                return true;
             }
+            return false;
         }
+    }
 
-        return isLimit;
+    public boolean isRemainReport() {
+        return this.writeCounter > this.readCounter;
     }
 
     public void truncateQueue() throws Exception {

     }
 
     private void readHeader() throws Exception {
-        synchronized (lockObject) {
-            initHeadBuffer();
-            this.channel.position(0);
-            this.channel.read(this.headBuffer);
-            this.byteArray = new byte[ReportConfig.USER_ID_LENGTH];
-            // USER_ID
-            this.headBuffer.position(ReportConfig.USER_ID_POSITION);
-            this.headBuffer.get(this.byteArray);
-            this.userId = (new String(this.byteArray)).trim();
-            // 쓰기 카운트 가져오기
-            this.byteArray = new byte[ReportConfig.WRITE_COUNT_LENGTH];
-            this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
-            this.headBuffer.get(this.byteArray);
-            this.writeCounter = Integer.parseInt((new String(this.byteArray)).trim());
-            // 읽기 카운트 가져오기
-            this.byteArray = new byte[ReportConfig.READ_COUNT_LENGTH];
-            this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
-            this.headBuffer.get(this.byteArray);
-            this.readCounter = Integer.parseInt((new String(this.byteArray)).trim());
-        }
+        initHeadBuffer();
+        this.channel.position(0);
+        this.channel.read(this.headBuffer);
+        this.byteArray = new byte[ReportConfig.USER_ID_LENGTH];
+        // USER_ID
+        this.headBuffer.position(ReportConfig.USER_ID_POSITION);
+        this.headBuffer.get(this.byteArray);
+        this.userId = (new String(this.byteArray)).trim();
+        // 쓰기 카운트 가져오기
+        this.byteArray = new byte[ReportConfig.WRITE_COUNT_LENGTH];
+        this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
+        this.headBuffer.get(this.byteArray);
+        this.writeCounter = Integer.parseInt((new String(this.byteArray)).trim());
+        // 읽기 카운트 가져오기
+        this.byteArray = new byte[ReportConfig.READ_COUNT_LENGTH];
+        this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
+        this.headBuffer.get(this.byteArray);
+        this.readCounter = Integer.parseInt((new String(this.byteArray)).trim());
     }
 
     public void addReadCounter() throws Exception {

             /* 읽기 카운트 증가 */
             this.readCounter = this.readCounter + 1;
 
-            initHeadBuffer();
-            this.channel.position(ReportConfig.USER_ID_POSITION);
-            this.headBuffer.put(this.userId.getBytes());
-            this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
-            this.headBuffer.put(Integer.toString(this.writeCounter).getBytes());
-            this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
-            this.headBuffer.put(Integer.toString(this.readCounter).getBytes());
-            this.headBuffer.flip();
-            this.channel.write(this.headBuffer);
+            writeHeader();
         }
     }
 
     private void writeHeader() throws Exception {
-        synchronized (lockObject) {
-            initHeadBuffer();
-            this.channel.position(ReportConfig.USER_ID_POSITION);
-            this.headBuffer.put(this.userId.getBytes());
-            this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
-            this.headBuffer.put(Integer.toString(this.writeCounter).getBytes());
-            this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
-            this.headBuffer.put(Integer.toString(this.readCounter).getBytes());
-            this.headBuffer.flip();
-            this.channel.write(this.headBuffer);
-        }
+        initHeadBuffer();
+        this.channel.position(ReportConfig.USER_ID_POSITION);
+        this.headBuffer.put(this.userId.getBytes());
+        this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
+        this.headBuffer.put(Integer.toString(this.writeCounter).getBytes());
+        this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
+        this.headBuffer.put(Integer.toString(this.readCounter).getBytes());
+        this.headBuffer.flip();
+        this.channel.write(this.headBuffer);
     }
 
     private void initHeadBuffer() {

455962e

src/main/java/com/munjaon/server/queue/pool/SerialQueue.java (added)

+++ src/main/java/com/munjaon/server/queue/pool/SerialQueue.java

...	...	@@ -0,0 +1,125 @@
	1	+package com.munjaon.server.queue.pool;
	2	+
	3	+import com.munjaon.server.queue.config.QueueConstants;
	4	+import com.munjaon.server.util.FileUtil;
	5	+import lombok.Getter;
	6	+
	7	+import java.io.File;
	8	+import java.io.IOException;
	9	+import java.io.RandomAccessFile;
	10	+import java.nio.ByteBuffer;
	11	+import java.nio.channels.FileChannel;
	12	+
	13	+public class SerialQueue {
	14	+ /** Queue Header Buffer */
	15	+ private ByteBuffer dataBuffer = null;
	16	+ /** Header 에서 사용하는 변수 */
	17	+ private byte[] dataArray = null;
	18	+ /* 채번 큐 크기 */
	19	+ private final int SERIAL_QUEUE_SIZE = 14;
	20	+ /* 큐경로 */
	21	+ @Getter
	22	+ private String queuePath;
	23	+ @Getter
	24	+ private final String queueName = "SERIAL_QUEUE.queue";
	25	+ @Getter
	26	+ private Long serialNo = 0L;
	27	+ /** Queue File Channel */
	28	+ private FileChannel channel = null;
	29	+
	30	+ public SerialQueue() throws Exception {
	31	+ initQueue();
	32	+ }
	33	+
	34	+ private void initQueuePath() {
	35	+ /* 1. 큐경로 */
	36	+ this.queuePath = System.getProperty("ROOTPATH") + File.separator + "queue" + File.separator + "SERIAL_QUEUE";
	37	+ /* 2. 경로 체크 및 생성 */
	38	+ FileUtil.mkdirs(this.queuePath);
	39	+ }
	40	+
	41	+ private void initQueue() throws Exception {
	42	+ this.dataBuffer = ByteBuffer.allocateDirect(SERIAL_QUEUE_SIZE);
	43	+ try{
	44	+ /* 1. 큐경로 초기화 */
	45	+ initQueuePath();
	46	+ File file = new File(this.queuePath + File.separator + queueName);
	47	+ this.channel = new RandomAccessFile(file, "rw").getChannel();
	48	+
	49	+ if (file.length() == 0) {
	50	+ serialNo = 0L;
	51	+ // 헤더 초기화
	52	+ writeData();
	53	+ } else {
	54	+ readData();
	55	+ }
	56	+// backupQueue();
	57	+ } catch(Exception e) {
	58	+ throw e;
	59	+ } finally {
	60	+ //lock.release();
	61	+ }
	62	+ }
	63	+
	64	+ private void readData() throws Exception {
	65	+ try {
	66	+ initDataBuffer();
	67	+ this.channel.position(0);
	68	+ this.channel.read(this.dataBuffer);
	69	+
	70	+ this.dataArray = new byte[SERIAL_QUEUE_SIZE];
	71	+ this.dataBuffer.position(0);
	72	+ this.dataBuffer.get(this.dataArray);
	73	+ String no = QueueConstants.getString(this.dataArray);
	74	+ serialNo = Long.parseLong(no);
	75	+ System.out.println("SERIAL QUEUE NO: " + serialNo);
	76	+ } catch(Exception e) {
	77	+ throw e;
	78	+ }
	79	+ }
	80	+
	81	+ public String getSerialNumber() throws Exception {
	82	+ this.serialNo = this.serialNo + 1;
	83	+ writeData();
	84	+
	85	+ return String.valueOf(this.serialNo);
	86	+ }
	87	+
	88	+ private void writeData() throws Exception {
	89	+ try {
	90	+ initDataBuffer();
	91	+ this.channel.position(0);
	92	+ this.dataBuffer.put(String.valueOf(serialNo).getBytes());
	93	+ this.dataBuffer.flip();
	94	+ this.channel.write(this.dataBuffer);
	95	+ } catch(Exception e) {
	96	+ throw e;
	97	+ }
	98	+ }
	99	+
	100	+ private void initDataBuffer(){
	101	+ this.dataBuffer.clear();
	102	+ for(int loopCnt = 0; loopCnt < SERIAL_QUEUE_SIZE; loopCnt++){
	103	+ this.dataBuffer.put(QueueConstants.SET_DEFAULT_BYTE);
	104	+ }
	105	+ this.dataBuffer.position(0);
	106	+ }
	107	+
	108	+ public void close() throws IOException {
	109	+ try {
	110	+ if (isOpen()) {
	111	+ channel.close();
	112	+ }
	113	+ } catch(IOException e) {
	114	+ throw e;
	115	+ }
	116	+ }
	117	+
	118	+ public boolean isOpen() {
	119	+ if (this.channel == null) {
	120	+ return false;
	121	+ }
	122	+
	123	+ return this.channel.isOpen();
	124	+ }
	125	+}

455962e

src/main/java/com/munjaon/server/queue/pool/SerialQueuePool.java (added)

+++ src/main/java/com/munjaon/server/queue/pool/SerialQueuePool.java

...	...	@@ -0,0 +1,54 @@
	1	+package com.munjaon.server.queue.pool;
	2	+
	3	+public class SerialQueuePool {
	4	+ /** Lock Object */
	5	+ protected final Object lockMonitor = new Object();
	6	+ /* Serial Queue */
	7	+ private SerialQueue serialQueue;
	8	+
	9	+ private static SerialQueuePool queueInstance;
	10	+
	11	+ private SerialQueuePool() {}
	12	+
	13	+ public synchronized static SerialQueuePool getInstance() {
	14	+ if (queueInstance == null) {
	15	+ queueInstance = new SerialQueuePool();
	16	+ }
	17	+
	18	+ return queueInstance;
	19	+ }
	20	+
	21	+ public String getSerialNumber() throws Exception {
	22	+ synchronized (lockMonitor) {
	23	+ if (serialQueue == null \|\| serialQueue.isOpen() == false) {
	24	+ try {
	25	+ lockMonitor.wait();
	26	+ } catch(InterruptedException e) {
	27	+ // 아무 처리도 하지 않는다.
	28	+ }
	29	+ }
	30	+
	31	+ return serialQueue.getSerialNumber();
	32	+ }
	33	+ }
	34	+
	35	+ public void setSerialQueue(SerialQueue serialQueue) {
	36	+ synchronized(lockMonitor){
	37	+ if (serialQueue != null){
	38	+ this.serialQueue = serialQueue;
	39	+ lockMonitor.notifyAll();
	40	+ }
	41	+ }
	42	+ }
	43	+
	44	+ public boolean isReady() {
	45	+ synchronized (lockMonitor) {
	46	+ if (serialQueue != null && serialQueue.isOpen()) {
	47	+ return true;
	48	+ } else {
	49	+ return false;
	50	+ }
	51	+ }
	52	+ }
	53	+
	54	+}

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/service/KakaoAlarmQueueService.java

--- src/main/java/com/munjaon/server/queue/service/KakaoAlarmQueueService.java

+++ src/main/java/com/munjaon/server/queue/service/KakaoAlarmQueueService.java


 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
 
 @Slf4j
 @Service

     }
 
     @Override
+    @Transactional
+    public int saveMessageForList(List<BasicMessageDto> list) {
+        katMapper.insertGroupForList(list);
+        return katMapper.insertForList(list);
+    }
+
+    @Override
     public void memoryEnQueue(BasicMessageDto data) {
         memoryQueue.memoryEnQueue(data);
     }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/service/KakaoFriendQueueService.java

--- src/main/java/com/munjaon/server/queue/service/KakaoFriendQueueService.java

+++ src/main/java/com/munjaon/server/queue/service/KakaoFriendQueueService.java


 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
 
 @Slf4j
 @Service

     }
 
     @Override
+    @Transactional
+    public int saveMessageForList(List<BasicMessageDto> list) {
+        kftMapper.insertGroupForList(list);
+        return kftMapper.insertForList(list);
+    }
+
+    @Override
     public void memoryEnQueue(BasicMessageDto data) {
         memoryQueue.memoryEnQueue(data);
     }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/service/LmsQueueService.java

--- src/main/java/com/munjaon/server/queue/service/LmsQueueService.java

+++ src/main/java/com/munjaon/server/queue/service/LmsQueueService.java


 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
 
 @Slf4j
 @Service

     }
 
     @Override
+    @Transactional
+    public int saveMessageForList(List<BasicMessageDto> list) {
+        lmsMapper.insertGroupForList(list);
+        return lmsMapper.insertForList(list);
+    }
+
+    @Override
     public void memoryEnQueue(BasicMessageDto data) {
         memoryQueue.memoryEnQueue(data);
     }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/service/MmsQueueService.java

--- src/main/java/com/munjaon/server/queue/service/MmsQueueService.java

+++ src/main/java/com/munjaon/server/queue/service/MmsQueueService.java


 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
 
 @Slf4j
 @Service

     }
 
     @Override
+    @Transactional
+    public int saveMessageForList(List<BasicMessageDto> list) {
+        mmsMapper.insertGroupForList(list);
+        return mmsMapper.insertForList(list);
+    }
+
+    @Override
     public void memoryEnQueue(BasicMessageDto data) {
         memoryQueue.memoryEnQueue(data);
     }

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/service/QueueAction.java

--- src/main/java/com/munjaon/server/queue/service/QueueAction.java

+++ src/main/java/com/munjaon/server/queue/service/QueueAction.java


 import com.munjaon.server.queue.dto.BasicMessageDto;
 import com.munjaon.server.queue.pool.WriteQueue;
 
+import java.util.List;
+
 public interface QueueAction {
     int getQueueSize();
     boolean isExistQueue(String name);

     void addQueue(WriteQueue queue);
     void pushQueue(BasicMessageDto data);
     int saveMessageToTable(BasicMessageDto data);
+    int saveMessageForList(List<BasicMessageDto> list);
 
     void memoryEnQueue(BasicMessageDto data);
     BasicMessageDto memoryDeQueue();

aa4fc21

455962e

src/main/java/com/munjaon/server/queue/service/SmsQueueService.java

--- src/main/java/com/munjaon/server/queue/service/SmsQueueService.java

+++ src/main/java/com/munjaon/server/queue/service/SmsQueueService.java


 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
 
 @Slf4j
 @Service

     }
 
     @Override
+    @Transactional
     public int saveMessageToTable(BasicMessageDto data) {
         String serialNo = serialNoService.getSerialNo();
         String groupSerialNo = serialNo.replace("MSGID", "MGRP");

     }
 
     @Override
+    @Transactional
+    public int saveMessageForList(List<BasicMessageDto> list) {
+        smsMapper.insertGroupForList(list);
+        return smsMapper.insertForList(list);
+    }
+
+    @Override
     public void memoryEnQueue(BasicMessageDto data) {
         memoryQueue.memoryEnQueue(data);
     }

aa4fc21

455962e

src/main/java/com/munjaon/server/scheduler/service/CacheScheduleService.java

--- src/main/java/com/munjaon/server/scheduler/service/CacheScheduleService.java

+++ src/main/java/com/munjaon/server/scheduler/service/CacheScheduleService.java


 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 
 @Slf4j

     /* 사용자 설정 테이블 마지막 업데이트 시간 */
     private String config_last_modified_time = null;
 
-//    @Scheduled(cron="0/5 * * * * *")
+    @Scheduled(cron="0/5 * * * * *")
     public void doService() throws Exception {
         doMemberService();
     }

aa4fc21

455962e

src/main/java/com/munjaon/server/server/config/ServerConfig.java

--- src/main/java/com/munjaon/server/server/config/ServerConfig.java

+++ src/main/java/com/munjaon/server/server/config/ServerConfig.java


     /* 서버 타임아웃 체크 시간 */
     public static final int CYCLE_SOCKET_TIMEOUT = 3000;
     /* 서버 연결후 로그인 만료 시간 */
-    public static final int LIMIT_BIND_TIMEOUT = 5000;
+    public static final int LIMIT_BIND_TIMEOUT = 3000;
     /* Session Check 만료 시간 */
     public static final int LIMIT_LINK_CHECK_TIMEOUT = 10000;
 
     /* 서버 프로퍼티 reload interval 시간 */
     public static final Long INTERVAL_PROPERTY_RELOAD_TIME = 3000L;
+    /* 사용자 정보 조회 체크 시간 */
+    public static final long USER_STATUS_CYCLE_TIME = 60000;
+    /* Deliver Thread 실행 시간 */
+    public static final long DELIVER_EXEC_CYCLE_TIME = 5000;
+    /* Report Thread 실행 시간 */
+    public static final long REPORT_EXEC_CYCLE_TIME = 5000;
 }

aa4fc21

455962e

src/main/java/com/munjaon/server/server/dto/ConnectUserDto.java

--- src/main/java/com/munjaon/server/server/dto/ConnectUserDto.java

+++ src/main/java/com/munjaon/server/server/dto/ConnectUserDto.java


     private String remoteIP;
     /* 요금제(선불 : P / 후불 : A) */
     private final String feeType = "A";
-    private int command;                //요청 command
+    /* 요청 command */
+    private int command;
+    /* 요청을 처리중인지 여부 */
+    private boolean isRunningMode;
 
     private MemberDto memberDto;
 

aa4fc21

455962e

src/main/java/com/munjaon/server/server/dto/ReportUserDto.java

--- src/main/java/com/munjaon/server/server/dto/ReportUserDto.java

+++ src/main/java/com/munjaon/server/server/dto/ReportUserDto.java


     private ReportQueue reportQueue;    //ReportQueue
     private MemberDto memberDto;        //사용자 정보
     private int command;                //요청 command
+    private int maxWriteCount;                //요청 command
+    /* 요청을 처리중인지 여부 */
+    private boolean isRunningMode;
 
     public int isAlive() {
         if (isLogin) {

aa4fc21

455962e

src/main/java/com/munjaon/server/server/sample/Main.java

--- src/main/java/com/munjaon/server/server/sample/Main.java

+++ src/main/java/com/munjaon/server/server/sample/Main.java


 package com.munjaon.server.server.sample;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 
 public class Main {
     public static void main(String[] args) throws InterruptedException, ExecutionException {
         ExecutorService e = Executors.newFixedThreadPool(5);
         // 리턴 값이 필요 없는 경우
-//        for (int i = 0; i < 5; i++) {
-//            e.execute(new MyRunnable(i * 20));
-//        }
+        for (int i = 0; i < 5; i++) {
+            e.execute(new MyRunnable(i * 20));
+        }
         // 작업을 기다려야 할 경우
-        //e.shutdown();
+        e.shutdown();
 
         // 리턴 값이 필요한 경우
-        List<Future<Integer>> l = new ArrayList<>();
-        for (int i = 0; i < 5; i++) {
-            Future<Integer> f = e.submit(new MyCallable(i * 20));
-            l.add(f);
-        }
-
-        // 작업이 완료 되길 기다려야 할 경우
-        int n = 0;
-        for (int i = 0; i < 5; i++) {
-            Future<Integer> f = l.get(i);
-            n += f.get();
-        }
+//        List<Future<Integer>> l = new ArrayList<>();
+//        for (int i = 0; i < 5; i++) {
+//            Future<Integer> f = e.submit(new MyCallable(i * 20));
+//            l.add(f);
+//        }
+//
+//        // 작업이 완료 되길 기다려야 할 경우
+//        int n = 0;
+//        for (int i = 0; i < 5; i++) {
+//            Future<Integer> f = l.get(i);
+//            n += f.get();
+//        }
     }
 }

aa4fc21

455962e

src/main/java/com/munjaon/server/server/sample/MyRunnable.java

--- src/main/java/com/munjaon/server/server/sample/MyRunnable.java

+++ src/main/java/com/munjaon/server/server/sample/MyRunnable.java


     }
 
     public void run() {
+        System.out.println("SendReadTask start : " + Thread.currentThread().getName());
         for (int i = 0; i < 20; i++) {
-            System.out.println(s + " : MyRunnable");
+            System.out.println(s + " : MyRunnable : " + Thread.currentThread().getName());
             System.out.println(i + s);
             try {
                 Thread.sleep(1000L);

455962e

src/main/java/com/munjaon/server/server/service/CollectServer.java (added)

+++ src/main/java/com/munjaon/server/server/service/CollectServer.java

...	...	@@ -0,0 +1,184 @@
	1	+package com.munjaon.server.server.service;
	2	+
	3	+import com.munjaon.server.queue.enums.QueueTypeWorker;
	4	+import com.munjaon.server.server.config.ServerConfig;
	5	+import com.munjaon.server.server.dto.ConnectUserDto;
	6	+import com.munjaon.server.server.queue.CollectUserQueue;
	7	+import com.munjaon.server.server.task.CollectServerTask;
	8	+import com.munjaon.server.server.task.StatusCheckTask;
	9	+import org.json.simple.JSONObject;
	10	+
	11	+import java.io.IOException;
	12	+import java.net.InetAddress;
	13	+import java.net.InetSocketAddress;
	14	+import java.net.Socket;
	15	+import java.nio.channels.SelectionKey;
	16	+import java.nio.channels.Selector;
	17	+import java.nio.channels.ServerSocketChannel;
	18	+import java.nio.channels.SocketChannel;
	19	+import java.util.Iterator;
	20	+
	21	+public class CollectServer extends Service {
	22	+ private final InetSocketAddress listenAddress;
	23	+ private CollectUserQueue collectUserQueue = CollectUserQueue.getInstance();
	24	+
	25	+ private Selector selector;
	26	+ private final String serviceType;
	27	+
	28	+ private long USER_STATUS_LAST_CHECK_TIME = System.currentTimeMillis();
	29	+
	30	+ public CollectServer(String serviceName, String serviceType, int port) {
	31	+ super(serviceName);
	32	+ this.listenAddress = new InetSocketAddress(port);
	33	+ this.serviceType = serviceType;
	34	+ }
	35	+
	36	+ @Override
	37	+ public void checkReady() {
	38	+ QueueTypeWorker worker = QueueTypeWorker.find(this.serviceType);
	39	+ if (worker != null && worker.getQueueSize() > 0) {
	40	+ this.IS_READY_YN = true;
	41	+ saveSystemLog("COLLECT_SERVER_SERVICE : QUEUE IS READY ... ...");
	42	+ } else {
	43	+ this.IS_READY_YN = false;
	44	+ saveSystemLog("COLLECT_SERVER_SERVICE : QUEUE IS NOT READY ... ...");
	45	+ }
	46	+ }
	47	+
	48	+ @Override
	49	+ public void initResources() {
	50	+ try {
	51	+ saveSystemLog("COLLECT_SERVER_SERVICE : RESOURCES INITIALIZING ... ...");
	52	+ initCollectChannel();
	53	+ saveSystemLog("COLLECT_SERVER_SERVICE : RESOURCES INITIALIZED ... ...");
	54	+ } catch (IOException e) {
	55	+ saveSystemLog(e);
	56	+ throw new RuntimeException(e);
	57	+ }
	58	+ }
	59	+
	60	+ private void initCollectChannel() throws IOException {
	61	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SOCKET INITIALIZING ... ...");
	62	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER PORT [" + listenAddress.getPort() + "]");
	63	+ selector = Selector.open();
	64	+ /* 채널 생성 */
	65	+ ServerSocketChannel serverChannel = ServerSocketChannel.open();
	66	+ /* non-Blocking 설정 */
	67	+ serverChannel.configureBlocking(false);
	68	+ /* 서버 ip, port 설정 */
	69	+ serverChannel.socket().bind(listenAddress);
	70	+ /* 채널에 accept 대기 설정 */
	71	+ serverChannel.register(selector, SelectionKey.OP_ACCEPT);
	72	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SOCKET INITIALIZED ... ...");
	73	+ }
	74	+
	75	+ private void closeCollectChannel() throws IOException {
	76	+ selector.close();
	77	+ }
	78	+
	79	+ @Override
	80	+ public void releaseResources() {
	81	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER RESOURCE RELEASING ... ...");
	82	+ try {
	83	+ closeCollectChannel();
	84	+ } catch (IOException e) {
	85	+ saveSystemLog(e);
	86	+ throw new RuntimeException(e);
	87	+ }
	88	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER RESOURCE RELEASED ... ...");
	89	+ }
	90	+
	91	+ @Override
	92	+ public void doService() {
	93	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SERVICE STARTED ... ...");
	94	+ while (isRun()) {
	95	+ try {
	96	+ execInterest();
	97	+ execUserStatus();
	98	+ } catch (Exception e) {
	99	+ throw new RuntimeException(e);
	100	+ }
	101	+ }
	102	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SERVICE STOPPED ... ...");
	103	+ }
	104	+
	105	+ private void execInterest() throws IOException {
	106	+ if (selector.select(1000) == 0) {
	107	+ return ;
	108	+ }
	109	+ Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
	110	+ while (keys.hasNext()) {
	111	+ SelectionKey key = keys.next();
	112	+ /* 키 셋에서 제거. */
	113	+ keys.remove();
	114	+
	115	+ if (key.isValid()) {
	116	+ if (key.isAcceptable()) { // 접속일 경우..
	117	+ saveSystemLog("CONNECTION IS ACCEPTABLE ... ...");
	118	+ accept(selector, key);
	119	+ } else if (key.isReadable()) { // 수신일 경우..
	120	+ ConnectUserDto connectUserDto = (ConnectUserDto) key.attachment();
	121	+ if (connectUserDto == null \|\| connectUserDto.isRunningMode()) {
	122	+ continue;
	123	+ }
	124	+ /* 사용자별 Collect Thread 실행 */
	125	+ new CollectServerTask(selector, key, getName(), this.serviceType, logger).run();
	126	+ }
	127	+ } else {
	128	+ expireConnectUser(key);
	129	+ }
	130	+ }
	131	+ }
	132	+
	133	+ private void execUserStatus() throws IOException {
	134	+ if (System.currentTimeMillis() - USER_STATUS_LAST_CHECK_TIME > ServerConfig.USER_STATUS_CYCLE_TIME) {
	135	+ new StatusCheckTask(this.serviceType, logger).run();
	136	+ USER_STATUS_LAST_CHECK_TIME = System.currentTimeMillis();
	137	+ }
	138	+ }
	139	+
	140	+ private void accept(Selector selector, SelectionKey key) {
	141	+ try {
	142	+ /* 키 채널을 가져온다. */
	143	+ ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
	144	+ /* accept을 해서 Socket 채널을 가져온다. */
	145	+ SocketChannel channel = serverChannel.accept();
	146	+ channel.configureBlocking(false);
	147	+ /* 소켓 취득 */
	148	+ Socket socket = channel.socket();
	149	+ InetAddress inetAddress = socket.getInetAddress();
	150	+ saveSystemLog("[CLIENT CONNECTION IP : " + inetAddress.getHostAddress() + "]");
	151	+ // Socket 채널을 channel에 수신 등록한다
	152	+ channel.register(selector, SelectionKey.OP_READ, ConnectUserDto.builder().serviceType(this.serviceType).lastTrafficTime(System.currentTimeMillis()).remoteIP(inetAddress.getHostAddress()).build());
	153	+ } catch (Exception e) {
	154	+ throw new RuntimeException(e);
	155	+ }
	156	+ }
	157	+
	158	+ private void expireConnectUser(SelectionKey key) {
	159	+ if (key == null \|\| !key.isValid()) {
	160	+ return;
	161	+ }
	162	+ try {
	163	+ SocketChannel channel = (SocketChannel) key.channel();
	164	+ ConnectUserDto userDto = (ConnectUserDto) key.attachment();
	165	+ if (userDto != null && userDto.getUserId() != null) {
	166	+ saveSystemLog("[CLIENT USER IS DISCONNECT : " + userDto.toString() + "]");
	167	+ collectUserQueue.removeUser(this.serviceType, userDto.getUserId());
	168	+// connectUserMap.remove(userDto.getUserId());
	169	+ key.attach(null);
	170	+ }
	171	+ // 소켓 채널 닫기
	172	+ channel.close();
	173	+ // 키 닫기
	174	+ key.cancel();
	175	+ } catch (IOException e) {
	176	+ e.printStackTrace();
	177	+ }
	178	+ }
	179	+
	180	+ @Override
	181	+ public JSONObject monitorService() {
	182	+ return null;
	183	+ }
	184	+}

aa4fc21

455962e

src/main/java/com/munjaon/server/server/service/CollectServerService.java

--- src/main/java/com/munjaon/server/server/service/CollectServerService.java

+++ src/main/java/com/munjaon/server/server/service/CollectServerService.java


 import com.munjaon.server.server.dto.ConnectUserDto;
 import com.munjaon.server.server.queue.CollectUserQueue;
 import com.munjaon.server.server.task.CollectReadTask;
+import com.munjaon.server.server.task.SendReadTask;
+import com.munjaon.server.server.task.StatusCheckTask;
 import com.munjaon.server.util.LogUtil;
 import lombok.Getter;
 import org.json.simple.JSONObject;
 
 import java.io.IOException;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
-import java.net.SocketAddress;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.ServerSocketChannel;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
-import java.util.concurrent.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 public class CollectServerService extends Service {
     private final InetSocketAddress listenAddress;
     private CollectThreadService threadService;
+    private StatusThreadService statusThreadService;
     private CollectUserQueue collectUserQueue = CollectUserQueue.getInstance();
+
     private Selector selector;
     private final String serviceType;
     private int readMaxCore;
+
+    private long USER_STATUS_LAST_CHECK_TIME = System.currentTimeMillis();
+    private static final long USER_STATUS_CYCLE_TIME = 60000;
 
     public CollectServerService(String serviceName, String serviceType, int port) {
         super(serviceName);

         QueueTypeWorker worker = QueueTypeWorker.find(this.serviceType);
         if (worker != null && worker.getQueueSize() > 0) {
             this.IS_READY_YN = true;
+            saveSystemLog("COLLECT_SERVER_SERVICE : QUEUE IS READY ... ...");
         } else {
             this.IS_READY_YN = false;
+            saveSystemLog("COLLECT_SERVER_SERVICE : QUEUE IS NOT READY ... ...");
         }
-        saveSystemLog("CollectServerService ready : " + this.IS_READY_YN);
     }
 
     @Override
     public void initResources() {
         try {
+            saveSystemLog("COLLECT_SERVER_SERVICE : RESOURCES INITIALIZING ... ...");
             initCollectChannel();
             threadService = new CollectThreadService(readMaxCore, this.serviceType, logger);
+            statusThreadService = new StatusThreadService(this.serviceType, this.logger);
+            saveSystemLog("COLLECT_SERVER_SERVICE : RESOURCES INITIALIZED ... ...");
         } catch (IOException e) {
             saveSystemLog(e);
             throw new RuntimeException(e);

     }
 
     private void initCollectChannel() throws IOException {
+        saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SOCKET INITIALIZING ... ...");
+        saveSystemLog("COLLECT_SERVER_SERVICE : SERVER PORT [" + listenAddress.getPort() + "]");
         selector = Selector.open();
         /* 채널 생성 */
         ServerSocketChannel serverChannel = ServerSocketChannel.open();

         serverChannel.socket().bind(listenAddress);
         /* 채널에 accept 대기 설정 */
         serverChannel.register(selector, SelectionKey.OP_ACCEPT);
+        saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SOCKET INITIALIZED ... ...");
     }
 
     private void closeCollectChannel() throws IOException {

 
     @Override
     public void releaseResources() {
+        saveSystemLog("COLLECT_SERVER_SERVICE : SERVER RESOURCE RELEASING ... ...");
         try {
             closeCollectChannel();
             threadService.close();
+            statusThreadService.close();
         } catch (IOException e) {
             saveSystemLog(e);
             throw new RuntimeException(e);
         }
+        saveSystemLog("COLLECT_SERVER_SERVICE : SERVER RESOURCE RELEASED ... ...");
     }
 
     @Override
     public void doService() {
+        saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SERVICE STARTED ... ...");
         while (isRun()) {
             try {
                 execInterest();
+                execUserStatus();
             } catch (Exception e) {
                 throw new RuntimeException(e);
+            }
+        }
+        saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SERVICE STOPPED ... ...");
+    }
+
+    private void execInterest_bak() throws IOException {
+        if (selector.select(1000) == 0) {
+            return ;
+        }
+        Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
+        while (keys.hasNext()) {
+            SelectionKey key = keys.next();
+            /* 키 셋에서 제거. */
+            keys.remove();
+
+            if (key.isValid()) {
+                if (key.isAcceptable()) {   // 접속일 경우..
+                    saveSystemLog("CONNECTION IS ACCEPTABLE ... ...");
+                    accept(selector, key);
+                } else if (key.isReadable()) {  // 수신일 경우..
+                    ConnectUserDto connectUserDto = (ConnectUserDto) key.attachment();
+                    if (connectUserDto == null || connectUserDto.isRunningMode()) {
+                        continue;
+                    }
+                    threadService.execute(new SendReadTask(selector, key, this.serviceType, logger));
+//                    threadService.submit(selector, key, 2);
+                }
+            } else {
+                expireConnectUser(key);
             }
         }
     }

 
             if (key.isValid()) {
                 if (key.isAcceptable()) {   // 접속일 경우..
-                    saveSystemLog("isAcceptable");
+                    saveSystemLog("CONNECTION IS ACCEPTABLE ... ...");
                     accept(selector, key);
                 } else if (key.isReadable()) {  // 수신일 경우..
-                    saveSystemLog("isReadable");
                     Future<ConnectUserDto> future = threadService.submit(new CollectReadTask(selector, key, this.serviceType, logger));
                     list.add(future);
 //                    threadService.submit(selector, key, 2);

             } catch (ExecutionException e) {
             }
 
-            if (connectUserDto == null) {
-                saveSystemLog("Future : " + future);
-            } else {
-                saveSystemLog("Future : " + connectUserDto.toString());
+            if (connectUserDto != null) {
+                saveSystemLog("[READ USER : " + connectUserDto.toString() + "]");
             }
+        }
+    }
+
+    private void execUserStatus() throws IOException {
+        if (System.currentTimeMillis() - USER_STATUS_LAST_CHECK_TIME > USER_STATUS_CYCLE_TIME) {
+            statusThreadService.execute(new StatusCheckTask(this.serviceType, logger));
+            USER_STATUS_LAST_CHECK_TIME = System.currentTimeMillis();
         }
     }
 

             channel.configureBlocking(false);
             /* 소켓 취득 */
             Socket socket = channel.socket();
-            SocketAddress remoteAddr = socket.getRemoteSocketAddress();
-            saveSystemLog("Connected to: " + remoteAddr);
+            InetAddress inetAddress = socket.getInetAddress();
+            saveSystemLog("[CLIENT CONNECTION IP : " + inetAddress.getHostAddress() + "]");
             // Socket 채널을 channel에 수신 등록한다
-            channel.register(selector, SelectionKey.OP_READ, ConnectUserDto.builder().serviceType(this.serviceType).lastTrafficTime(System.currentTimeMillis()).remoteIP(remoteAddr.toString()).build());
+            channel.register(selector, SelectionKey.OP_READ, ConnectUserDto.builder().serviceType(this.serviceType).lastTrafficTime(System.currentTimeMillis()).remoteIP(inetAddress.getHostAddress()).build());
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

             SocketChannel channel = (SocketChannel) key.channel();
             ConnectUserDto userDto = (ConnectUserDto) key.attachment();
             if (userDto != null && userDto.getUserId() != null) {
+                saveSystemLog("[CLIENT USER IS DISCONNECT : " + userDto.toString() + "]");
                 collectUserQueue.removeUser(this.serviceType, userDto.getUserId());
 //                connectUserMap.remove(userDto.getUserId());
                 key.attach(null);

         return null;
     }
 
-    private static class CollectThreadService {
+    private static class StatusThreadService {
         @Getter
         private String serviceType;
         @Getter
-        private final int maxCore;
+        private final int maxCore = 1;
         private final ExecutorService executor;
-        private final Map<String, ConnectUserDto> connectUserMap = new ConcurrentHashMap<>();
         private final LogUtil logger;
 
-        public CollectThreadService(String serviceType, LogUtil logger) {
-            this(Runtime.getRuntime().availableProcessors(), serviceType, logger);
-        }
-
-        public CollectThreadService(int maxCore, String serviceType, LogUtil logger) {
-            this.maxCore = maxCore;
+        public StatusThreadService(String serviceType, LogUtil logger) {
             this.executor = Executors.newFixedThreadPool(maxCore);
             this.logger = logger;
+            saveSystemLog("[STATUS_TASK_THREAD_POOL : " + maxCore + "]");
         }
 
-        public Future<ConnectUserDto> submit(CollectReadTask collectReadTask) {
-            return executor.submit(collectReadTask);
+        public void execute(StatusCheckTask statusCheckTask) {
+            executor.execute(statusCheckTask);
         }
 
         private void saveSystemLog(Object obj) {

 
         public void close() {
             List<Runnable> unfinishedTasks = executor.shutdownNow();
-            connectUserMap.clear();
+            if (!unfinishedTasks.isEmpty()) {
+                saveSystemLog("Not all tasks finished before calling close: " + unfinishedTasks.size());
+            }
+        }
+    }
+
+    private static class CollectThreadService {
+        @Getter
+        private String serviceType;
+        @Getter
+        private final int maxCore;
+        private final ExecutorService executor;
+        private final LogUtil logger;
+
+        public CollectThreadService(String serviceType, LogUtil logger) {
+            this(Runtime.getRuntime().availableProcessors(), serviceType, logger);
+        }
+
+        public CollectThreadService(int maxCore, String serviceType, LogUtil logger) {
+            this.maxCore = maxCore;
+            this.executor = Executors.newFixedThreadPool(maxCore);
+            this.logger = logger;
+            saveSystemLog("[COLLECT_TASK_THREAD_POOL : " + maxCore + "]");
+        }
+
+        public Future<ConnectUserDto> submit(CollectReadTask collectReadTask) {
+            return executor.submit(collectReadTask);
+        }
+
+        public void execute(SendReadTask sendReadTask) {
+            executor.execute(sendReadTask);
+        }
+
+        private void saveSystemLog(Object obj) {
+            saveLog(obj, true);
+        }
+
+        private void saveLog(Object obj) {
+            saveLog(obj, false);
+        }
+
+        private void saveLog(Object obj, boolean isConsoleOutput) {
+            if (isConsoleOutput) {
+                System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern(LOG_DATE_FORMAT)) + " {{" + serviceType + "}} " + obj);
+            }
+
+            if (logger == null) {
+                return;
+            }
+
+            logger.log(obj);
+        }
+
+        public void close() {
+            List<Runnable> unfinishedTasks = executor.shutdownNow();
             if (!unfinishedTasks.isEmpty()) {
                 saveSystemLog("Not all tasks finished before calling close: " + unfinishedTasks.size());
             }

aa4fc21

455962e

src/main/java/com/munjaon/server/server/service/QueueServerService.java

--- src/main/java/com/munjaon/server/server/service/QueueServerService.java

+++ src/main/java/com/munjaon/server/server/service/QueueServerService.java


 import com.munjaon.server.queue.dto.BasicMessageDto;
 import com.munjaon.server.queue.enums.QueueTypeWorker;
 import com.munjaon.server.queue.pool.ReadQueue;
+import com.munjaon.server.queue.pool.SerialQueuePool;
 import com.munjaon.server.queue.pool.WriteQueue;
 import com.munjaon.server.util.CommonUtil;
+import com.munjaon.server.util.MessageUtil;
 import com.munjaon.server.util.ServiceUtil;
 import org.json.simple.JSONObject;
 
 import java.io.IOException;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
 
 public class QueueServerService extends Service {
     /** 큐모드 설정(WAIT : 파일에 쓰기모드만 / DB : DB에 적재)  */

     private long QUEUE_INIT_CHECK_TIME = 0;
     /** Commit 누적 카운트  */
     private long SUM_COMMIT_COUNT = 0;
+    SerialQueuePool queueInstance = SerialQueuePool.getInstance();
     /* 쓰기큐 */
     private WriteQueue writeQueue;
     private ReadQueue readQueue;

 
     @Override
     public void checkReady() {
-        this.IS_READY_YN = true;
+        this.IS_READY_YN = queueInstance.isReady();
     }
 
     @Override

         }
         // 큐초기화 대상이면
         if (isQueueInit) {
+            /* 큐 백업 */
+            writeQueue.backupQueue();
             /* 커밋 카운트 초기화 */
             SUM_COMMIT_COUNT = 0;
             writeQueue.truncateQueue();

             isQueueInit = true;
         }
         if (isQueueInit) {
+            /* 큐 백업 */
+            writeQueue.backupQueue();
             /* 커밋 카운트 초기화 */
             SUM_COMMIT_COUNT = 0;
             // 큐를 초기화한다.

 
     private void messageService() throws Exception {
         int DB_PROC_COUNT = 0;
+        List<BasicMessageDto> list = new ArrayList<>();
+        for (int loopCnt = 0; loopCnt < ServiceUtil.COMMIT_COUNT; loopCnt++) {
+            BasicMessageDto messageDto = readQueue.popMessageFromBuffer();
+            if (messageDto == null) {
+                break;
+            }
+            /* MSG ID 채번 */
+            String msgId = queueInstance.getSerialNumber();
+            msgId = MessageUtil.makeMessageKey(msgId);
+            String msgGroupId = msgId.replace("MSGID", "MGRP");
+            messageDto.setId(msgId);
+            messageDto.setMsgGroupID(msgGroupId);
+            list.add(messageDto);
+            DB_PROC_COUNT++;
+            SUM_COMMIT_COUNT++;
+        }
+
+        // DB 처리한 카운트에 대한 처리
+        if (DB_PROC_COUNT > 0) {
+            worker.saveMessageForList(list);
+            Thread.sleep(10);
+        } else {
+            Thread.sleep(100);
+        }
+    }
+
+    private void messageService_bak() throws Exception {
+        int DB_PROC_COUNT = 0;
         for (int loopCnt = 0; loopCnt < ServiceUtil.COMMIT_COUNT; loopCnt++) {
             BasicMessageDto messageDto = readQueue.popMessageFromBuffer();
             if (messageDto == null) {

aa4fc21

455962e

src/main/java/com/munjaon/server/server/service/ReportQueueServerService.java

--- src/main/java/com/munjaon/server/server/service/ReportQueueServerService.java

+++ src/main/java/com/munjaon/server/server/service/ReportQueueServerService.java


     private final ReportUserQueue reportUserQueue = ReportUserQueue.getInstance();
     private QueueThreadService threadService;
     private int queueMaxCore;
+    private int maxWriteCount;
 
     public ReportQueueServerService(String serviceName) {
         super(serviceName);
         this.queueMaxCore = Integer.parseInt(getProp("QUEUE_MAX_CORE").trim());
+        this.maxWriteCount = Integer.parseInt(getProp("MAX_WRITE_COUNT").trim());
     }
 
     @Override

         while (isRun()) {
             try {
                 doQueueService();
-                Thread.sleep(100);
+                Thread.sleep(10);
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }

         }
 
         for (ReportUserDto reportUserDto : reportUserList) {
+            reportUserDto.setMaxWriteCount(this.maxWriteCount);
             threadService.execute(new ReportQueueTask(reportUserDto, logger));
         }
     }

455962e

src/main/java/com/munjaon/server/server/service/ReportServer.java (added)

+++ src/main/java/com/munjaon/server/server/service/ReportServer.java

...	...	@@ -0,0 +1,191 @@
	1	+package com.munjaon.server.server.service;
	2	+
	3	+import com.munjaon.server.queue.pool.ReportQueue;
	4	+import com.munjaon.server.server.dto.ConnectUserDto;
	5	+import com.munjaon.server.server.dto.ReportUserDto;
	6	+import com.munjaon.server.server.queue.ReportUserQueue;
	7	+import org.json.simple.JSONObject;
	8	+
	9	+import java.io.File;
	10	+import java.io.IOException;
	11	+import java.net.InetSocketAddress;
	12	+import java.net.Socket;
	13	+import java.net.SocketAddress;
	14	+import java.nio.channels.SelectionKey;
	15	+import java.nio.channels.Selector;
	16	+import java.nio.channels.ServerSocketChannel;
	17	+import java.nio.channels.SocketChannel;
	18	+import java.util.ArrayList;
	19	+import java.util.Iterator;
	20	+import java.util.List;
	21	+import java.util.concurrent.Future;
	22	+
	23	+public class ReportServer extends Service {
	24	+ private final InetSocketAddress listenAddress;
	25	+ private final ReportUserQueue reportUserQueue = ReportUserQueue.getInstance();
	26	+ private Selector selector;
	27	+
	28	+ public ReportServer(String serviceName, int port) {
	29	+ super(serviceName);
	30	+ this.listenAddress = new InetSocketAddress(port);
	31	+ }
	32	+
	33	+ @Override
	34	+ public void checkReady() {
	35	+ this.IS_READY_YN = true;
	36	+ }
	37	+
	38	+ @Override
	39	+ public void initResources() {
	40	+ try {
	41	+ initReportChannel();
	42	+ } catch (IOException e) {
	43	+ saveSystemLog(e);
	44	+ throw new RuntimeException(e);
	45	+ }
	46	+ }
	47	+
	48	+ private void initReportChannel() throws IOException {
	49	+ selector = Selector.open();
	50	+ /* 채널 생성 */
	51	+ ServerSocketChannel serverChannel = ServerSocketChannel.open();
	52	+ /* non-Blocking 설정 */
	53	+ serverChannel.configureBlocking(false);
	54	+ /* 서버 ip, port 설정 */
	55	+ serverChannel.socket().bind(listenAddress);
	56	+ /* 채널에 accept 대기 설정 */
	57	+ serverChannel.register(selector, SelectionKey.OP_ACCEPT);
	58	+ }
	59	+
	60	+ private void closeReportChannel() throws IOException {
	61	+ selector.close();
	62	+ }
	63	+
	64	+ @Override
	65	+ public void releaseResources() {
	66	+ try {
	67	+ closeReportChannel();
	68	+ } catch (IOException e) {
	69	+ saveSystemLog(e);
	70	+ throw new RuntimeException(e);
	71	+ }
	72	+ }
	73	+
	74	+ @Override
	75	+ public void doService() {
	76	+
	77	+ while (isRun()) {
	78	+ try {
	79	+ execInterest();
	80	+ checkInterest();
	81	+ } catch (Exception e) {
	82	+ saveSystemLog(e.toString());
	83	+ }
	84	+ }
	85	+ }
	86	+
	87	+ private void checkInterest() throws IOException, InterruptedException {
	88	+ Iterator<SelectionKey> keys = selector.keys().iterator();
	89	+ while (keys.hasNext()) {
	90	+ SelectionKey key = keys.next();
	91	+ if (key.isValid()) {
	92	+ ReportUserDto reportUserDto = (ReportUserDto) key.attachment();
	93	+ if (reportUserDto == null) {
	94	+ continue;
	95	+ }
	96	+ SocketChannel channel = (SocketChannel) key.channel(); // 키 채널을 가져온다.
	97	+ if (reportUserDto.isAlive() == 1) { // 로그인이 완료되지 않은 경우
	98	+ expireConnectUser(key);
	99	+ } else if (reportUserDto.isAlive() == 2) {
	100	+ if (reportUserDto == null \|\| reportUserDto.isRunningMode()) {
	101	+ continue;
	102	+ }
	103	+ } else {
	104	+ ReportQueue reportQueue = reportUserDto.getReportQueue();
	105	+ if (reportUserDto.isLogin() && reportQueue != null && reportQueue.isRemainReport()) {
	106	+ if (reportUserDto.isRunningMode()) {
	107	+ continue;
	108	+ }
	109	+ /* 사용자별 Report Thread 실행 */
	110	+ }
	111	+ }
	112	+ } else {
	113	+ expireConnectUser(key);
	114	+ }
	115	+ }
	116	+ }
	117	+
	118	+ private void execInterest() throws IOException {
	119	+ if (selector.select(1000) == 0) {
	120	+ return ;
	121	+ }
	122	+ Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
	123	+ List<Future<ReportUserDto>> list = new ArrayList<>();
	124	+ while (keys.hasNext()) {
	125	+ SelectionKey key = keys.next();
	126	+ /* 키 셋에서 제거. */
	127	+ keys.remove();
	128	+
	129	+ if (key.isValid()) {
	130	+ if (key.isAcceptable()) { // 접속일 경우..
	131	+ saveSystemLog("CONNECTION IS ACCEPTABLE ... ...");
	132	+ accept(selector, key);
	133	+ } else if (key.isReadable()) { // 수신일 경우..
	134	+ ReportUserDto reportUserDto = (ReportUserDto) key.attachment();
	135	+ if (reportUserDto == null \|\| reportUserDto.isRunningMode()) {
	136	+ continue;
	137	+ }
	138	+ saveSystemLog("isReadable");
	139	+ /* 사용자별 Report Thread 실행 */
	140	+// threadService.submit(selector, key, 2);
	141	+ }
	142	+ } else {
	143	+ expireConnectUser(key);
	144	+ }
	145	+ }
	146	+ }
	147	+
	148	+ private void accept(Selector selector, SelectionKey key) {
	149	+ try {
	150	+ /* 키 채널을 가져온다. */
	151	+ ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
	152	+ /* accept을 해서 Socket 채널을 가져온다. */
	153	+ SocketChannel channel = serverChannel.accept();
	154	+ channel.configureBlocking(false);
	155	+ /* 소켓 취득 */
	156	+ Socket socket = channel.socket();
	157	+ SocketAddress remoteAddr = socket.getRemoteSocketAddress();
	158	+ saveSystemLog("Connected to: " + remoteAddr);
	159	+ // Socket 채널을 channel에 수신 등록한다
	160	+ channel.register(selector, SelectionKey.OP_READ, ReportUserDto.builder().lastTrafficTime(System.currentTimeMillis()).remoteIP(remoteAddr.toString()).queuePath(System.getProperty("ROOTPATH") + File.separator + getProp("QUEUE_PATH")).build());
	161	+ } catch (Exception e) {
	162	+ throw new RuntimeException(e);
	163	+ }
	164	+ }
	165	+
	166	+ private void expireConnectUser(SelectionKey key) {
	167	+ if (key == null \|\| !key.isValid()) {
	168	+ return;
	169	+ }
	170	+ try {
	171	+ SocketChannel channel = (SocketChannel) key.channel();
	172	+ ConnectUserDto userDto = (ConnectUserDto) key.attachment();
	173	+ if (userDto != null && userDto.getUserId() != null) {
	174	+ reportUserQueue.removeUser(userDto.getUserId());
	175	+// connectUserMap.remove(userDto.getUserId());
	176	+ key.attach(null);
	177	+ }
	178	+ // 소켓 채널 닫기
	179	+ channel.close();
	180	+ // 키 닫기
	181	+ key.cancel();
	182	+ } catch (IOException e) {
	183	+ e.printStackTrace();
	184	+ }
	185	+ }
	186	+
	187	+ @Override
	188	+ public JSONObject monitorService() {
	189	+ return null;
	190	+ }
	191	+}

aa4fc21

455962e

src/main/java/com/munjaon/server/server/service/ReportServerService.java

--- src/main/java/com/munjaon/server/server/service/ReportServerService.java

+++ src/main/java/com/munjaon/server/server/service/ReportServerService.java


     public void initResources() {
         try {
             initReportChannel();
-            threadService = new ReadThreadService(8, logger);
+            threadService = new ReadThreadService(readMaxCore, logger);
         } catch (IOException e) {
             saveSystemLog(e);
             throw new RuntimeException(e);

                         try {
                             ReportDto reportDto = reportQueue.popReportFromQueue();
                             if (reportDto == null) {
-                                saveSystemLog("reportQueue.popReportFromQueue() : null");
                                 continue;
                             }
                             saveSystemLog("reportQueue.popReportFromQueue() : " + reportDto.toString());

aa4fc21

455962e

src/main/java/com/munjaon/server/server/task/CollectReadTask.java

--- src/main/java/com/munjaon/server/server/task/CollectReadTask.java

+++ src/main/java/com/munjaon/server/server/task/CollectReadTask.java

...	...	@@ -77,6 +77,11 @@
77	77	}
78	78
79	79	private void recvDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	80	+ /* 서비스 중지여부 체크 */
	81	+ if (isExpireService()) {
	82	+ expireConnectUser();
	83	+ return;
	84	+ }
80	85	switch (this.serviceType) {
81	86	case "SMS":
82	87	recvSmsDeliver(channel, headBuffer);
...	...	@@ -95,6 +100,40 @@
95	100	break;
96	101	default:break;
97	102	}
	103	+ }
	104	+
	105	+ private boolean isExpireService() {
	106	+ ConnectUserDto checkConnectUserDto = collectUserQueue.getUser(this.serviceType, this.connectUserDto.getUserId());
	107	+ MemberDto memberDto = checkConnectUserDto.getMemberDto();
	108	+ saveSystemLog("[isExpireService : " + memberDto.toString() + "]");
	109	+ if (memberDto == null) {
	110	+ return true;
	111	+ }
	112	+ if (collectUserQueue.isExist(this.serviceType, memberDto.getMberId()) == false) {
	113	+ return true;
	114	+ }
	115	+ /* 회원 사용 상태 */
	116	+ if (memberDto.getMberSttus() == null \|\| "N".equals(memberDto.getMberSttus())) {
	117	+ return true;
	118	+ }
	119	+ /* 서비스 이용 상태 */
	120	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	121	+ return true;
	122	+ }
	123	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	124	+ return true;
	125	+ }
	126	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	127	+ return true;
	128	+ }
	129	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	130	+ return true;
	131	+ }
	132	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	133	+ return true;
	134	+ }
	135	+
	136	+ return false;
98	137	}
99	138
100	139	public BasicMessageDto recvCommonMessage(ByteBuffer deliverBuffer) {
...	...	@@ -116,6 +155,7 @@
116	155
117	156	return messageDto;
118	157	}
	158	+
119	159	private void recvSmsDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
120	160	try {
121	161	ByteBuffer bodyBuffer = ByteBuffer.allocate(SmsMessage.DELIVER_SMS_BODY_LENGTH);
...	...	@@ -126,7 +166,18 @@
126	166	// Packet.printBuffer(deliverBuffer);
127	167	BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
128	168	messageDto.setUserMessage(SmsMessage.getMessageForDeliver(deliverBuffer));
129		- System.out.println("BasicMessageDto : " + messageDto.toString());
	169	+
	170	+ /* 사용자 단가, 발송망 설정 */
	171	+ MemberDto savedMemberDto = null;
	172	+ if (this.connectUserDto != null) {
	173	+ savedMemberDto = this.connectUserDto.getMemberDto();
	174	+ }
	175	+ if (savedMemberDto != null) {
	176	+ messageDto.setRouterSeq(savedMemberDto.getSmsAgentCode());
	177	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getShortPrice()));
	178	+ }
	179	+
	180	+ saveSystemLog("[SMS] [MESSAGE : " + messageDto.toString() + "]");
130	181	QueueTypeWorker worker = QueueTypeWorker.find("SMS");
131	182	if (worker != null) {
132	183	worker.pushQueue(messageDto);
...	...	@@ -148,6 +199,17 @@
148	199	messageDto.setUserSubject(LmsMessage.getSubjectForDeliver(deliverBuffer));
149	200	messageDto.setUserMessage(LmsMessage.getMessageForDeliver(deliverBuffer));
150	201
	202	+ /* 사용자 단가, 발송망 설정 */
	203	+ MemberDto savedMemberDto = null;
	204	+ if (this.connectUserDto != null) {
	205	+ savedMemberDto = this.connectUserDto.getMemberDto();
	206	+ }
	207	+ if (savedMemberDto != null) {
	208	+ messageDto.setRouterSeq(savedMemberDto.getLmsAgentCode());
	209	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getLongPrice()));
	210	+ }
	211	+
	212	+ saveSystemLog("[LMS] [MESSAGE : " + messageDto.toString() + "]");
151	213	QueueTypeWorker worker = QueueTypeWorker.find("LMS");
152	214	if (worker != null) {
153	215	worker.pushQueue(messageDto);
...	...	@@ -173,10 +235,7 @@
173	235	if (fileCount != null && fileCount.length() > 0) {
174	236	recvFileCount = Integer.parseInt(fileCount);
175	237	messageDto.setUserFileCnt(recvFileCount);
176		- saveSystemLog("recvFileCount : " + recvFileCount);
177	238	}
178		-
179		- saveSystemLog("messageDto : " + messageDto.toString());
180	239
181	240	String imagePath = System.getProperty("ROOTPATH") + File.separator + "mmsfile";
182	241	imagePath = imagePath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
...	...	@@ -198,9 +257,28 @@
198	257	} else if (i == 2) {
199	258	messageDto.setUserFileName03(imagePath + File.separator + fileName);
200	259	}
201		- saveSystemLog("File : " + fileName + ", Size : " + fileSize);
	260	+ saveSystemLog("[MMS IMAGE] [File : " + fileName + ", Size : " + fileSize + "]");
202	261	}
203	262
	263	+ /* 사용자 단가, 발송망 설정 */
	264	+ MemberDto savedMemberDto = null;
	265	+ if (this.connectUserDto != null) {
	266	+ savedMemberDto = this.connectUserDto.getMemberDto();
	267	+ }
	268	+ if (savedMemberDto != null) {
	269	+ messageDto.setRouterSeq(savedMemberDto.getMmsAgentCode());
	270	+ float mmsPrice = 0.0F;
	271	+ if (recvFileCount == 1) {
	272	+ mmsPrice = savedMemberDto.getPicturePrice();
	273	+ } else if (recvFileCount == 2) {
	274	+ mmsPrice = savedMemberDto.getPicture2Price();
	275	+ } else {
	276	+ mmsPrice = savedMemberDto.getPicture3Price();
	277	+ }
	278	+ messageDto.setUnitCost(String.valueOf(mmsPrice));
	279	+ }
	280	+
	281	+ saveSystemLog("[MMS] [MESSAGE : " + messageDto.toString() + "]");
204	282	QueueTypeWorker worker = QueueTypeWorker.find("MMS");
205	283	if (worker != null) {
206	284	worker.pushQueue(messageDto);
...	...	@@ -224,8 +302,6 @@
224	302	messageDto.setKakaoSenderKey(KakaoMessage.getKakaoSenderKeyForDeliver(deliverBuffer));
225	303	messageDto.setKakaoTemplateCode(KakaoMessage.getKakaoTemplateCodeForDeliver(deliverBuffer));
226	304
227		- saveSystemLog("messageDto : " + messageDto.toString());
228		-
229	305	String jsonPath = System.getProperty("ROOTPATH") + File.separator + "kakaofile";
230	306	jsonPath = jsonPath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
231	307	FileUtil.mkdirs(jsonPath);
...	...	@@ -242,8 +318,19 @@
242	318	JobFileFactory.saveFileForByteBuffer(jsonPath, fileName, fileBuffer);
243	319
244	320	messageDto.setKakaoJsonFile(jsonPath + File.separator + fileName);
245		- saveSystemLog("File : " + fileName + ", Size : " + fileSize);
	321	+ saveSystemLog("[KAT JSON] [File : " + fileName + ", Size : " + fileSize + "]");
246	322
	323	+ /* 사용자 단가, 발송망 설정 */
	324	+ MemberDto savedMemberDto = null;
	325	+ if (this.connectUserDto != null) {
	326	+ savedMemberDto = this.connectUserDto.getMemberDto();
	327	+ }
	328	+ if (savedMemberDto != null) {
	329	+ messageDto.setRouterSeq(savedMemberDto.getKakaoAtAgentCode());
	330	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getKakaoAtPrice()));
	331	+ }
	332	+
	333	+ saveSystemLog("[KAKAO ALARM] [MESSAGE : " + messageDto.toString() + "]");
247	334	QueueTypeWorker worker = QueueTypeWorker.find("KAT");
248	335	if (worker != null) {
249	336	worker.pushQueue(messageDto);
...	...	@@ -269,8 +356,6 @@
269	356	messageDto.setKakaoSenderKey(KakaoMessage.getKakaoSenderKeyForDeliver(deliverBuffer));
270	357	messageDto.setKakaoTemplateCode(KakaoMessage.getKakaoTemplateCodeForDeliver(deliverBuffer));
271	358
272		- saveSystemLog("messageDto : " + messageDto.toString());
273		-
274	359	String jsonPath = System.getProperty("ROOTPATH") + File.separator + "kakaofile";
275	360	jsonPath = jsonPath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
276	361	FileUtil.mkdirs(jsonPath);
...	...	@@ -287,8 +372,19 @@
287	372	JobFileFactory.saveFileForByteBuffer(jsonPath, fileName, fileBuffer);
288	373
289	374	messageDto.setKakaoJsonFile(jsonPath + File.separator + fileName);
290		- saveSystemLog("File : " + fileName + ", Size : " + fileSize);
	375	+ saveSystemLog("[KFT JSON] [File : " + fileName + ", Size : " + fileSize + "]");
291	376
	377	+ /* 사용자 단가, 발송망 설정 */
	378	+ MemberDto savedMemberDto = null;
	379	+ if (this.connectUserDto != null) {
	380	+ savedMemberDto = this.connectUserDto.getMemberDto();
	381	+ }
	382	+ if (savedMemberDto != null) {
	383	+ messageDto.setRouterSeq(savedMemberDto.getKakaoFtAgentCode());
	384	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getKakaoFtPrice()));
	385	+ }
	386	+
	387	+ saveSystemLog("[KAKAO FRIEND] [MESSAGE : " + messageDto.toString() + "]");
292	388	QueueTypeWorker worker = QueueTypeWorker.find("KFT");
293	389	if (worker != null) {
294	390	worker.pushQueue(messageDto);
...	...	@@ -304,6 +400,11 @@
304	400	channel.read(bodyBuffer);
305	401	// SocketChannel channel = (SocketChannel) key.channel();
306	402	channel.write(LinkCheck.makeLinkCheckAckBuffer());
	403	+ /* 서비스 중지여부 체크 */
	404	+ if (isExpireService()) {
	405	+ expireConnectUser();
	406	+ return;
	407	+ }
307	408	}
308	409
309	410	private void recvBind(SocketChannel channel, ByteBuffer headBuffer) {
...	...	@@ -316,29 +417,46 @@
316	417
317	418	String id = Bind.getBindId(bindBuffer);
318	419	String pwd = Bind.getBindPwd(bindBuffer);
319		- saveSystemLog("Bind id : " + id);
320		- saveSystemLog("Bind pwd : " + pwd);
321		- if (id == null \|\| pwd == null) {
322		- resultCode = "50";
323		- } else {
324		- if (collectUserQueue.isExist(this.serviceType, id)) {
325		- resultCode = "60";
	420	+
	421	+ MemberService svc = (MemberService) CacheService.LOGIN_SERVICE.getService();
	422	+ MemberDto memberDto = null;
	423	+ if (svc != null) {
	424	+ memberDto = svc.get(id);
	425	+ }
	426	+ saveSystemLog("[BIND REQUEST] [ID : " + id + ", PWD : " + pwd + "]");
	427	+ /* Bind Check */
	428	+ resultCode = checkBind(memberDto, this.serviceType, id, pwd);
	429	+
	430	+ /* 접속 IP 체크 */
	431	+ if ("00".equals(resultCode)) {
	432	+ boolean isPermit = false;
	433	+ if (memberDto.getIpLimitYn() == null \|\| "Y".equals(memberDto.getIpLimitYn())) {
	434	+ saveSystemLog("connectUserDto.getRemoteIP() : " + connectUserDto.getRemoteIP());
	435	+ saveSystemLog("Customize Toolbar... : " + memberDto.getAllowIpBasic());
	436	+ saveSystemLog("memberDto.getAllowIpExtend() : " + memberDto.getAllowIpExtend());
	437	+ if (memberDto.getAllowIpBasic() != null && connectUserDto.getRemoteIP().equals(memberDto.getAllowIpBasic())) {
	438	+ isPermit = true;
	439	+ }
	440	+ if (memberDto.getAllowIpExtend() != null && connectUserDto.getRemoteIP().equals(memberDto.getAllowIpExtend())) {
	441	+ isPermit = true;
	442	+ }
326	443	} else {
327		- MemberService svc = (MemberService) CacheService.LOGIN_SERVICE.getService();
328		- MemberDto memberDto = null;
329		- if (svc != null) {
330		- memberDto = svc.get(id);
331		- }
332		- if (memberDto == null \|\| !pwd.equals(memberDto.getAccessKey())) {
333		- resultCode = "20";
334		- } else {
335		- connectUserDto.setUserId(id);
336		- connectUserDto.setLogin(true);
337		- connectUserDto.setMemberDto(memberDto);
338		- /* 세션통신 시간 업데이트 */
339		- connectUserDto.updateLastTrafficTime();
340		- }
	444	+ isPermit = true;
341	445	}
	446	+ if (isPermit) {
	447	+ resultCode = "00";
	448	+ } else {
	449	+ resultCode = "40";
	450	+ }
	451	+ }
	452	+ if ("00".equals(resultCode)) {
	453	+ connectUserDto.setUserId(id);
	454	+ connectUserDto.setLogin(true);
	455	+ connectUserDto.setMemberDto(memberDto);
	456	+ /* 사용자 Pool에 저장 */
	457	+ collectUserQueue.putUser(this.serviceType, connectUserDto);
	458	+ /* 세션통신 시간 업데이트 */
	459	+ connectUserDto.updateLastTrafficTime();
342	460	}
343	461	} catch (Exception e) {
344	462	resultCode = "10";
...	...	@@ -346,7 +464,7 @@
346	464	}
347	465
348	466	try {
349		- saveSystemLog("Bind ResultCode : " + resultCode);
	467	+ saveSystemLog("[BIND RESULT : " + resultCode + "]");
350	468	channel.write(Bind.makeBindAckBuffer(resultCode));
351	469	if ("00".equals(resultCode) == false) {
352	470	expireConnectUser();
...	...	@@ -356,6 +474,60 @@
356	474	}
357	475	}
358	476
	477	+ private String checkBind(MemberDto memberDto, String serviceType, String id, String pwd) {
	478	+ if (id == null \|\| pwd == null) {
	479	+ return "50";
	480	+ }
	481	+ if (collectUserQueue.isExist(this.serviceType, id)) {
	482	+ return "60";
	483	+ }
	484	+ if (memberDto == null \|\| !pwd.equals(memberDto.getAccessKey())) {
	485	+ return "20";
	486	+ }
	487	+ /* 회원 사용 상태 */
	488	+ if (memberDto.getMberSttus() == null \|\| "N".equals(memberDto.getMberSttus())) {
	489	+ return "30";
	490	+ }
	491	+ /* 서비스 이용 상태 */
	492	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	493	+ return "30";
	494	+ }
	495	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	496	+ return "30";
	497	+ }
	498	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	499	+ return "30";
	500	+ }
	501	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	502	+ return "30";
	503	+ }
	504	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	505	+ return "30";
	506	+ }
	507	+
	508	+ return "00";
	509	+ }
	510	+
	511	+ private String checkService(MemberDto memberDto, String serviceType) {
	512	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	513	+ return "30";
	514	+ }
	515	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	516	+ return "30";
	517	+ }
	518	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	519	+ return "30";
	520	+ }
	521	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	522	+ return "30";
	523	+ }
	524	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	525	+ return "30";
	526	+ }
	527	+
	528	+ return "00";
	529	+ }
	530	+
359	531	private void expireConnectUser() {
360	532	if (key == null \|\| !key.isValid()) {
361	533	return;

455962e

src/main/java/com/munjaon/server/server/task/CollectServerTask.java (added)

+++ src/main/java/com/munjaon/server/server/task/CollectServerTask.java

...	...	@@ -0,0 +1,635 @@
	1	+package com.munjaon.server.server.task;
	2	+
	3	+import com.munjaon.server.cache.dto.MemberDto;
	4	+import com.munjaon.server.cache.enums.CacheService;
	5	+import com.munjaon.server.cache.service.MemberService;
	6	+import com.munjaon.server.queue.dto.BasicMessageDto;
	7	+import com.munjaon.server.queue.enums.QueueTypeWorker;
	8	+import com.munjaon.server.server.config.ServerConfig;
	9	+import com.munjaon.server.server.dto.ConnectUserDto;
	10	+import com.munjaon.server.server.packet.*;
	11	+import com.munjaon.server.server.queue.CollectUserQueue;
	12	+import com.munjaon.server.server.service.PropertyLoader;
	13	+import com.munjaon.server.util.*;
	14	+
	15	+import java.io.File;
	16	+import java.io.IOException;
	17	+import java.nio.ByteBuffer;
	18	+import java.nio.channels.SelectionKey;
	19	+import java.nio.channels.Selector;
	20	+import java.nio.channels.SocketChannel;
	21	+import java.text.SimpleDateFormat;
	22	+import java.time.LocalDateTime;
	23	+import java.time.format.DateTimeFormatter;
	24	+
	25	+public class CollectServerTask implements Runnable {
	26	+ public static final SimpleDateFormat sdf = new SimpleDateFormat("[MM-dd HH:mm:ss]");
	27	+ public static final String LOG_DATE_FORMAT = "[MM-dd HH:mm:ss]";
	28	+
	29	+ private Selector selector;
	30	+ private SelectionKey key;
	31	+ private SocketChannel channel;
	32	+ private CollectUserQueue collectUserQueue = CollectUserQueue.getInstance();
	33	+ private ConnectUserDto connectUserDto;
	34	+ private String serviceName;
	35	+ private String serviceType;
	36	+ private final LogUtil logger;
	37	+
	38	+ private boolean IS_SERVER_RUN; // 서버가 구동중인지 여부
	39	+ private boolean IS_RUN_YN;
	40	+ private long RUN_FLAG_CHECK_TIME;
	41	+
	42	+ /* 클라이언트 요청 데이터 수신 */
	43	+
	44	+ /* 세션이 만료되었는지 체크 */
	45	+ private boolean isExpiredYn;
	46	+
	47	+ public CollectServerTask(Selector selector, SelectionKey key, String serviceName, String serviceType, LogUtil logger) {
	48	+ this.selector = selector;
	49	+ this.key = key;
	50	+ this.channel = (SocketChannel) key.channel();
	51	+ this.connectUserDto = (ConnectUserDto) key.attachment();
	52	+ this.connectUserDto.setRunningMode(true);
	53	+ this.serviceName = serviceName;
	54	+ this.serviceType = serviceType;
	55	+ this.logger = logger;
	56	+ }
	57	+
	58	+ protected String getProp(String name) {
	59	+ return getProp(this.serviceName, name);
	60	+ }
	61	+
	62	+ public static String getProp(String svc, String name) {
	63	+ return PropertyLoader.getProp(svc, name);
	64	+ }
	65	+
	66	+ private void reloadRunFlag() {
	67	+ if (System.currentTimeMillis() - RUN_FLAG_CHECK_TIME > ServerConfig.INTERVAL_PROPERTY_RELOAD_TIME) {
	68	+ this.IS_RUN_YN = getProp("RUN_FLAG") != null && "Y".equals(getProp("RUN_FLAG"));
	69	+ this.IS_SERVER_RUN = getProp("server", "run") != null && "Y".equals(getProp("server", "run"));
	70	+ RUN_FLAG_CHECK_TIME = System.currentTimeMillis();
	71	+ }
	72	+ }
	73	+
	74	+ public boolean isRun() {
	75	+ return IS_SERVER_RUN && IS_RUN_YN;
	76	+ }
	77	+
	78	+ @Override
	79	+ public void run() {
	80	+ saveSystemLog("CollectServerTask is Entered");
	81	+ /* 최초 RUN Flag 체크 */
	82	+ reloadRunFlag();
	83	+ /* BIND 체크 및 처리 */
	84	+ while (isRun()) {
	85	+ /* 만료 여부 체크 */
	86	+ if (isExpiredYn) {
	87	+ break;
	88	+ }
	89	+
	90	+ int size = -1;
	91	+ try {
	92	+ /* 1. Head 읽기 */
	93	+ ByteBuffer headBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH);
	94	+ try {
	95	+ size = channel.read(headBuffer);
	96	+ } catch (IOException e) {}
	97	+ /* 2. Body 읽기 */
	98	+ if (size > 0) {
	99	+ String command = Header.getCommand(headBuffer);
	100	+ switch (Integer.parseInt(command)) {
	101	+ case 1:
	102	+ recvBind(channel, headBuffer);
	103	+ break;
	104	+ case 3:
	105	+ recvDeliver(channel, headBuffer);
	106	+ break;
	107	+ case 7:
	108	+ recvLinkCheck(channel);
	109	+ break;
	110	+ default:
	111	+ expireConnectUser();
	112	+ break;
	113	+ }
	114	+ } else if (size == 0) {
	115	+ Thread.sleep(1);
	116	+ if (System.currentTimeMillis() - connectUserDto.getLastTrafficTime() > ServerConfig.DELIVER_EXEC_CYCLE_TIME) {
	117	+ this.isExpiredYn = true;
	118	+ }
	119	+ } else {
	120	+ expireConnectUser();
	121	+ }
	122	+
	123	+ } catch (Exception e) {
	124	+ size = -1;
	125	+ e.printStackTrace();
	126	+ }
	127	+ /* RUN Flag 체크 */
	128	+ reloadRunFlag();
	129	+ }
	130	+ /* 중요 : 사용자 Thread 실행모드 Off */
	131	+ connectUserDto.setRunningMode(false);
	132	+ saveSystemLog("CollectServerTask is Finished");
	133	+ }
	134	+
	135	+ private void recvDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	136	+ /* 서비스 중지여부 체크 */
	137	+ if (isExpireService()) {
	138	+ expireConnectUser();
	139	+ return;
	140	+ }
	141	+ switch (this.serviceType) {
	142	+ case "SMS":
	143	+ recvSmsDeliver(channel, headBuffer);
	144	+ break;
	145	+ case "LMS":
	146	+ recvLmsDeliver(channel, headBuffer);
	147	+ break;
	148	+ case "MMS":
	149	+ recvMmsDeliver(channel, headBuffer);
	150	+ break;
	151	+ case "KAT":
	152	+ recvKatDeliver(channel, headBuffer);
	153	+ break;
	154	+ case "KFT":
	155	+ recvKftDeliver(channel, headBuffer);
	156	+ break;
	157	+ default:break;
	158	+ }
	159	+ }
	160	+
	161	+ private boolean isExpireService() {
	162	+ ConnectUserDto checkConnectUserDto = collectUserQueue.getUser(this.serviceType, this.connectUserDto.getUserId());
	163	+ MemberDto memberDto = checkConnectUserDto.getMemberDto();
	164	+ saveSystemLog("[isExpireService : " + memberDto.toString() + "]");
	165	+ if (memberDto == null) {
	166	+ return true;
	167	+ }
	168	+ if (collectUserQueue.isExist(this.serviceType, memberDto.getMberId()) == false) {
	169	+ return true;
	170	+ }
	171	+ /* 회원 사용 상태 */
	172	+ if (memberDto.getMberSttus() == null \|\| "N".equals(memberDto.getMberSttus())) {
	173	+ return true;
	174	+ }
	175	+ /* 서비스 이용 상태 */
	176	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	177	+ return true;
	178	+ }
	179	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	180	+ return true;
	181	+ }
	182	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	183	+ return true;
	184	+ }
	185	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	186	+ return true;
	187	+ }
	188	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	189	+ return true;
	190	+ }
	191	+
	192	+ return false;
	193	+ }
	194	+
	195	+ public BasicMessageDto recvCommonMessage(ByteBuffer deliverBuffer) {
	196	+ if (deliverBuffer == null) {
	197	+ return null;
	198	+ }
	199	+ BasicMessageDto messageDto = new BasicMessageDto();
	200	+ messageDto.setRouterSeq("40");
	201	+ messageDto.setServiceType("4");
	202	+ messageDto.setUserId(connectUserDto.getUserId());
	203	+ messageDto.setRemoteIP(connectUserDto.getRemoteIP());
	204	+ messageDto.setSendStatus("0");
	205	+ messageDto.setUserMsgID(CommonMessage.getMessageIdForDeliver(deliverBuffer));
	206	+ messageDto.setUserSender(CommonMessage.getSenderForDeliver(deliverBuffer));
	207	+ messageDto.setUserReceiver(CommonMessage.getReceiverForDeliver(deliverBuffer));
	208	+ messageDto.setReserveDt(CommonMessage.getReserveTimeForDeliver(deliverBuffer));
	209	+ messageDto.setRequestDt(CommonMessage.getRequestTimeForDeliver(deliverBuffer));
	210	+ messageDto.setUnitCost("10.4");
	211	+
	212	+ return messageDto;
	213	+ }
	214	+
	215	+ private void recvSmsDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	216	+ try {
	217	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(SmsMessage.DELIVER_SMS_BODY_LENGTH);
	218	+ channel.read(bodyBuffer);
	219	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + SmsMessage.DELIVER_SMS_BODY_LENGTH);
	220	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	221	+
	222	+// Packet.printBuffer(deliverBuffer);
	223	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	224	+ messageDto.setUserMessage(SmsMessage.getMessageForDeliver(deliverBuffer));
	225	+
	226	+ /* 사용자 단가, 발송망 설정 */
	227	+ MemberDto savedMemberDto = null;
	228	+ if (this.connectUserDto != null) {
	229	+ savedMemberDto = this.connectUserDto.getMemberDto();
	230	+ }
	231	+ if (savedMemberDto != null) {
	232	+ messageDto.setRouterSeq(savedMemberDto.getSmsAgentCode());
	233	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getShortPrice()));
	234	+ }
	235	+
	236	+ saveLog("[SMS] [MESSAGE : " + messageDto.toString() + "]");
	237	+ QueueTypeWorker worker = QueueTypeWorker.find("SMS");
	238	+ if (worker != null) {
	239	+ worker.pushQueue(messageDto);
	240	+ channel.write(SmsMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	241	+ connectUserDto.updateLastTrafficTime();
	242	+ }
	243	+ } catch (Exception e) {
	244	+ e.printStackTrace();
	245	+ }
	246	+ }
	247	+
	248	+ private void recvLmsDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	249	+ try {
	250	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(LmsMessage.DELIVER_LMS_BODY_LENGTH);
	251	+ channel.read(bodyBuffer);
	252	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + LmsMessage.DELIVER_LMS_BODY_LENGTH);
	253	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	254	+
	255	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	256	+ messageDto.setUserSubject(LmsMessage.getSubjectForDeliver(deliverBuffer));
	257	+ messageDto.setUserMessage(LmsMessage.getMessageForDeliver(deliverBuffer));
	258	+
	259	+ /* 사용자 단가, 발송망 설정 */
	260	+ MemberDto savedMemberDto = null;
	261	+ if (this.connectUserDto != null) {
	262	+ savedMemberDto = this.connectUserDto.getMemberDto();
	263	+ }
	264	+ if (savedMemberDto != null) {
	265	+ messageDto.setRouterSeq(savedMemberDto.getLmsAgentCode());
	266	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getLongPrice()));
	267	+ }
	268	+
	269	+ saveSystemLog("[LMS] [MESSAGE : " + messageDto.toString() + "]");
	270	+ QueueTypeWorker worker = QueueTypeWorker.find("LMS");
	271	+ if (worker != null) {
	272	+ worker.pushQueue(messageDto);
	273	+ channel.write(LmsMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	274	+ connectUserDto.updateLastTrafficTime();
	275	+ }
	276	+ } catch (Exception e) {
	277	+ e.printStackTrace();
	278	+ }
	279	+ }
	280	+
	281	+ private void recvMmsDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	282	+ try {
	283	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(MmsMessage.DELIVER_MMS_BODY_LENGTH);
	284	+ channel.read(bodyBuffer);
	285	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + MmsMessage.DELIVER_MMS_BODY_LENGTH);
	286	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	287	+
	288	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	289	+ messageDto.setUserSubject(MmsMessage.getSubjectForDeliver(deliverBuffer));
	290	+ messageDto.setUserMessage(MmsMessage.getMessageForDeliver(deliverBuffer));
	291	+ String fileCount = MessageUtil.doNumber(MmsMessage.getFileCountForDeliver(deliverBuffer));
	292	+ int recvFileCount = 0;
	293	+ if (fileCount != null && fileCount.length() > 0) {
	294	+ recvFileCount = Integer.parseInt(fileCount);
	295	+ messageDto.setUserFileCnt(recvFileCount);
	296	+ }
	297	+
	298	+ String imagePath = System.getProperty("ROOTPATH") + File.separator + "mmsfile";
	299	+ imagePath = imagePath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
	300	+ FileUtil.mkdirs(imagePath);
	301	+
	302	+ for (int i = 0; i < recvFileCount; i++) {
	303	+ ByteBuffer fileHeadBuffer = ByteBuffer.allocate(MmsMessage.DELIVER_MMS_FILENAME_LENGTH + MmsMessage.DELIVER_MMS_FILESIZE_LENGTH);
	304	+ channel.read(fileHeadBuffer);
	305	+ String fileName = MmsMessage.getFileNameForDeliver(fileHeadBuffer);
	306	+ String fileSize = MmsMessage.getFileSizeForDeliver(fileHeadBuffer);
	307	+ ByteBuffer fileBuffer = ByteBuffer.allocate(Integer.parseInt(fileSize));
	308	+ channel.read(fileBuffer);
	309	+ fileBuffer.flip();
	310	+ JobFileFactory.saveFileForByteBuffer(imagePath, fileName, fileBuffer);
	311	+ if (i == 0) {
	312	+ messageDto.setUserFileName01(imagePath + File.separator + fileName);
	313	+ } else if (i == 1) {
	314	+ messageDto.setUserFileName02(imagePath + File.separator + fileName);
	315	+ } else if (i == 2) {
	316	+ messageDto.setUserFileName03(imagePath + File.separator + fileName);
	317	+ }
	318	+ saveSystemLog("[MMS IMAGE] [File : " + fileName + ", Size : " + fileSize + "]");
	319	+ }
	320	+
	321	+ /* 사용자 단가, 발송망 설정 */
	322	+ MemberDto savedMemberDto = null;
	323	+ if (this.connectUserDto != null) {
	324	+ savedMemberDto = this.connectUserDto.getMemberDto();
	325	+ }
	326	+ if (savedMemberDto != null) {
	327	+ messageDto.setRouterSeq(savedMemberDto.getMmsAgentCode());
	328	+ float mmsPrice = 0.0F;
	329	+ if (recvFileCount == 1) {
	330	+ mmsPrice = savedMemberDto.getPicturePrice();
	331	+ } else if (recvFileCount == 2) {
	332	+ mmsPrice = savedMemberDto.getPicture2Price();
	333	+ } else {
	334	+ mmsPrice = savedMemberDto.getPicture3Price();
	335	+ }
	336	+ messageDto.setUnitCost(String.valueOf(mmsPrice));
	337	+ }
	338	+
	339	+ saveSystemLog("[MMS] [MESSAGE : " + messageDto.toString() + "]");
	340	+ QueueTypeWorker worker = QueueTypeWorker.find("MMS");
	341	+ if (worker != null) {
	342	+ worker.pushQueue(messageDto);
	343	+ channel.write(MmsMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	344	+ connectUserDto.updateLastTrafficTime();
	345	+ }
	346	+ } catch (Exception e) {
	347	+ e.printStackTrace();
	348	+ }
	349	+ }
	350	+
	351	+ private void recvKatDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	352	+ try {
	353	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	354	+ channel.read(bodyBuffer);
	355	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	356	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	357	+
	358	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	359	+ messageDto.setUserSubject(KakaoMessage.getSubjectForDeliver(deliverBuffer));
	360	+ messageDto.setUserMessage(KakaoMessage.getMessageForDeliver(deliverBuffer));
	361	+ messageDto.setKakaoSenderKey(KakaoMessage.getKakaoSenderKeyForDeliver(deliverBuffer));
	362	+ messageDto.setKakaoTemplateCode(KakaoMessage.getKakaoTemplateCodeForDeliver(deliverBuffer));
	363	+
	364	+ String jsonPath = System.getProperty("ROOTPATH") + File.separator + "kakaofile";
	365	+ jsonPath = jsonPath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
	366	+ FileUtil.mkdirs(jsonPath);
	367	+
	368	+ ByteBuffer fileHeadBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_JSON_FILENAME_LENGTH + KakaoMessage.DELIVER_JSON_FILESIZE_LENGTH);
	369	+ channel.read(fileHeadBuffer);
	370	+
	371	+ String fileName = KakaoMessage.getFileNameForDeliver(fileHeadBuffer);
	372	+ String fileSize = KakaoMessage.getFileSizeForDeliver(fileHeadBuffer);
	373	+
	374	+ ByteBuffer fileBuffer = ByteBuffer.allocate(Integer.parseInt(fileSize));
	375	+ channel.read(fileBuffer);
	376	+ fileBuffer.flip();
	377	+ JobFileFactory.saveFileForByteBuffer(jsonPath, fileName, fileBuffer);
	378	+
	379	+ messageDto.setKakaoJsonFile(jsonPath + File.separator + fileName);
	380	+ saveSystemLog("[KAT JSON] [File : " + fileName + ", Size : " + fileSize + "]");
	381	+
	382	+ /* 사용자 단가, 발송망 설정 */
	383	+ MemberDto savedMemberDto = null;
	384	+ if (this.connectUserDto != null) {
	385	+ savedMemberDto = this.connectUserDto.getMemberDto();
	386	+ }
	387	+ if (savedMemberDto != null) {
	388	+ messageDto.setRouterSeq(savedMemberDto.getKakaoAtAgentCode());
	389	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getKakaoAtPrice()));
	390	+ }
	391	+
	392	+ saveSystemLog("[KAKAO ALARM] [MESSAGE : " + messageDto.toString() + "]");
	393	+ QueueTypeWorker worker = QueueTypeWorker.find("KAT");
	394	+ if (worker != null) {
	395	+ worker.pushQueue(messageDto);
	396	+ channel.write(KakaoMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	397	+ connectUserDto.updateLastTrafficTime();
	398	+ } else {
	399	+ saveSystemLog("worker is null");
	400	+ }
	401	+ } catch (Exception e) {
	402	+ e.printStackTrace();
	403	+ }
	404	+ }
	405	+
	406	+ private void recvKftDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	407	+ try {
	408	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	409	+ channel.read(bodyBuffer);
	410	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	411	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	412	+
	413	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	414	+ messageDto.setUserSubject(KakaoMessage.getSubjectForDeliver(deliverBuffer));
	415	+ messageDto.setUserMessage(KakaoMessage.getMessageForDeliver(deliverBuffer));
	416	+ messageDto.setKakaoSenderKey(KakaoMessage.getKakaoSenderKeyForDeliver(deliverBuffer));
	417	+ messageDto.setKakaoTemplateCode(KakaoMessage.getKakaoTemplateCodeForDeliver(deliverBuffer));
	418	+
	419	+ String jsonPath = System.getProperty("ROOTPATH") + File.separator + "kakaofile";
	420	+ jsonPath = jsonPath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
	421	+ FileUtil.mkdirs(jsonPath);
	422	+
	423	+ ByteBuffer fileHeadBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_JSON_FILENAME_LENGTH + KakaoMessage.DELIVER_JSON_FILESIZE_LENGTH);
	424	+ channel.read(fileHeadBuffer);
	425	+
	426	+ String fileName = KakaoMessage.getFileNameForDeliver(fileHeadBuffer);
	427	+ String fileSize = KakaoMessage.getFileSizeForDeliver(fileHeadBuffer);
	428	+
	429	+ ByteBuffer fileBuffer = ByteBuffer.allocate(Integer.parseInt(fileSize));
	430	+ channel.read(fileBuffer);
	431	+ fileBuffer.flip();
	432	+ JobFileFactory.saveFileForByteBuffer(jsonPath, fileName, fileBuffer);
	433	+
	434	+ messageDto.setKakaoJsonFile(jsonPath + File.separator + fileName);
	435	+ saveSystemLog("[KFT JSON] [File : " + fileName + ", Size : " + fileSize + "]");
	436	+
	437	+ /* 사용자 단가, 발송망 설정 */
	438	+ MemberDto savedMemberDto = null;
	439	+ if (this.connectUserDto != null) {
	440	+ savedMemberDto = this.connectUserDto.getMemberDto();
	441	+ }
	442	+ if (savedMemberDto != null) {
	443	+ messageDto.setRouterSeq(savedMemberDto.getKakaoFtAgentCode());
	444	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getKakaoFtPrice()));
	445	+ }
	446	+
	447	+ saveSystemLog("[KAKAO FRIEND] [MESSAGE : " + messageDto.toString() + "]");
	448	+ QueueTypeWorker worker = QueueTypeWorker.find("KFT");
	449	+ if (worker != null) {
	450	+ worker.pushQueue(messageDto);
	451	+ channel.write(KakaoMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	452	+ connectUserDto.updateLastTrafficTime();
	453	+ }
	454	+ } catch (Exception e) {
	455	+ e.printStackTrace();
	456	+ }
	457	+ }
	458	+
	459	+ private void recvLinkCheck(SocketChannel channel) throws IOException {
	460	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(LinkCheck.LINK_CHECK_ACK_BODY_LENGTH);
	461	+ channel.read(bodyBuffer);
	462	+// SocketChannel channel = (SocketChannel) key.channel();
	463	+ channel.write(LinkCheck.makeLinkCheckAckBuffer());
	464	+ connectUserDto.updateLastTrafficTime();
	465	+ /* 서비스 중지여부 체크 */
	466	+ if (isExpireService()) {
	467	+ expireConnectUser();
	468	+ return;
	469	+ }
	470	+ }
	471	+
	472	+ private void recvBind(SocketChannel channel, ByteBuffer headBuffer) {
	473	+ String resultCode = "00";
	474	+ try {
	475	+ ByteBuffer bindBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + Bind.BIND_BODY_LENGTH);
	476	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(Bind.BIND_BODY_LENGTH);
	477	+ channel.read(bodyBuffer);
	478	+ Packet.mergeBuffers(bindBuffer, headBuffer, bodyBuffer);
	479	+
	480	+ String id = Bind.getBindId(bindBuffer);
	481	+ String pwd = Bind.getBindPwd(bindBuffer);
	482	+
	483	+ MemberService svc = (MemberService) CacheService.LOGIN_SERVICE.getService();
	484	+ MemberDto memberDto = null;
	485	+ if (svc != null) {
	486	+ memberDto = svc.get(id);
	487	+ }
	488	+ saveSystemLog("[BIND REQUEST] [ID : " + id + ", PWD : " + pwd + "]");
	489	+ /* Bind Check */
	490	+ resultCode = checkBind(memberDto, this.serviceType, id, pwd);
	491	+
	492	+ /* 접속 IP 체크 */
	493	+ if ("00".equals(resultCode)) {
	494	+ boolean isPermit = false;
	495	+ if (memberDto.getIpLimitYn() == null \|\| "Y".equals(memberDto.getIpLimitYn())) {
	496	+ saveSystemLog("connectUserDto.getRemoteIP() : " + connectUserDto.getRemoteIP());
	497	+ saveSystemLog("Customize Toolbar... : " + memberDto.getAllowIpBasic());
	498	+ saveSystemLog("memberDto.getAllowIpExtend() : " + memberDto.getAllowIpExtend());
	499	+ if (memberDto.getAllowIpBasic() != null && connectUserDto.getRemoteIP().equals(memberDto.getAllowIpBasic())) {
	500	+ isPermit = true;
	501	+ }
	502	+ if (memberDto.getAllowIpExtend() != null && connectUserDto.getRemoteIP().equals(memberDto.getAllowIpExtend())) {
	503	+ isPermit = true;
	504	+ }
	505	+ } else {
	506	+ isPermit = true;
	507	+ }
	508	+ if (isPermit) {
	509	+ resultCode = "00";
	510	+ } else {
	511	+ resultCode = "40";
	512	+ }
	513	+ }
	514	+ if ("00".equals(resultCode)) {
	515	+ connectUserDto.setUserId(id);
	516	+ connectUserDto.setLogin(true);
	517	+ connectUserDto.setMemberDto(memberDto);
	518	+ /* 사용자 Pool에 저장 */
	519	+ collectUserQueue.putUser(this.serviceType, connectUserDto);
	520	+ /* 세션통신 시간 업데이트 */
	521	+ connectUserDto.updateLastTrafficTime();
	522	+ }
	523	+ } catch (Exception e) {
	524	+ resultCode = "10";
	525	+ e.printStackTrace();
	526	+ }
	527	+
	528	+ try {
	529	+ saveSystemLog("[BIND RESULT : " + resultCode + "]");
	530	+ channel.write(Bind.makeBindAckBuffer(resultCode));
	531	+ if ("00".equals(resultCode) == false) {
	532	+ expireConnectUser();
	533	+ }
	534	+ } catch (IOException e) {
	535	+ e.printStackTrace();
	536	+ }
	537	+ }
	538	+
	539	+ private String checkBind(MemberDto memberDto, String serviceType, String id, String pwd) {
	540	+ if (id == null \|\| pwd == null) {
	541	+ return "50";
	542	+ }
	543	+ if (collectUserQueue.isExist(this.serviceType, id)) {
	544	+ return "60";
	545	+ }
	546	+ if (memberDto == null \|\| !pwd.equals(memberDto.getAccessKey())) {
	547	+ return "20";
	548	+ }
	549	+ /* 회원 사용 상태 */
	550	+ if (memberDto.getMberSttus() == null \|\| "N".equals(memberDto.getMberSttus())) {
	551	+ return "30";
	552	+ }
	553	+ /* 서비스 이용 상태 */
	554	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	555	+ return "30";
	556	+ }
	557	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	558	+ return "30";
	559	+ }
	560	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	561	+ return "30";
	562	+ }
	563	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	564	+ return "30";
	565	+ }
	566	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	567	+ return "30";
	568	+ }
	569	+
	570	+ return "00";
	571	+ }
	572	+
	573	+ private String checkService(MemberDto memberDto, String serviceType) {
	574	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	575	+ return "30";
	576	+ }
	577	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	578	+ return "30";
	579	+ }
	580	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	581	+ return "30";
	582	+ }
	583	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	584	+ return "30";
	585	+ }
	586	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	587	+ return "30";
	588	+ }
	589	+
	590	+ return "00";
	591	+ }
	592	+
	593	+ private void expireConnectUser() {
	594	+ if (key == null \|\| !key.isValid()) {
	595	+ return;
	596	+ }
	597	+ try {
	598	+ SocketChannel channel = (SocketChannel) key.channel();
	599	+ if (connectUserDto != null) {
	600	+ if (connectUserDto.getUserId() != null) {
	601	+ collectUserQueue.removeUser(connectUserDto.getServiceType(), connectUserDto.getUserId());
	602	+ }
	603	+ key.attach(null);
	604	+ }
	605	+ /* 세션 만료 여부 */
	606	+ this.isExpiredYn = true;
	607	+ // 소켓 채널 닫기
	608	+ channel.close();
	609	+ // 키 닫기
	610	+ key.cancel();
	611	+ } catch (IOException e) {
	612	+ e.printStackTrace();
	613	+ }
	614	+ }
	615	+
	616	+ private void saveSystemLog(Object obj) {
	617	+ saveLog(obj, true);
	618	+ }
	619	+
	620	+ private void saveLog(Object obj) {
	621	+ saveLog(obj, false);
	622	+ }
	623	+
	624	+ private void saveLog(Object obj, boolean isConsoleOutput) {
	625	+ if (isConsoleOutput) {
	626	+ System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern(LOG_DATE_FORMAT)) + " {{COLLECT_READ_TASK}} " + obj);
	627	+ }
	628	+
	629	+ if (logger == null) {
	630	+ return;
	631	+ }
	632	+
	633	+ logger.log(obj);
	634	+ }
	635	+}

aa4fc21

455962e

src/main/java/com/munjaon/server/server/task/ReportQueueTask.java

--- src/main/java/com/munjaon/server/server/task/ReportQueueTask.java

+++ src/main/java/com/munjaon/server/server/task/ReportQueueTask.java


         }
 
         ReportQueue reportQueue = reportUserDto.getReportQueue();
+        /* 리포트큐에 최대 크기까지 쓰고 모두 리포트는 전송했는지 체크 : 테스트후 적용 */
+//        if (reportQueue.isWriteLimit(reportUserDto.getMaxWriteCount())) {
+//            if (reportQueue.isTruncateQueue(reportUserDto.getMaxWriteCount())) {
+//                try {
+//                    reportQueue.truncateQueue();
+//                } catch (Exception e) {}
+//            } else {
+//                return;
+//            }
+//        }
         ReportService reportService = (ReportService) CacheService.REPORT_SERVICE.getService();
         List<ReportDto> list = reportService.getReportListForUser(reportUserDto.getUserId());
         if (list == null || list.isEmpty()) {

aa4fc21

455962e

src/main/java/com/munjaon/server/server/task/ReportReadTask.java

--- src/main/java/com/munjaon/server/server/task/ReportReadTask.java

+++ src/main/java/com/munjaon/server/server/task/ReportReadTask.java


     private void recvReport(SocketChannel channel, ByteBuffer headBuffer) {
         try {
             ByteBuffer bodyBuffer = ByteBuffer.allocate(Report.REPORT_ACK_BODY_LENGTH);
-            saveSystemLog("recv report");
             int size = channel.read(bodyBuffer);
-            if (size > 0) {
-                ReportQueue reportQueue = reportUserDto.getReportQueue();
-                reportUserDto.updateLastTrafficTime();
-                if (reportQueue != null) {
-                    reportQueue.addReadCounter();
-                }
+            if (size != Report.REPORT_ACK_BODY_LENGTH) {
+                return;
+            }
+
+            saveSystemLog("recv report");
+            ReportQueue reportQueue = reportUserDto.getReportQueue();
+            reportUserDto.updateLastTrafficTime();
+            if (reportQueue != null) {
+                reportQueue.addReadCounter();
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
+    private String checkBind(MemberDto memberDto, String id, String pwd) {
+        if (id == null || pwd == null) {
+            return "50";
+        }
+        if (reportUserQueue.isExist(id)) {
+            return "60";
+        }
+        if (memberDto == null || !pwd.equals(memberDto.getAccessKey())) {
+            return "20";
+        }
+        /* 회원 사용 상태 */
+        if (memberDto.getMberSttus() == null || "N".equals(memberDto.getMberSttus())) {
+            return "30";
+        }
+
+        return "00";
+    }
+
     private void recvBind(SocketChannel channel, ByteBuffer headBuffer) {
         String resultCode = "00";
         try {

 
             String id = Bind.getBindId(bindBuffer);
             String pwd = Bind.getBindPwd(bindBuffer);
+
+            MemberService svc = (MemberService) CacheService.LOGIN_SERVICE.getService();
+            MemberDto memberDto = null;
+            if (svc != null) {
+                memberDto = svc.get(id);
+            }
+            saveSystemLog("[BIND REQUEST] [ID : " + id + ", PWD : " +  pwd + "]");
+            /* Bind Check */
+            resultCode = checkBind(memberDto, id, pwd);
+
+            /* 접속 IP 체크 */
+            if ("00".equals(resultCode)) {
+                boolean isPermit = false;
+                if (memberDto.getIpLimitYn() == null || "Y".equals(memberDto.getIpLimitYn())) {
+                    saveSystemLog("connectUserDto.getRemoteIP() : " + reportUserDto.getRemoteIP());
+                    saveSystemLog("Customize Toolbar... : " + memberDto.getAllowIpBasic());
+                    saveSystemLog("memberDto.getAllowIpExtend() : " + memberDto.getAllowIpExtend());
+                    if (memberDto.getAllowIpBasic() != null && reportUserDto.getRemoteIP().equals(memberDto.getAllowIpBasic())) {
+                        isPermit = true;
+                    }
+                    if (memberDto.getAllowIpExtend() != null && reportUserDto.getRemoteIP().equals(memberDto.getAllowIpExtend())) {
+                        isPermit = true;
+                    }
+                } else {
+                    isPermit = true;
+                }
+                if (isPermit) {
+                    resultCode = "00";
+                } else {
+                    resultCode = "40";
+                }
+            }
+
+            if ("00".equals(resultCode)) {
+                reportUserDto.setUserId(id);
+                reportUserDto.setLogin(true);
+                reportUserDto.setMemberDto(memberDto);
+                /* 리포트 큐 생성 */
+                ReportQueue reportQueue = new ReportQueue(reportUserDto.getQueuePath(), reportUserDto.getUserId());
+                reportUserDto.setReportQueue(reportQueue);
+                /* 사용자 Pool에 저장 */
+                reportUserQueue.putUser(reportUserDto);
+                /* 세션통신 시간 업데이트 */
+                reportUserDto.updateLastTrafficTime();
+            }
+        } catch (Exception e) {
+            resultCode = "10";
+            e.printStackTrace();
+        }
+
+        try {
+            saveSystemLog("Bind ResultCode : " + resultCode);
+            channel.write(Bind.makeBindAckBuffer(resultCode));
+            if ("00".equals(resultCode) == false) {
+                expireConnectUser();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void recvBind_bak(SocketChannel channel, ByteBuffer headBuffer) {
+        String resultCode = "00";
+        try {
+            ByteBuffer bindBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + Bind.BIND_BODY_LENGTH);
+            ByteBuffer bodyBuffer = ByteBuffer.allocate(Bind.BIND_BODY_LENGTH);
+            channel.read(bodyBuffer);
+            Packet.mergeBuffers(bindBuffer, headBuffer, bodyBuffer);
+
+            String id = Bind.getBindId(bindBuffer);
+            String pwd = Bind.getBindPwd(bindBuffer);
             saveSystemLog("Bind id : " + id);
             saveSystemLog("Bind pwd : " + pwd);
             if (id == null || pwd == null) {

455962e

src/main/java/com/munjaon/server/server/task/ReportServerTask.java (added)

+++ src/main/java/com/munjaon/server/server/task/ReportServerTask.java

...	...	@@ -0,0 +1,219 @@
	1	+package com.munjaon.server.server.task;
	2	+
	3	+import com.munjaon.server.queue.pool.ReportQueue;
	4	+import com.munjaon.server.server.config.ServerConfig;
	5	+import com.munjaon.server.server.dto.ReportDto;
	6	+import com.munjaon.server.server.dto.ReportUserDto;
	7	+import com.munjaon.server.server.packet.Header;
	8	+import com.munjaon.server.server.packet.LinkCheck;
	9	+import com.munjaon.server.server.packet.Packet;
	10	+import com.munjaon.server.server.packet.Report;
	11	+import com.munjaon.server.server.queue.ReportUserQueue;
	12	+import com.munjaon.server.server.service.PropertyLoader;
	13	+import com.munjaon.server.util.LogUtil;
	14	+
	15	+import java.io.IOException;
	16	+import java.nio.ByteBuffer;
	17	+import java.nio.channels.SelectionKey;
	18	+import java.nio.channels.Selector;
	19	+import java.nio.channels.SocketChannel;
	20	+import java.text.SimpleDateFormat;
	21	+import java.time.LocalDateTime;
	22	+import java.time.format.DateTimeFormatter;
	23	+
	24	+public class ReportServerTask implements Runnable {
	25	+ public static final SimpleDateFormat sdf = new SimpleDateFormat("[MM-dd HH:mm:ss]");
	26	+ public static final String LOG_DATE_FORMAT = "[MM-dd HH:mm:ss]";
	27	+
	28	+ private Selector selector;
	29	+ private SelectionKey key;
	30	+ private SocketChannel channel;
	31	+ private final ReportUserQueue reportUserQueue = ReportUserQueue.getInstance();
	32	+ private ReportUserDto reportUserDto;
	33	+ private ReportQueue reportQueue;
	34	+ private String serviceName;
	35	+ private final LogUtil logger;
	36	+
	37	+ private boolean IS_SERVER_RUN; // 서버가 구동중인지 여부
	38	+ private boolean IS_RUN_YN;
	39	+ private long RUN_FLAG_CHECK_TIME;
	40	+
	41	+ /* 세션이 만료되었는지 체크 */
	42	+ private boolean isExpiredYn;
	43	+ /* Packet을 전송했는지 여부 */
	44	+ private boolean isPacketSendYn;
	45	+
	46	+ public ReportServerTask(Selector selector, SelectionKey key, String serviceName, LogUtil logger) {
	47	+ this.selector = selector;
	48	+ this.key = key;
	49	+ this.channel = (SocketChannel) key.channel();
	50	+ this.reportUserDto = (ReportUserDto) key.attachment();
	51	+ this.reportUserDto.setRunningMode(true);
	52	+ this.serviceName = serviceName;
	53	+ this.reportQueue = reportUserDto.getReportQueue();
	54	+ this.logger = logger;
	55	+ }
	56	+
	57	+ protected String getProp(String name) {
	58	+ return getProp(this.serviceName, name);
	59	+ }
	60	+
	61	+ public static String getProp(String svc, String name) {
	62	+ return PropertyLoader.getProp(svc, name);
	63	+ }
	64	+
	65	+ private void reloadRunFlag() {
	66	+ if (System.currentTimeMillis() - RUN_FLAG_CHECK_TIME > ServerConfig.INTERVAL_PROPERTY_RELOAD_TIME) {
	67	+ this.IS_RUN_YN = getProp("RUN_FLAG") != null && "Y".equals(getProp("RUN_FLAG"));
	68	+ this.IS_SERVER_RUN = getProp("server", "run") != null && "Y".equals(getProp("server", "run"));
	69	+ RUN_FLAG_CHECK_TIME = System.currentTimeMillis();
	70	+ }
	71	+ }
	72	+
	73	+ public boolean isRun() {
	74	+ return IS_SERVER_RUN && IS_RUN_YN;
	75	+ }
	76	+
	77	+ @Override
	78	+ public void run() {
	79	+ saveSystemLog("ReportServerTask is Entered");
	80	+ /* 최초 RUN Flag 체크 */
	81	+ reloadRunFlag();
	82	+ /* BIND 체크 및 처리 */
	83	+ while (isRun()) {
	84	+ /* 만료 여부 체크 */
	85	+ if (isExpiredYn) {
	86	+ break;
	87	+ }
	88	+
	89	+ try {
	90	+ sendInterest();
	91	+ /* RUN Flag 체크 */
	92	+ reloadRunFlag();
	93	+ } catch (Exception e) {
	94	+ this.isExpiredYn = true;
	95	+ e.printStackTrace();
	96	+ }
	97	+ }
	98	+ /* 중요 : 사용자 Thread 실행모드 Off */
	99	+ reportUserDto.setRunningMode(false);
	100	+ saveSystemLog("ReportServerTask is Finished");
	101	+ }
	102	+
	103	+// private void recvInterest() {
	104	+// while (isPacketSendYn) {
	105	+//
	106	+// }
	107	+// int size = -1;
	108	+// try {
	109	+// /* 1. Head 읽기 */
	110	+// ByteBuffer headBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH);
	111	+// try {
	112	+// size = channel.read(headBuffer);
	113	+// } catch (IOException e) {}
	114	+// /* 2. Body 읽기 */
	115	+// if (size > 0) {
	116	+// String command = Header.getCommand(headBuffer);
	117	+// switch (Integer.parseInt(command)) {
	118	+// case 1:
	119	+// recvBind(channel, headBuffer);
	120	+// break;
	121	+// case 3:
	122	+// recvDeliver(channel, headBuffer);
	123	+// break;
	124	+// case 7:
	125	+// recvLinkCheck(channel);
	126	+// break;
	127	+// default:
	128	+// expireConnectUser();
	129	+// break;
	130	+// }
	131	+// } else if (size == 0) {
	132	+// Thread.sleep(1);
	133	+// if (System.currentTimeMillis() - reportUserDto.getLastTrafficTime() > ServerConfig.REPORT_EXEC_CYCLE_TIME) {
	134	+// this.isExpiredYn = true;
	135	+// }
	136	+// } else {
	137	+// expireConnectUser();
	138	+// }
	139	+// } catch (Exception e) {
	140	+// size = -1;
	141	+// e.printStackTrace();
	142	+// }
	143	+// }
	144	+
	145	+ private void sendInterest() throws IOException {
	146	+ if (reportUserDto.isLogin() == false) {
	147	+ return;
	148	+ }
	149	+ if (reportUserDto.isAlive() == 1) {
	150	+ expireConnectUser();
	151	+ } else if (reportUserDto.isAlive() == 2) {
	152	+ channel.write(LinkCheck.makeLinkCheckBuffer());
	153	+ /* Packet을 전송했는지 여부 */
	154	+ isPacketSendYn = true;
	155	+ } else {
	156	+ if (this.reportQueue != null && this.reportQueue.isRemainReport()) {
	157	+ try {
	158	+ ReportDto reportDto = this.reportQueue.popReportFromQueue();
	159	+ if (reportDto == null) {
	160	+ return;
	161	+ }
	162	+ saveSystemLog("[REPORT : " + reportDto.toString() + "]");
	163	+ ByteBuffer reportBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + Report.REPORT_BODY_LENGTH);
	164	+ Packet.setDefaultByte(reportBuffer);
	165	+ Header.putHeader(reportBuffer, Header.COMMAND_REPORT, Report.REPORT_BODY_LENGTH);
	166	+ Report.putReport(reportBuffer, reportDto);
	167	+ channel.write(reportBuffer);
	168	+ /* Packet을 전송했는지 여부 */
	169	+ isPacketSendYn = true;
	170	+ } catch (Exception e) {
	171	+ e.printStackTrace();
	172	+ }
	173	+ }
	174	+ }
	175	+ }
	176	+
	177	+ private void expireConnectUser() {
	178	+ if (key == null \|\| !key.isValid()) {
	179	+ return;
	180	+ }
	181	+ try {
	182	+ SocketChannel channel = (SocketChannel) key.channel();
	183	+ if (reportUserDto != null) {
	184	+ if (reportUserDto.getUserId() != null) {
	185	+ reportUserQueue.removeUser(reportUserDto.getUserId());
	186	+ }
	187	+ key.attach(null);
	188	+ }
	189	+ /* 세션 만료 여부 */
	190	+ this.isExpiredYn = true;
	191	+ // 소켓 채널 닫기
	192	+ channel.close();
	193	+ // 키 닫기
	194	+ key.cancel();
	195	+ } catch (IOException e) {
	196	+ e.printStackTrace();
	197	+ }
	198	+ }
	199	+
	200	+ private void saveSystemLog(Object obj) {
	201	+ saveLog(obj, true);
	202	+ }
	203	+
	204	+ private void saveLog(Object obj) {
	205	+ saveLog(obj, false);
	206	+ }
	207	+
	208	+ private void saveLog(Object obj, boolean isConsoleOutput) {
	209	+ if (isConsoleOutput) {
	210	+ System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern(LOG_DATE_FORMAT)) + " {{COLLECT_READ_TASK}} " + obj);
	211	+ }
	212	+
	213	+ if (logger == null) {
	214	+ return;
	215	+ }
	216	+
	217	+ logger.log(obj);
	218	+ }
	219	+}

455962e

src/main/java/com/munjaon/server/server/task/SendReadTask.java (added)

+++ src/main/java/com/munjaon/server/server/task/SendReadTask.java

...	...	@@ -0,0 +1,564 @@
	1	+package com.munjaon.server.server.task;
	2	+
	3	+import com.munjaon.server.cache.dto.MemberDto;
	4	+import com.munjaon.server.cache.enums.CacheService;
	5	+import com.munjaon.server.cache.service.MemberService;
	6	+import com.munjaon.server.queue.dto.BasicMessageDto;
	7	+import com.munjaon.server.queue.enums.QueueTypeWorker;
	8	+import com.munjaon.server.server.dto.ConnectUserDto;
	9	+import com.munjaon.server.server.packet.*;
	10	+import com.munjaon.server.server.queue.CollectUserQueue;
	11	+import com.munjaon.server.util.*;
	12	+
	13	+import java.io.File;
	14	+import java.io.IOException;
	15	+import java.nio.ByteBuffer;
	16	+import java.nio.channels.SelectionKey;
	17	+import java.nio.channels.Selector;
	18	+import java.nio.channels.SocketChannel;
	19	+import java.text.SimpleDateFormat;
	20	+import java.time.LocalDateTime;
	21	+import java.time.format.DateTimeFormatter;
	22	+
	23	+public class SendReadTask implements Runnable {
	24	+ public static final SimpleDateFormat sdf = new SimpleDateFormat("[MM-dd HH:mm:ss]");
	25	+ public static final String LOG_DATE_FORMAT = "[MM-dd HH:mm:ss]";
	26	+
	27	+ private Selector selector;
	28	+ private SelectionKey key;
	29	+ private CollectUserQueue collectUserQueue = CollectUserQueue.getInstance();
	30	+ private ConnectUserDto connectUserDto;
	31	+ private String serviceType;
	32	+ private final LogUtil logger;
	33	+
	34	+ public SendReadTask(Selector selector, SelectionKey key, String serviceType, LogUtil logger) {
	35	+ this.selector = selector;
	36	+ this.key = key;
	37	+ this.connectUserDto = (ConnectUserDto) key.attachment();
	38	+ this.serviceType = serviceType;
	39	+ this.logger = logger;
	40	+ }
	41	+
	42	+ @Override
	43	+ public void run() {
	44	+ System.out.println("SendReadTask start : " + Thread.currentThread().getName());
	45	+ int size = -1;
	46	+ try {
	47	+ SocketChannel channel = (SocketChannel) key.channel();
	48	+ /* 1. Head 읽기 */
	49	+ ByteBuffer headBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH);
	50	+ try {
	51	+ size = channel.read(headBuffer);
	52	+ } catch (IOException e) {}
	53	+ /* 2. Body 읽기 */
	54	+ if (size > 0) {
	55	+// Packet.printBuffer(headBuffer);
	56	+ String command = Header.getCommand(headBuffer);
	57	+ switch (Integer.parseInt(command)) {
	58	+ case 1 : recvBind(channel, headBuffer); break;
	59	+ case 3 : recvDeliver(channel, headBuffer); break;
	60	+ case 7 : recvLinkCheck(channel); break;
	61	+ default: expireConnectUser(); break;
	62	+ }
	63	+ } else {
	64	+ expireConnectUser();
	65	+ }
	66	+ } catch (Exception e) {
	67	+ size = -1;
	68	+ e.printStackTrace();
	69	+ }
	70	+ }
	71	+
	72	+ private void recvDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	73	+ /* 서비스 중지여부 체크 */
	74	+ if (isExpireService()) {
	75	+ expireConnectUser();
	76	+ return;
	77	+ }
	78	+ switch (this.serviceType) {
	79	+ case "SMS":
	80	+ recvSmsDeliver(channel, headBuffer);
	81	+ break;
	82	+ case "LMS":
	83	+ recvLmsDeliver(channel, headBuffer);
	84	+ break;
	85	+ case "MMS":
	86	+ recvMmsDeliver(channel, headBuffer);
	87	+ break;
	88	+ case "KAT":
	89	+ recvKatDeliver(channel, headBuffer);
	90	+ break;
	91	+ case "KFT":
	92	+ recvKftDeliver(channel, headBuffer);
	93	+ break;
	94	+ default:break;
	95	+ }
	96	+ }
	97	+
	98	+ private boolean isExpireService() {
	99	+ ConnectUserDto checkConnectUserDto = collectUserQueue.getUser(this.serviceType, this.connectUserDto.getUserId());
	100	+ MemberDto memberDto = checkConnectUserDto.getMemberDto();
	101	+ saveSystemLog("[isExpireService : " + memberDto.toString() + "]");
	102	+ if (memberDto == null) {
	103	+ return true;
	104	+ }
	105	+ if (collectUserQueue.isExist(this.serviceType, memberDto.getMberId()) == false) {
	106	+ return true;
	107	+ }
	108	+ /* 회원 사용 상태 */
	109	+ if (memberDto.getMberSttus() == null \|\| "N".equals(memberDto.getMberSttus())) {
	110	+ return true;
	111	+ }
	112	+ /* 서비스 이용 상태 */
	113	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	114	+ return true;
	115	+ }
	116	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	117	+ return true;
	118	+ }
	119	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	120	+ return true;
	121	+ }
	122	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	123	+ return true;
	124	+ }
	125	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	126	+ return true;
	127	+ }
	128	+
	129	+ return false;
	130	+ }
	131	+
	132	+ public BasicMessageDto recvCommonMessage(ByteBuffer deliverBuffer) {
	133	+ if (deliverBuffer == null) {
	134	+ return null;
	135	+ }
	136	+ BasicMessageDto messageDto = new BasicMessageDto();
	137	+ messageDto.setRouterSeq("40");
	138	+ messageDto.setServiceType("4");
	139	+ messageDto.setUserId(connectUserDto.getUserId());
	140	+ messageDto.setRemoteIP(connectUserDto.getRemoteIP());
	141	+ messageDto.setSendStatus("0");
	142	+ messageDto.setUserMsgID(CommonMessage.getMessageIdForDeliver(deliverBuffer));
	143	+ messageDto.setUserSender(CommonMessage.getSenderForDeliver(deliverBuffer));
	144	+ messageDto.setUserReceiver(CommonMessage.getReceiverForDeliver(deliverBuffer));
	145	+ messageDto.setReserveDt(CommonMessage.getReserveTimeForDeliver(deliverBuffer));
	146	+ messageDto.setRequestDt(CommonMessage.getRequestTimeForDeliver(deliverBuffer));
	147	+ messageDto.setUnitCost("10.4");
	148	+
	149	+ return messageDto;
	150	+ }
	151	+
	152	+ private void recvSmsDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	153	+ try {
	154	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(SmsMessage.DELIVER_SMS_BODY_LENGTH);
	155	+ channel.read(bodyBuffer);
	156	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + SmsMessage.DELIVER_SMS_BODY_LENGTH);
	157	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	158	+
	159	+// Packet.printBuffer(deliverBuffer);
	160	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	161	+ messageDto.setUserMessage(SmsMessage.getMessageForDeliver(deliverBuffer));
	162	+
	163	+ /* 사용자 단가, 발송망 설정 */
	164	+ MemberDto savedMemberDto = null;
	165	+ if (this.connectUserDto != null) {
	166	+ savedMemberDto = this.connectUserDto.getMemberDto();
	167	+ }
	168	+ if (savedMemberDto != null) {
	169	+ messageDto.setRouterSeq(savedMemberDto.getSmsAgentCode());
	170	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getShortPrice()));
	171	+ }
	172	+
	173	+ saveSystemLog("[SMS] [MESSAGE : " + messageDto.toString() + "]");
	174	+ QueueTypeWorker worker = QueueTypeWorker.find("SMS");
	175	+ if (worker != null) {
	176	+ worker.pushQueue(messageDto);
	177	+ channel.write(SmsMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	178	+ }
	179	+ } catch (Exception e) {
	180	+ e.printStackTrace();
	181	+ }
	182	+ }
	183	+
	184	+ private void recvLmsDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	185	+ try {
	186	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(LmsMessage.DELIVER_LMS_BODY_LENGTH);
	187	+ channel.read(bodyBuffer);
	188	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + LmsMessage.DELIVER_LMS_BODY_LENGTH);
	189	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	190	+
	191	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	192	+ messageDto.setUserSubject(LmsMessage.getSubjectForDeliver(deliverBuffer));
	193	+ messageDto.setUserMessage(LmsMessage.getMessageForDeliver(deliverBuffer));
	194	+
	195	+ /* 사용자 단가, 발송망 설정 */
	196	+ MemberDto savedMemberDto = null;
	197	+ if (this.connectUserDto != null) {
	198	+ savedMemberDto = this.connectUserDto.getMemberDto();
	199	+ }
	200	+ if (savedMemberDto != null) {
	201	+ messageDto.setRouterSeq(savedMemberDto.getLmsAgentCode());
	202	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getLongPrice()));
	203	+ }
	204	+
	205	+ saveSystemLog("[LMS] [MESSAGE : " + messageDto.toString() + "]");
	206	+ QueueTypeWorker worker = QueueTypeWorker.find("LMS");
	207	+ if (worker != null) {
	208	+ worker.pushQueue(messageDto);
	209	+ channel.write(LmsMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	210	+ }
	211	+ } catch (Exception e) {
	212	+ e.printStackTrace();
	213	+ }
	214	+ }
	215	+
	216	+ private void recvMmsDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	217	+ try {
	218	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(MmsMessage.DELIVER_MMS_BODY_LENGTH);
	219	+ channel.read(bodyBuffer);
	220	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + MmsMessage.DELIVER_MMS_BODY_LENGTH);
	221	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	222	+
	223	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	224	+ messageDto.setUserSubject(MmsMessage.getSubjectForDeliver(deliverBuffer));
	225	+ messageDto.setUserMessage(MmsMessage.getMessageForDeliver(deliverBuffer));
	226	+ String fileCount = MessageUtil.doNumber(MmsMessage.getFileCountForDeliver(deliverBuffer));
	227	+ int recvFileCount = 0;
	228	+ if (fileCount != null && fileCount.length() > 0) {
	229	+ recvFileCount = Integer.parseInt(fileCount);
	230	+ messageDto.setUserFileCnt(recvFileCount);
	231	+ }
	232	+
	233	+ String imagePath = System.getProperty("ROOTPATH") + File.separator + "mmsfile";
	234	+ imagePath = imagePath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
	235	+ FileUtil.mkdirs(imagePath);
	236	+
	237	+ for (int i = 0; i < recvFileCount; i++) {
	238	+ ByteBuffer fileHeadBuffer = ByteBuffer.allocate(MmsMessage.DELIVER_MMS_FILENAME_LENGTH + MmsMessage.DELIVER_MMS_FILESIZE_LENGTH);
	239	+ channel.read(fileHeadBuffer);
	240	+ String fileName = MmsMessage.getFileNameForDeliver(fileHeadBuffer);
	241	+ String fileSize = MmsMessage.getFileSizeForDeliver(fileHeadBuffer);
	242	+ ByteBuffer fileBuffer = ByteBuffer.allocate(Integer.parseInt(fileSize));
	243	+ channel.read(fileBuffer);
	244	+ fileBuffer.flip();
	245	+ JobFileFactory.saveFileForByteBuffer(imagePath, fileName, fileBuffer);
	246	+ if (i == 0) {
	247	+ messageDto.setUserFileName01(imagePath + File.separator + fileName);
	248	+ } else if (i == 1) {
	249	+ messageDto.setUserFileName02(imagePath + File.separator + fileName);
	250	+ } else if (i == 2) {
	251	+ messageDto.setUserFileName03(imagePath + File.separator + fileName);
	252	+ }
	253	+ saveSystemLog("[MMS IMAGE] [File : " + fileName + ", Size : " + fileSize + "]");
	254	+ }
	255	+
	256	+ /* 사용자 단가, 발송망 설정 */
	257	+ MemberDto savedMemberDto = null;
	258	+ if (this.connectUserDto != null) {
	259	+ savedMemberDto = this.connectUserDto.getMemberDto();
	260	+ }
	261	+ if (savedMemberDto != null) {
	262	+ messageDto.setRouterSeq(savedMemberDto.getMmsAgentCode());
	263	+ float mmsPrice = 0.0F;
	264	+ if (recvFileCount == 1) {
	265	+ mmsPrice = savedMemberDto.getPicturePrice();
	266	+ } else if (recvFileCount == 2) {
	267	+ mmsPrice = savedMemberDto.getPicture2Price();
	268	+ } else {
	269	+ mmsPrice = savedMemberDto.getPicture3Price();
	270	+ }
	271	+ messageDto.setUnitCost(String.valueOf(mmsPrice));
	272	+ }
	273	+
	274	+ saveSystemLog("[MMS] [MESSAGE : " + messageDto.toString() + "]");
	275	+ QueueTypeWorker worker = QueueTypeWorker.find("MMS");
	276	+ if (worker != null) {
	277	+ worker.pushQueue(messageDto);
	278	+ channel.write(MmsMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	279	+ }
	280	+ } catch (Exception e) {
	281	+ e.printStackTrace();
	282	+ }
	283	+ }
	284	+
	285	+ private void recvKatDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	286	+ try {
	287	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	288	+ channel.read(bodyBuffer);
	289	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	290	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	291	+
	292	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	293	+ messageDto.setUserSubject(KakaoMessage.getSubjectForDeliver(deliverBuffer));
	294	+ messageDto.setUserMessage(KakaoMessage.getMessageForDeliver(deliverBuffer));
	295	+ messageDto.setKakaoSenderKey(KakaoMessage.getKakaoSenderKeyForDeliver(deliverBuffer));
	296	+ messageDto.setKakaoTemplateCode(KakaoMessage.getKakaoTemplateCodeForDeliver(deliverBuffer));
	297	+
	298	+ String jsonPath = System.getProperty("ROOTPATH") + File.separator + "kakaofile";
	299	+ jsonPath = jsonPath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
	300	+ FileUtil.mkdirs(jsonPath);
	301	+
	302	+ ByteBuffer fileHeadBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_JSON_FILENAME_LENGTH + KakaoMessage.DELIVER_JSON_FILESIZE_LENGTH);
	303	+ channel.read(fileHeadBuffer);
	304	+
	305	+ String fileName = KakaoMessage.getFileNameForDeliver(fileHeadBuffer);
	306	+ String fileSize = KakaoMessage.getFileSizeForDeliver(fileHeadBuffer);
	307	+
	308	+ ByteBuffer fileBuffer = ByteBuffer.allocate(Integer.parseInt(fileSize));
	309	+ channel.read(fileBuffer);
	310	+ fileBuffer.flip();
	311	+ JobFileFactory.saveFileForByteBuffer(jsonPath, fileName, fileBuffer);
	312	+
	313	+ messageDto.setKakaoJsonFile(jsonPath + File.separator + fileName);
	314	+ saveSystemLog("[KAT JSON] [File : " + fileName + ", Size : " + fileSize + "]");
	315	+
	316	+ /* 사용자 단가, 발송망 설정 */
	317	+ MemberDto savedMemberDto = null;
	318	+ if (this.connectUserDto != null) {
	319	+ savedMemberDto = this.connectUserDto.getMemberDto();
	320	+ }
	321	+ if (savedMemberDto != null) {
	322	+ messageDto.setRouterSeq(savedMemberDto.getKakaoAtAgentCode());
	323	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getKakaoAtPrice()));
	324	+ }
	325	+
	326	+ saveSystemLog("[KAKAO ALARM] [MESSAGE : " + messageDto.toString() + "]");
	327	+ QueueTypeWorker worker = QueueTypeWorker.find("KAT");
	328	+ if (worker != null) {
	329	+ worker.pushQueue(messageDto);
	330	+ channel.write(KakaoMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	331	+ } else {
	332	+ saveSystemLog("worker is null");
	333	+ }
	334	+ } catch (Exception e) {
	335	+ e.printStackTrace();
	336	+ }
	337	+ }
	338	+
	339	+ private void recvKftDeliver(SocketChannel channel, ByteBuffer headBuffer) throws IOException {
	340	+ try {
	341	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	342	+ channel.read(bodyBuffer);
	343	+ ByteBuffer deliverBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + KakaoMessage.DELIVER_KAKAO_BODY_LENGTH);
	344	+ Packet.mergeBuffers(deliverBuffer, headBuffer, bodyBuffer);
	345	+
	346	+ BasicMessageDto messageDto = recvCommonMessage(deliverBuffer);
	347	+ messageDto.setUserSubject(KakaoMessage.getSubjectForDeliver(deliverBuffer));
	348	+ messageDto.setUserMessage(KakaoMessage.getMessageForDeliver(deliverBuffer));
	349	+ messageDto.setKakaoSenderKey(KakaoMessage.getKakaoSenderKeyForDeliver(deliverBuffer));
	350	+ messageDto.setKakaoTemplateCode(KakaoMessage.getKakaoTemplateCodeForDeliver(deliverBuffer));
	351	+
	352	+ String jsonPath = System.getProperty("ROOTPATH") + File.separator + "kakaofile";
	353	+ jsonPath = jsonPath + File.separator + MessageUtil.getDate() + File.separator + SerialNoUtil.getSerialNo();
	354	+ FileUtil.mkdirs(jsonPath);
	355	+
	356	+ ByteBuffer fileHeadBuffer = ByteBuffer.allocate(KakaoMessage.DELIVER_JSON_FILENAME_LENGTH + KakaoMessage.DELIVER_JSON_FILESIZE_LENGTH);
	357	+ channel.read(fileHeadBuffer);
	358	+
	359	+ String fileName = KakaoMessage.getFileNameForDeliver(fileHeadBuffer);
	360	+ String fileSize = KakaoMessage.getFileSizeForDeliver(fileHeadBuffer);
	361	+
	362	+ ByteBuffer fileBuffer = ByteBuffer.allocate(Integer.parseInt(fileSize));
	363	+ channel.read(fileBuffer);
	364	+ fileBuffer.flip();
	365	+ JobFileFactory.saveFileForByteBuffer(jsonPath, fileName, fileBuffer);
	366	+
	367	+ messageDto.setKakaoJsonFile(jsonPath + File.separator + fileName);
	368	+ saveSystemLog("[KFT JSON] [File : " + fileName + ", Size : " + fileSize + "]");
	369	+
	370	+ /* 사용자 단가, 발송망 설정 */
	371	+ MemberDto savedMemberDto = null;
	372	+ if (this.connectUserDto != null) {
	373	+ savedMemberDto = this.connectUserDto.getMemberDto();
	374	+ }
	375	+ if (savedMemberDto != null) {
	376	+ messageDto.setRouterSeq(savedMemberDto.getKakaoFtAgentCode());
	377	+ messageDto.setUnitCost(String.valueOf(savedMemberDto.getKakaoFtPrice()));
	378	+ }
	379	+
	380	+ saveSystemLog("[KAKAO FRIEND] [MESSAGE : " + messageDto.toString() + "]");
	381	+ QueueTypeWorker worker = QueueTypeWorker.find("KFT");
	382	+ if (worker != null) {
	383	+ worker.pushQueue(messageDto);
	384	+ channel.write(KakaoMessage.makeDeliverAckBuffer(messageDto.getUserMsgID(), messageDto.getSendStatus()));
	385	+ }
	386	+ } catch (Exception e) {
	387	+ e.printStackTrace();
	388	+ }
	389	+ }
	390	+
	391	+ private void recvLinkCheck(SocketChannel channel) throws IOException {
	392	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(LinkCheck.LINK_CHECK_ACK_BODY_LENGTH);
	393	+ channel.read(bodyBuffer);
	394	+// SocketChannel channel = (SocketChannel) key.channel();
	395	+ channel.write(LinkCheck.makeLinkCheckAckBuffer());
	396	+ /* 서비스 중지여부 체크 */
	397	+ if (isExpireService()) {
	398	+ expireConnectUser();
	399	+ return;
	400	+ }
	401	+ }
	402	+
	403	+ private void recvBind(SocketChannel channel, ByteBuffer headBuffer) {
	404	+ String resultCode = "00";
	405	+ try {
	406	+ ByteBuffer bindBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + Bind.BIND_BODY_LENGTH);
	407	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(Bind.BIND_BODY_LENGTH);
	408	+ channel.read(bodyBuffer);
	409	+ Packet.mergeBuffers(bindBuffer, headBuffer, bodyBuffer);
	410	+
	411	+ String id = Bind.getBindId(bindBuffer);
	412	+ String pwd = Bind.getBindPwd(bindBuffer);
	413	+
	414	+ MemberService svc = (MemberService) CacheService.LOGIN_SERVICE.getService();
	415	+ MemberDto memberDto = null;
	416	+ if (svc != null) {
	417	+ memberDto = svc.get(id);
	418	+ }
	419	+ saveSystemLog("[BIND REQUEST] [ID : " + id + ", PWD : " + pwd + "]");
	420	+ /* Bind Check */
	421	+ resultCode = checkBind(memberDto, this.serviceType, id, pwd);
	422	+
	423	+ /* 접속 IP 체크 */
	424	+ if ("00".equals(resultCode)) {
	425	+ boolean isPermit = false;
	426	+ if (memberDto.getIpLimitYn() == null \|\| "Y".equals(memberDto.getIpLimitYn())) {
	427	+ saveSystemLog("connectUserDto.getRemoteIP() : " + connectUserDto.getRemoteIP());
	428	+ saveSystemLog("Customize Toolbar... : " + memberDto.getAllowIpBasic());
	429	+ saveSystemLog("memberDto.getAllowIpExtend() : " + memberDto.getAllowIpExtend());
	430	+ if (memberDto.getAllowIpBasic() != null && connectUserDto.getRemoteIP().equals(memberDto.getAllowIpBasic())) {
	431	+ isPermit = true;
	432	+ }
	433	+ if (memberDto.getAllowIpExtend() != null && connectUserDto.getRemoteIP().equals(memberDto.getAllowIpExtend())) {
	434	+ isPermit = true;
	435	+ }
	436	+ } else {
	437	+ isPermit = true;
	438	+ }
	439	+ if (isPermit) {
	440	+ resultCode = "00";
	441	+ } else {
	442	+ resultCode = "40";
	443	+ }
	444	+ }
	445	+ if ("00".equals(resultCode)) {
	446	+ connectUserDto.setUserId(id);
	447	+ connectUserDto.setLogin(true);
	448	+ connectUserDto.setMemberDto(memberDto);
	449	+ /* 사용자 Pool에 저장 */
	450	+ collectUserQueue.putUser(this.serviceType, connectUserDto);
	451	+ /* 세션통신 시간 업데이트 */
	452	+ connectUserDto.updateLastTrafficTime();
	453	+ }
	454	+ } catch (Exception e) {
	455	+ resultCode = "10";
	456	+ e.printStackTrace();
	457	+ }
	458	+
	459	+ try {
	460	+ saveSystemLog("[BIND RESULT : " + resultCode + "]");
	461	+ channel.write(Bind.makeBindAckBuffer(resultCode));
	462	+ if ("00".equals(resultCode) == false) {
	463	+ expireConnectUser();
	464	+ }
	465	+ } catch (IOException e) {
	466	+ e.printStackTrace();
	467	+ }
	468	+ }
	469	+
	470	+ private String checkBind(MemberDto memberDto, String serviceType, String id, String pwd) {
	471	+ if (id == null \|\| pwd == null) {
	472	+ return "50";
	473	+ }
	474	+ if (collectUserQueue.isExist(this.serviceType, id)) {
	475	+ return "60";
	476	+ }
	477	+ if (memberDto == null \|\| !pwd.equals(memberDto.getAccessKey())) {
	478	+ return "20";
	479	+ }
	480	+ /* 회원 사용 상태 */
	481	+ if (memberDto.getMberSttus() == null \|\| "N".equals(memberDto.getMberSttus())) {
	482	+ return "30";
	483	+ }
	484	+ /* 서비스 이용 상태 */
	485	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	486	+ return "30";
	487	+ }
	488	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	489	+ return "30";
	490	+ }
	491	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	492	+ return "30";
	493	+ }
	494	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	495	+ return "30";
	496	+ }
	497	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	498	+ return "30";
	499	+ }
	500	+
	501	+ return "00";
	502	+ }
	503	+
	504	+ private String checkService(MemberDto memberDto, String serviceType) {
	505	+ if ("SMS".equals(serviceType) && "N".equals(memberDto.getSmsUseYn())) {
	506	+ return "30";
	507	+ }
	508	+ if ("LMS".equals(serviceType) && "N".equals(memberDto.getLmsUseYn())) {
	509	+ return "30";
	510	+ }
	511	+ if ("MMS".equals(serviceType) && "N".equals(memberDto.getMmsUseYn())) {
	512	+ return "30";
	513	+ }
	514	+ if ("KAT".equals(serviceType) && "N".equals(memberDto.getKakaoAtUseYn())) {
	515	+ return "30";
	516	+ }
	517	+ if ("KFT".equals(serviceType) && "N".equals(memberDto.getKakaoFtUseYn())) {
	518	+ return "30";
	519	+ }
	520	+
	521	+ return "00";
	522	+ }
	523	+
	524	+ private void expireConnectUser() {
	525	+ if (key == null \|\| !key.isValid()) {
	526	+ return;
	527	+ }
	528	+ try {
	529	+ SocketChannel channel = (SocketChannel) key.channel();
	530	+ if (connectUserDto != null) {
	531	+ if (connectUserDto.getUserId() != null) {
	532	+ collectUserQueue.removeUser(connectUserDto.getServiceType(), connectUserDto.getUserId());
	533	+ }
	534	+ key.attach(null);
	535	+ }
	536	+ // 소켓 채널 닫기
	537	+ channel.close();
	538	+ // 키 닫기
	539	+ key.cancel();
	540	+ } catch (IOException e) {
	541	+ e.printStackTrace();
	542	+ }
	543	+ }
	544	+
	545	+ private void saveSystemLog(Object obj) {
	546	+ saveLog(obj, true);
	547	+ }
	548	+
	549	+ private void saveLog(Object obj) {
	550	+ saveLog(obj, false);
	551	+ }
	552	+
	553	+ private void saveLog(Object obj, boolean isConsoleOutput) {
	554	+ if (isConsoleOutput) {
	555	+ System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern(LOG_DATE_FORMAT)) + " {{COLLECT_READ_TASK}} " + obj);
	556	+ }
	557	+
	558	+ if (logger == null) {
	559	+ return;
	560	+ }
	561	+
	562	+ logger.log(obj);
	563	+ }
	564	+}

455962e

src/main/java/com/munjaon/server/server/task/StatusCheckTask.java (added)

+++ src/main/java/com/munjaon/server/server/task/StatusCheckTask.java

...	...	@@ -0,0 +1,76 @@
	1	+package com.munjaon.server.server.task;
	2	+
	3	+import com.munjaon.server.cache.dto.MemberDto;
	4	+import com.munjaon.server.cache.enums.CacheService;
	5	+import com.munjaon.server.cache.service.MemberService;
	6	+import com.munjaon.server.server.dto.ConnectUserDto;
	7	+import com.munjaon.server.server.queue.CollectUserQueue;
	8	+import com.munjaon.server.util.LogUtil;
	9	+
	10	+import java.text.SimpleDateFormat;
	11	+import java.time.LocalDateTime;
	12	+import java.time.format.DateTimeFormatter;
	13	+import java.util.List;
	14	+
	15	+public class StatusCheckTask implements Runnable {
	16	+ public static final SimpleDateFormat sdf = new SimpleDateFormat("[MM-dd HH:mm:ss]");
	17	+ public static final String LOG_DATE_FORMAT = "[MM-dd HH:mm:ss]";
	18	+
	19	+ private CollectUserQueue collectUserQueue = CollectUserQueue.getInstance();
	20	+ private String serviceType;
	21	+ private final LogUtil logger;
	22	+
	23	+ public StatusCheckTask(String serviceType, LogUtil logger) {
	24	+ this.serviceType = serviceType;
	25	+ this.logger = logger;
	26	+ }
	27	+
	28	+ @Override
	29	+ public void run() {
	30	+ saveSystemLog("[" + this.serviceType + "][USER STATUS CHECK is starting ... ...]");
	31	+ List<ConnectUserDto> userList = collectUserQueue.getUsers(this.serviceType);
	32	+ if (userList == null && userList.isEmpty()) {
	33	+ saveSystemLog("[" + this.serviceType + "][USER STATUS CHECK is empty ... ...]");
	34	+ saveSystemLog("[" + this.serviceType + "][USER STATUS CHECK is ended ... ...]");
	35	+ return;
	36	+ }
	37	+
	38	+ MemberService svc = (MemberService) CacheService.LOGIN_SERVICE.getService();
	39	+ for (ConnectUserDto user : userList) {
	40	+ MemberDto savedMemberDto = user.getMemberDto();
	41	+ saveSystemLog("[" + this.serviceType + "][USER PREVIOUS STATUS : " + savedMemberDto.toString() + "]");
	42	+ if (savedMemberDto == null) {
	43	+ continue;
	44	+ }
	45	+ MemberDto newMemberDto = svc.get(savedMemberDto.getMberId());
	46	+ saveSystemLog("[" + this.serviceType + "][USER NEW STATUS : " + newMemberDto.toString() + "]");
	47	+ if (newMemberDto == null) {
	48	+ savedMemberDto.setMberSttus("N");
	49	+ } else {
	50	+ user.setMemberDto(newMemberDto);
	51	+ }
	52	+ saveSystemLog("[" + this.serviceType + "][USER AFTER STATUS : " + savedMemberDto.toString() + "]");
	53	+ }
	54	+ saveSystemLog("[" + this.serviceType + "][USER STATUS CHECK is ended ... ...]");
	55	+ }
	56	+
	57	+ private void saveSystemLog(Object obj) {
	58	+ saveLog(obj, true);
	59	+ }
	60	+
	61	+ private void saveLog(Object obj) {
	62	+ saveLog(obj, false);
	63	+ }
	64	+
	65	+ private void saveLog(Object obj, boolean isConsoleOutput) {
	66	+ if (isConsoleOutput) {
	67	+ System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern(LOG_DATE_FORMAT)) + " {{StatusCheckTask}} " + obj);
	68	+ }
	69	+
	70	+ if (logger == null) {
	71	+ return;
	72	+ }
	73	+
	74	+ logger.log(obj);
	75	+ }
	76	+}

aa4fc21

455962e

src/main/java/com/munjaon/server/util/MessageUtil.java

--- src/main/java/com/munjaon/server/util/MessageUtil.java

+++ src/main/java/com/munjaon/server/util/MessageUtil.java

...	...	@@ -501,4 +501,16 @@
501	501
502	502	return reportDto;
503	503	}
	504	+
	505	+ public static String makeMessageKey(String msgId) {
	506	+ if (msgId == null \|\| msgId.trim().isEmpty() \|\| msgId.trim().length() > 14) {
	507	+ return "MSGID_" + SerialNoUtil.getSerialNo();
	508	+ }
	509	+ String lpad = "";
	510	+ for (int i = 0, size = 14 - msgId.trim().length(); i < size; i++) {
	511	+ lpad += "0";
	512	+ }
	513	+
	514	+ return "MSGID_" + lpad + msgId.trim();
	515	+ }
504	516	}

aa4fc21

455962e

src/main/resources/application.yml

--- src/main/resources/application.yml

+++ src/main/resources/application.yml


   profiles:
     default: local
 
+logging:
+  level:
+    root: info
+
 mybatis:
   configuration:
     map-underscore-to-camel-case: true

aa4fc21

455962e

src/main/resources/dev/application-dev.yml

--- src/main/resources/dev/application-dev.yml

+++ src/main/resources/dev/application-dev.yml


   datasource:
     server:
       driver-class-name: org.mariadb.jdbc.Driver
-      jdbc-url: jdbc:mariadb://119.193.215.98:3306/mjon_agent_back
+      url: jdbc:mariadb://192.168.0.125:3306/mjon_agent_back
+      jdbc-url: jdbc:mariadb://192.168.0.125:3306/mjon_agent_back
+#      jdbc-url: jdbc:mariadb://119.193.215.98:3306/mjon_agent_back
       username: mjonUr_agent
       password: mjagent123$
 

aa4fc21

455962e

src/main/resources/logback-spring.xml

--- src/main/resources/logback-spring.xml

+++ src/main/resources/logback-spring.xml


                 <pattern>${LOG_PATTERN}</pattern>
             </encoder>
         </appender>
-        <logger name="com.munjaon.server" level="DEBUG" />
+        <logger name="com.munjaon.server" level="INFO" />
         <root level="ERROR">
             <appender-ref ref="CONSOLE"/>
         </root>

aa4fc21

455962e

src/main/resources/prod/application-prod.yml

--- src/main/resources/prod/application-prod.yml

+++ src/main/resources/prod/application-prod.yml


   datasource:
     server:
       driver-class-name: org.mariadb.jdbc.Driver
+      url: jdbc:mariadb://119.193.215.98:3306/mjon_agent
       jdbc-url: jdbc:mariadb://119.193.215.98:3306/mjon_agent
       username: mjonUr_agent
       password: mjagent123$

aa4fc21

455962e

src/main/resources/sqlmap/kat_sql.xml

--- src/main/resources/sqlmap/kat_sql.xml

+++ src/main/resources/sqlmap/kat_sql.xml


                                 , BIZ_KAKAO_RESEND_DATA
                                 , BIZ_KAKAO_RESEND_TYPE
                                 , BIZ_KAKAO_JSON_FILE
-        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '8', 'N', null, null, #{kakaoJsonFile})
+        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '8', 'N', null, null, #{kakaoJsonFile})
+    </insert>
+
+    <insert id="insertForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, MSG_NOTICETALK_SENDER_KEY, MSG_NOTICETALK_TMP_KEY, REQ_DATE, CALL_TO, CALL_FROM, SMS_TXT, BIZ_KAKAO_TITLE, MSG_TYPE, BIZ_KAKAO_RESEND_YN, BIZ_KAKAO_RESEND_DATA, BIZ_KAKAO_RESEND_TYPE, BIZ_KAKAO_JSON_FILE)
+        VALUES
+            <foreach separator="," item="item" collection="list">
+                (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, #{item.kakaoSenderKey}, #{item.kakaoTemplateCode}, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, '8', 'N', null, null, #{item.kakaoJsonFile})
+            </foreach>
+    </insert>
+
+    <insert id="insertGroupForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.msgGroupID}, #{item.userId},  #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '8', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'Y', '' )
+        </foreach>
     </insert>
 </mapper>

aa4fc21

455962e

src/main/resources/sqlmap/kft_sql.xml

--- src/main/resources/sqlmap/kft_sql.xml

+++ src/main/resources/sqlmap/kft_sql.xml


                                 , BIZ_KAKAO_RESEND_DATA
                                 , BIZ_KAKAO_RESEND_TYPE
                                 , BIZ_KAKAO_JSON_FILE
-        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '9', 'N', null, null, #{kakaoJsonFile})
+        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '9', 'N', null, null, #{kakaoJsonFile})
+    </insert>
+
+    <insert id="insertForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, MSG_NOTICETALK_SENDER_KEY, MSG_NOTICETALK_TMP_KEY, REQ_DATE, CALL_TO, CALL_FROM, SMS_TXT, BIZ_KAKAO_TITLE, MSG_TYPE, BIZ_KAKAO_RESEND_YN, BIZ_KAKAO_RESEND_DATA, BIZ_KAKAO_RESEND_TYPE, BIZ_KAKAO_JSON_FILE)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, #{item.kakaoSenderKey}, #{item.kakaoTemplateCode}, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, '8', 'N', null, null, #{item.kakaoJsonFile})
+        </foreach>
+    </insert>
+
+    <insert id="insertGroupForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.msgGroupID}, #{item.userId},  #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '9', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'Y', '' )
+        </foreach>
     </insert>
 </mapper>

aa4fc21

455962e

src/main/resources/sqlmap/lms_sql.xml

--- src/main/resources/sqlmap/lms_sql.xml

+++ src/main/resources/sqlmap/lms_sql.xml


                                 , SMS_TXT
                                 , MSG_TYPE
                                 , CONT_SEQ, FILE_CNT
-        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, '0' )
+        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, '0' )
+    </insert>
+
+    <insert id="insertForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, REQ_DATE, CALL_TO, CALL_FROM, SUBJECT, SMS_TXT, MSG_TYPE, CONT_SEQ, FILE_CNT)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userSubject}, #{item.userMessage}, '6', null, '0' )
+        </foreach>
+    </insert>
+
+    <insert id="insertGroupForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.msgGroupID}, #{item.userId},  #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '6', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'N', '' )
+        </foreach>
     </insert>
 </mapper>

aa4fc21

455962e

src/main/resources/sqlmap/mms_sql.xml

--- src/main/resources/sqlmap/mms_sql.xml

+++ src/main/resources/sqlmap/mms_sql.xml


                                 , FILE_PATH2
                                 , FILE_PATH3
                                 , NEO_TYPE
-        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, #{userFileCnt}, #{userFileName01}, #{userFileName02}, #{userFileName03}, null)
+        ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, #{userFileCnt}, #{userFileName01}, #{userFileName02}, #{userFileName03}, null)
+    </insert>
+
+    <insert id="insertForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, REQ_DATE, CALL_TO, CALL_FROM, SUBJECT, SMS_TXT, MSG_TYPE, CONT_SEQ, FILE_CNT, FILE_PATH1, FILE_PATH2, FILE_PATH3, NEO_TYPE)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userSubject}, #{item.userMessage}, '6', null, #{item.userFileCnt}, #{item.userFileName01}, #{item.userFileName02}, #{item.userFileName03}, null)
+        </foreach>
+    </insert>
+
+    <insert id="insertGroupForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.msgGroupID}, #{item.userId},  #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '6', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, #{item.userFileCnt}, '0.0', NULL, NULL, 'N', '' )
+        </foreach>
     </insert>
 </mapper>

aa4fc21

455962e

src/main/resources/sqlmap/sms_sql.xml

--- src/main/resources/sqlmap/sms_sql.xml

+++ src/main/resources/sqlmap/sms_sql.xml


                                 , SUBJECT
                                 , SMS_TXT
                                 , MSG_TYPE
-        )VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, NOW(), #{userReceiver}, #{userSender}, NULL, #{userMessage}, '4' )
+        )VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, NOW(), #{userReceiver}, #{userSender}, NULL, #{userMessage}, '4' )
+    </insert>
+
+    <insert id="insertForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, REQ_DATE, CALL_TO, CALL_FROM, SUBJECT, SMS_TXT, MSG_TYPE)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, NOW(), #{item.userReceiver}, #{item.userSender}, NULL, #{item.userMessage}, '4' )
+        </foreach>
+    </insert>
+
+    <insert id="insertGroupForList" parameterType="java.util.List">
+        INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
+        VALUES
+        <foreach separator="," item="item" collection="list">
+            (#{item.msgGroupID}, #{item.userId},  #{item.userSender}, #{item.userMessage}, NULL, NOW(), '1', NULL, '4', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'N', '' )
+        </foreach>
     </insert>
 </mapper>

Add a comment

Open 0
Closed 0

List

...	...	@@ -6,7 +6,6 @@
6	6	import com.munjaon.server.util.ServiceUtil;
7	7	import lombok.RequiredArgsConstructor;
8	8	import lombok.extern.slf4j.Slf4j;
9		-import org.apache.commons.configuration2.ex.ConfigurationException;
10	9	import org.springframework.boot.CommandLineRunner;
11	10	import org.springframework.context.annotation.Bean;
12	11	import org.springframework.context.annotation.Configuration;
...	...	@@ -24,16 +23,16 @@
24	23	System.setProperty("PROPS", serverConfig.getServerProperyFile());
25	24	System.setProperty("ROOTPATH", serverConfig.getServerRootPath());
26	25	PropertyLoader.load();
	26	+
	27	+ /* Serial queue 초기화 */
	28	+ SerialQueuePool queueInstance = SerialQueuePool.getInstance();
27	29	try {
28		- String[] array = serverConfig.getStringArray("test.list");
29		- if (array != null && array.length > 0) {
30		- for (String s : array) {
31		- System.out.println("List : " + s);
32		- }
33		- }
34		- } catch (ConfigurationException e) {
35		- throw new RuntimeException(e);
	30	+ SerialQueue serialQueue = new SerialQueue();
	31	+ queueInstance.setSerialQueue(serialQueue);
	32	+ } catch (Exception e) {
	33	+ e.printStackTrace();
36	34	}
	35	+
37	36	return args -> System.out.println("Runner Bean #1 : " + serverConfig.getServerProperyFile());
38	37	}
39	38
...	...	@@ -180,8 +179,8 @@
180	179	String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
181	180	int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
182	181	// CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
183		- CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
184		- collectServerService.start();
	182	+ CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
	183	+ collectServer.start();
185	184	} catch (Exception e) {
186	185	throw new RuntimeException(e);
187	186	}
...	...	@@ -196,8 +195,8 @@
196	195	String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
197	196	int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
198	197	// CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
199		- CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
200		- collectServerService.start();
	198	+ CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
	199	+ collectServer.start();
201	200	} catch (Exception e) {
202	201	throw new RuntimeException(e);
203	202	}
...	...	@@ -212,8 +211,8 @@
212	211	String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
213	212	int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
214	213	// CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
215		- CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
216		- collectServerService.start();
	214	+ CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
	215	+ collectServer.start();
217	216	} catch (Exception e) {
218	217	throw new RuntimeException(e);
219	218	}
...	...	@@ -228,8 +227,8 @@
228	227	String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
229	228	int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
230	229	// CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
231		- CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
232		- collectServerService.start();
	230	+ CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
	231	+ collectServer.start();
233	232	} catch (Exception e) {
234	233	throw new RuntimeException(e);
235	234	}
...	...	@@ -244,8 +243,8 @@
244	243	String serviceType = serverConfig.getString(serviceName + ".SERVICE_TYPE");
245	244	int port = serverConfig.getInt(serviceName + ".SERVICE_PORT");
246	245	// CollectBackServerService collectServerService = new CollectBackServerService(serviceName, serviceType, port);
247		- CollectServerService collectServerService = new CollectServerService(serviceName, serviceType, port);
248		- collectServerService.start();
	246	+ CollectServer collectServer = new CollectServer(serviceName, serviceType, port);
	247	+ collectServer.start();
249	248	} catch (Exception e) {
250	249	throw new RuntimeException(e);
251	250	}

...	...	@@ -6,6 +6,7 @@
6	6	import lombok.Getter;
7	7
8	8	import java.util.EnumSet;
	9	+import java.util.List;
9	10
10	11	@Getter
11	12	public enum QueueTypeWorker {
...	...	@@ -44,6 +45,12 @@
44	45	public int saveMessageToTable(BasicMessageDto data) {
45	46	SmsQueueService smsQueueService = (SmsQueueService) QueueService.SMS_QUEUE_SERVICE.getService();
46	47	return smsQueueService.saveMessageToTable(data);
	48	+ }
	49	+
	50	+ @Override
	51	+ public int saveMessageForList(List<BasicMessageDto> list) {
	52	+ SmsQueueService smsQueueService = (SmsQueueService) QueueService.SMS_QUEUE_SERVICE.getService();
	53	+ return smsQueueService.saveMessageForList(list);
47	54	}
48	55
49	56	@Override
...	...	@@ -108,6 +115,12 @@
108	115	}
109	116
110	117	@Override
	118	+ public int saveMessageForList(List<BasicMessageDto> list) {
	119	+ LmsQueueService lmsQueueService = (LmsQueueService) QueueService.LMS_QUEUE_SERVICE.getService();
	120	+ return lmsQueueService.saveMessageForList(list);
	121	+ }
	122	+
	123	+ @Override
111	124	public void memoryEnQueue(BasicMessageDto data) {
112	125	LmsQueueService lmsQueueService = (LmsQueueService) QueueService.LMS_QUEUE_SERVICE.getService();
113	126	lmsQueueService.memoryEnQueue(data);
...	...	@@ -166,6 +179,12 @@
166	179	public int saveMessageToTable(BasicMessageDto data) {
167	180	MmsQueueService mmsQueueService = (MmsQueueService) QueueService.MMS_QUEUE_SERVICE.getService();
168	181	return mmsQueueService.saveMessageToTable(data);
	182	+ }
	183	+
	184	+ @Override
	185	+ public int saveMessageForList(List<BasicMessageDto> list) {
	186	+ MmsQueueService mmsQueueService = (MmsQueueService) QueueService.MMS_QUEUE_SERVICE.getService();
	187	+ return mmsQueueService.saveMessageForList(list);
169	188	}
170	189
171	190	@Override
...	...	@@ -230,6 +249,12 @@
230	249	}
231	250
232	251	@Override
	252	+ public int saveMessageForList(List<BasicMessageDto> list) {
	253	+ KakaoAlarmQueueService kakaoAlarmQueueService = (KakaoAlarmQueueService) QueueService.KAT_QUEUE_SERVICE.getService();
	254	+ return kakaoAlarmQueueService.saveMessageForList(list);
	255	+ }
	256	+
	257	+ @Override
233	258	public void memoryEnQueue(BasicMessageDto data) {
234	259	KakaoAlarmQueueService kakaoAlarmQueueService = (KakaoAlarmQueueService) QueueService.KAT_QUEUE_SERVICE.getService();
235	260	kakaoAlarmQueueService.memoryEnQueue(data);
...	...	@@ -291,6 +316,12 @@
291	316	}
292	317
293	318	@Override
	319	+ public int saveMessageForList(List<BasicMessageDto> list) {
	320	+ KakaoFriendQueueService kakaoFriendQueueService = (KakaoFriendQueueService) QueueService.KFT_QUEUE_SERVICE.getService();
	321	+ return kakaoFriendQueueService.saveMessageForList(list);
	322	+ }
	323	+
	324	+ @Override
294	325	public void memoryEnQueue(BasicMessageDto data) {
295	326	KakaoFriendQueueService kakaoFriendQueueService = (KakaoFriendQueueService) QueueService.KFT_QUEUE_SERVICE.getService();
296	327	kakaoFriendQueueService.memoryEnQueue(data);
...	...	@@ -337,6 +368,7 @@
337	368	public abstract void addQueue(WriteQueue queue);
338	369	public abstract void pushQueue(BasicMessageDto data);
339	370	public abstract int saveMessageToTable(BasicMessageDto data);
	371	+ public abstract int saveMessageForList(List<BasicMessageDto> list);
340	372
341	373	public abstract void memoryEnQueue(BasicMessageDto data);
342	374	public abstract BasicMessageDto memoryDeQueue();

...	...	@@ -3,7 +3,11 @@
3	3	import com.munjaon.server.queue.dto.BasicMessageDto;
4	4	import org.apache.ibatis.annotations.Mapper;
5	5
	6	+import java.util.List;
	7	+
6	8	@Mapper
7	9	public interface KatMapper {
8	10	int insert(BasicMessageDto messageDto);
	11	+ int insertForList(List<BasicMessageDto> list);
	12	+ int insertGroupForList(List<BasicMessageDto> list);
9	13	}

...	...	@@ -89,27 +89,28 @@
89	89	}
90	90
91	91	public boolean isTruncateQueue(int maxWriteCount) {
92		- boolean truncate = false;
93	92	synchronized (lockObject) {
94	93	if (this.writeCounter >= maxWriteCount) {
95	94	if (this.writeCounter == this.readCounter) {
96		- truncate = true;
	95	+ return true;
97	96	}
	97	+ return false;
98	98	}
	99	+ return false;
99	100	}
100		-
101		- return truncate;
102	101	}
103	102
104	103	public boolean isWriteLimit(int maxWriteCount) {
105		- boolean isLimit = false;
106	104	synchronized (lockObject) {
107	105	if (this.writeCounter >= maxWriteCount) {
108		- isLimit = true;
	106	+ return true;
109	107	}
	108	+ return false;
110	109	}
	110	+ }
111	111
112		- return isLimit;
	112	+ public boolean isRemainReport() {
	113	+ return this.writeCounter > this.readCounter;
113	114	}
114	115
115	116	public void truncateQueue() throws Exception {
...	...	@@ -124,26 +125,24 @@
124	125	}
125	126
126	127	private void readHeader() throws Exception {
127		- synchronized (lockObject) {
128		- initHeadBuffer();
129		- this.channel.position(0);
130		- this.channel.read(this.headBuffer);
131		- this.byteArray = new byte[ReportConfig.USER_ID_LENGTH];
132		- // USER_ID
133		- this.headBuffer.position(ReportConfig.USER_ID_POSITION);
134		- this.headBuffer.get(this.byteArray);
135		- this.userId = (new String(this.byteArray)).trim();
136		- // 쓰기 카운트 가져오기
137		- this.byteArray = new byte[ReportConfig.WRITE_COUNT_LENGTH];
138		- this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
139		- this.headBuffer.get(this.byteArray);
140		- this.writeCounter = Integer.parseInt((new String(this.byteArray)).trim());
141		- // 읽기 카운트 가져오기
142		- this.byteArray = new byte[ReportConfig.READ_COUNT_LENGTH];
143		- this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
144		- this.headBuffer.get(this.byteArray);
145		- this.readCounter = Integer.parseInt((new String(this.byteArray)).trim());
146		- }
	128	+ initHeadBuffer();
	129	+ this.channel.position(0);
	130	+ this.channel.read(this.headBuffer);
	131	+ this.byteArray = new byte[ReportConfig.USER_ID_LENGTH];
	132	+ // USER_ID
	133	+ this.headBuffer.position(ReportConfig.USER_ID_POSITION);
	134	+ this.headBuffer.get(this.byteArray);
	135	+ this.userId = (new String(this.byteArray)).trim();
	136	+ // 쓰기 카운트 가져오기
	137	+ this.byteArray = new byte[ReportConfig.WRITE_COUNT_LENGTH];
	138	+ this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
	139	+ this.headBuffer.get(this.byteArray);
	140	+ this.writeCounter = Integer.parseInt((new String(this.byteArray)).trim());
	141	+ // 읽기 카운트 가져오기
	142	+ this.byteArray = new byte[ReportConfig.READ_COUNT_LENGTH];
	143	+ this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
	144	+ this.headBuffer.get(this.byteArray);
	145	+ this.readCounter = Integer.parseInt((new String(this.byteArray)).trim());
147	146	}
148	147
149	148	public void addReadCounter() throws Exception {
...	...	@@ -151,30 +150,20 @@
151	150	/* 읽기 카운트 증가 */
152	151	this.readCounter = this.readCounter + 1;
153	152
154		- initHeadBuffer();
155		- this.channel.position(ReportConfig.USER_ID_POSITION);
156		- this.headBuffer.put(this.userId.getBytes());
157		- this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
158		- this.headBuffer.put(Integer.toString(this.writeCounter).getBytes());
159		- this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
160		- this.headBuffer.put(Integer.toString(this.readCounter).getBytes());
161		- this.headBuffer.flip();
162		- this.channel.write(this.headBuffer);
	153	+ writeHeader();
163	154	}
164	155	}
165	156
166	157	private void writeHeader() throws Exception {
167		- synchronized (lockObject) {
168		- initHeadBuffer();
169		- this.channel.position(ReportConfig.USER_ID_POSITION);
170		- this.headBuffer.put(this.userId.getBytes());
171		- this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
172		- this.headBuffer.put(Integer.toString(this.writeCounter).getBytes());
173		- this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
174		- this.headBuffer.put(Integer.toString(this.readCounter).getBytes());
175		- this.headBuffer.flip();
176		- this.channel.write(this.headBuffer);
177		- }
	158	+ initHeadBuffer();
	159	+ this.channel.position(ReportConfig.USER_ID_POSITION);
	160	+ this.headBuffer.put(this.userId.getBytes());
	161	+ this.headBuffer.position(ReportConfig.WRITE_COUNT_POSITION);
	162	+ this.headBuffer.put(Integer.toString(this.writeCounter).getBytes());
	163	+ this.headBuffer.position(ReportConfig.READ_COUNT_POSITION);
	164	+ this.headBuffer.put(Integer.toString(this.readCounter).getBytes());
	165	+ this.headBuffer.flip();
	166	+ this.channel.write(this.headBuffer);
178	167	}
179	168
180	169	private void initHeadBuffer() {

...	...	@@ -9,6 +9,9 @@
9	9	import lombok.RequiredArgsConstructor;
10	10	import lombok.extern.slf4j.Slf4j;
11	11	import org.springframework.stereotype.Service;
	12	+import org.springframework.transaction.annotation.Transactional;
	13	+
	14	+import java.util.List;
12	15
13	16	@Slf4j
14	17	@Service
...	...	@@ -64,6 +67,13 @@
64	67	}
65	68
66	69	@Override
	70	+ @Transactional
	71	+ public int saveMessageForList(List<BasicMessageDto> list) {
	72	+ katMapper.insertGroupForList(list);
	73	+ return katMapper.insertForList(list);
	74	+ }
	75	+
	76	+ @Override
67	77	public void memoryEnQueue(BasicMessageDto data) {
68	78	memoryQueue.memoryEnQueue(data);
69	79	}

...	...	@@ -3,6 +3,8 @@
3	3	import com.munjaon.server.queue.dto.BasicMessageDto;
4	4	import com.munjaon.server.queue.pool.WriteQueue;
5	5
	6	+import java.util.List;
	7	+
6	8	public interface QueueAction {
7	9	int getQueueSize();
8	10	boolean isExistQueue(String name);
...	...	@@ -10,6 +12,7 @@
10	12	void addQueue(WriteQueue queue);
11	13	void pushQueue(BasicMessageDto data);
12	14	int saveMessageToTable(BasicMessageDto data);
	15	+ int saveMessageForList(List<BasicMessageDto> list);
13	16
14	17	void memoryEnQueue(BasicMessageDto data);
15	18	BasicMessageDto memoryDeQueue();

...	...	@@ -4,6 +4,7 @@
4	4	import lombok.RequiredArgsConstructor;
5	5	import lombok.extern.slf4j.Slf4j;
6	6	import org.springframework.beans.factory.annotation.Value;
	7	+import org.springframework.scheduling.annotation.Scheduled;
7	8	import org.springframework.stereotype.Component;
8	9
9	10	@Slf4j
...	...	@@ -19,7 +20,7 @@
19	20	/* 사용자 설정 테이블 마지막 업데이트 시간 */
20	21	private String config_last_modified_time = null;
21	22
22		-// @Scheduled(cron="0/5 * * * * *")
	23	+ @Scheduled(cron="0/5 * * * * *")
23	24	public void doService() throws Exception {
24	25	doMemberService();
25	26	}

...	...	@@ -4,10 +4,16 @@
4	4	/* 서버 타임아웃 체크 시간 */
5	5	public static final int CYCLE_SOCKET_TIMEOUT = 3000;
6	6	/* 서버 연결후 로그인 만료 시간 */
7		- public static final int LIMIT_BIND_TIMEOUT = 5000;
	7	+ public static final int LIMIT_BIND_TIMEOUT = 3000;
8	8	/* Session Check 만료 시간 */
9	9	public static final int LIMIT_LINK_CHECK_TIMEOUT = 10000;
10	10
11	11	/* 서버 프로퍼티 reload interval 시간 */
12	12	public static final Long INTERVAL_PROPERTY_RELOAD_TIME = 3000L;
	13	+ /* 사용자 정보 조회 체크 시간 */
	14	+ public static final long USER_STATUS_CYCLE_TIME = 60000;
	15	+ /* Deliver Thread 실행 시간 */
	16	+ public static final long DELIVER_EXEC_CYCLE_TIME = 5000;
	17	+ /* Report Thread 실행 시간 */
	18	+ public static final long REPORT_EXEC_CYCLE_TIME = 5000;
13	19	}

...	...	@@ -24,7 +24,10 @@
24	24	private String remoteIP;
25	25	/* 요금제(선불 : P / 후불 : A) */
26	26	private final String feeType = "A";
27		- private int command; //요청 command
	27	+ /* 요청 command */
	28	+ private int command;
	29	+ /* 요청을 처리중인지 여부 */
	30	+ private boolean isRunningMode;
28	31
29	32	private MemberDto memberDto;
30	33

...	...	@@ -21,6 +21,9 @@
21	21	private ReportQueue reportQueue; //ReportQueue
22	22	private MemberDto memberDto; //사용자 정보
23	23	private int command; //요청 command
	24	+ private int maxWriteCount; //요청 command
	25	+ /* 요청을 처리중인지 여부 */
	26	+ private boolean isRunningMode;
24	27
25	28	public int isAlive() {
26	29	if (isLogin) {

...	...	@@ -1,34 +1,31 @@
1	1	package com.munjaon.server.server.sample;
2	2
3		-import java.util.ArrayList;
4		-import java.util.List;
5	3	import java.util.concurrent.ExecutionException;
6	4	import java.util.concurrent.ExecutorService;
7	5	import java.util.concurrent.Executors;
8		-import java.util.concurrent.Future;
9	6
10	7	public class Main {
11	8	public static void main(String[] args) throws InterruptedException, ExecutionException {
12	9	ExecutorService e = Executors.newFixedThreadPool(5);
13	10	// 리턴 값이 필요 없는 경우
14		-// for (int i = 0; i < 5; i++) {
15		-// e.execute(new MyRunnable(i * 20));
16		-// }
	11	+ for (int i = 0; i < 5; i++) {
	12	+ e.execute(new MyRunnable(i * 20));
	13	+ }
17	14	// 작업을 기다려야 할 경우
18		- //e.shutdown();
	15	+ e.shutdown();
19	16
20	17	// 리턴 값이 필요한 경우
21		- List<Future<Integer>> l = new ArrayList<>();
22		- for (int i = 0; i < 5; i++) {
23		- Future<Integer> f = e.submit(new MyCallable(i * 20));
24		- l.add(f);
25		- }
26		-
27		- // 작업이 완료 되길 기다려야 할 경우
28		- int n = 0;
29		- for (int i = 0; i < 5; i++) {
30		- Future<Integer> f = l.get(i);
31		- n += f.get();
32		- }
	18	+// List<Future<Integer>> l = new ArrayList<>();
	19	+// for (int i = 0; i < 5; i++) {
	20	+// Future<Integer> f = e.submit(new MyCallable(i * 20));
	21	+// l.add(f);
	22	+// }
	23	+//
	24	+// // 작업이 완료 되길 기다려야 할 경우
	25	+// int n = 0;
	26	+// for (int i = 0; i < 5; i++) {
	27	+// Future<Integer> f = l.get(i);
	28	+// n += f.get();
	29	+// }
33	30	}
34	31	}

...	...	@@ -7,8 +7,9 @@
7	7	}
8	8
9	9	public void run() {
	10	+ System.out.println("SendReadTask start : " + Thread.currentThread().getName());
10	11	for (int i = 0; i < 20; i++) {
11		- System.out.println(s + " : MyRunnable");
	12	+ System.out.println(s + " : MyRunnable : " + Thread.currentThread().getName());
12	13	System.out.println(i + s);
13	14	try {
14	15	Thread.sleep(1000L);

...	...	@@ -4,14 +4,16 @@
4	4	import com.munjaon.server.server.dto.ConnectUserDto;
5	5	import com.munjaon.server.server.queue.CollectUserQueue;
6	6	import com.munjaon.server.server.task.CollectReadTask;
	7	+import com.munjaon.server.server.task.SendReadTask;
	8	+import com.munjaon.server.server.task.StatusCheckTask;
7	9	import com.munjaon.server.util.LogUtil;
8	10	import lombok.Getter;
9	11	import org.json.simple.JSONObject;
10	12
11	13	import java.io.IOException;
	14	+import java.net.InetAddress;
12	15	import java.net.InetSocketAddress;
13	16	import java.net.Socket;
14		-import java.net.SocketAddress;
15	17	import java.nio.channels.SelectionKey;
16	18	import java.nio.channels.Selector;
17	19	import java.nio.channels.ServerSocketChannel;
...	...	@@ -21,16 +23,23 @@
21	23	import java.util.ArrayList;
22	24	import java.util.Iterator;
23	25	import java.util.List;
24		-import java.util.Map;
25		-import java.util.concurrent.*;
	26	+import java.util.concurrent.ExecutionException;
	27	+import java.util.concurrent.ExecutorService;
	28	+import java.util.concurrent.Executors;
	29	+import java.util.concurrent.Future;
26	30
27	31	public class CollectServerService extends Service {
28	32	private final InetSocketAddress listenAddress;
29	33	private CollectThreadService threadService;
	34	+ private StatusThreadService statusThreadService;
30	35	private CollectUserQueue collectUserQueue = CollectUserQueue.getInstance();
	36	+
31	37	private Selector selector;
32	38	private final String serviceType;
33	39	private int readMaxCore;
	40	+
	41	+ private long USER_STATUS_LAST_CHECK_TIME = System.currentTimeMillis();
	42	+ private static final long USER_STATUS_CYCLE_TIME = 60000;
34	43
35	44	public CollectServerService(String serviceName, String serviceType, int port) {
36	45	super(serviceName);
...	...	@@ -44,17 +53,21 @@
44	53	QueueTypeWorker worker = QueueTypeWorker.find(this.serviceType);
45	54	if (worker != null && worker.getQueueSize() > 0) {
46	55	this.IS_READY_YN = true;
	56	+ saveSystemLog("COLLECT_SERVER_SERVICE : QUEUE IS READY ... ...");
47	57	} else {
48	58	this.IS_READY_YN = false;
	59	+ saveSystemLog("COLLECT_SERVER_SERVICE : QUEUE IS NOT READY ... ...");
49	60	}
50		- saveSystemLog("CollectServerService ready : " + this.IS_READY_YN);
51	61	}
52	62
53	63	@Override
54	64	public void initResources() {
55	65	try {
	66	+ saveSystemLog("COLLECT_SERVER_SERVICE : RESOURCES INITIALIZING ... ...");
56	67	initCollectChannel();
57	68	threadService = new CollectThreadService(readMaxCore, this.serviceType, logger);
	69	+ statusThreadService = new StatusThreadService(this.serviceType, this.logger);
	70	+ saveSystemLog("COLLECT_SERVER_SERVICE : RESOURCES INITIALIZED ... ...");
58	71	} catch (IOException e) {
59	72	saveSystemLog(e);
60	73	throw new RuntimeException(e);
...	...	@@ -62,6 +75,8 @@
62	75	}
63	76
64	77	private void initCollectChannel() throws IOException {
	78	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SOCKET INITIALIZING ... ...");
	79	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER PORT [" + listenAddress.getPort() + "]");
65	80	selector = Selector.open();
66	81	/* 채널 생성 */
67	82	ServerSocketChannel serverChannel = ServerSocketChannel.open();
...	...	@@ -71,6 +86,7 @@
71	86	serverChannel.socket().bind(listenAddress);
72	87	/* 채널에 accept 대기 설정 */
73	88	serverChannel.register(selector, SelectionKey.OP_ACCEPT);
	89	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SOCKET INITIALIZED ... ...");
74	90	}
75	91
76	92	private void closeCollectChannel() throws IOException {
...	...	@@ -79,22 +95,56 @@
79	95
80	96	@Override
81	97	public void releaseResources() {
	98	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER RESOURCE RELEASING ... ...");
82	99	try {
83	100	closeCollectChannel();
84	101	threadService.close();
	102	+ statusThreadService.close();
85	103	} catch (IOException e) {
86	104	saveSystemLog(e);
87	105	throw new RuntimeException(e);
88	106	}
	107	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER RESOURCE RELEASED ... ...");
89	108	}
90	109
91	110	@Override
92	111	public void doService() {
	112	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SERVICE STARTED ... ...");
93	113	while (isRun()) {
94	114	try {
95	115	execInterest();
	116	+ execUserStatus();
96	117	} catch (Exception e) {
97	118	throw new RuntimeException(e);
	119	+ }
	120	+ }
	121	+ saveSystemLog("COLLECT_SERVER_SERVICE : SERVER SERVICE STOPPED ... ...");
	122	+ }
	123	+
	124	+ private void execInterest_bak() throws IOException {
	125	+ if (selector.select(1000) == 0) {
	126	+ return ;
	127	+ }
	128	+ Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
	129	+ while (keys.hasNext()) {
	130	+ SelectionKey key = keys.next();
	131	+ /* 키 셋에서 제거. */
	132	+ keys.remove();
	133	+
	134	+ if (key.isValid()) {
	135	+ if (key.isAcceptable()) { // 접속일 경우..
	136	+ saveSystemLog("CONNECTION IS ACCEPTABLE ... ...");
	137	+ accept(selector, key);
	138	+ } else if (key.isReadable()) { // 수신일 경우..
	139	+ ConnectUserDto connectUserDto = (ConnectUserDto) key.attachment();
	140	+ if (connectUserDto == null \|\| connectUserDto.isRunningMode()) {
	141	+ continue;
	142	+ }
	143	+ threadService.execute(new SendReadTask(selector, key, this.serviceType, logger));
	144	+// threadService.submit(selector, key, 2);
	145	+ }
	146	+ } else {
	147	+ expireConnectUser(key);
98	148	}
99	149	}
100	150	}
...	...	@@ -112,10 +162,9 @@
112	162
113	163	if (key.isValid()) {
114	164	if (key.isAcceptable()) { // 접속일 경우..
115		- saveSystemLog("isAcceptable");
	165	+ saveSystemLog("CONNECTION IS ACCEPTABLE ... ...");
116	166	accept(selector, key);
117	167	} else if (key.isReadable()) { // 수신일 경우..
118		- saveSystemLog("isReadable");
119	168	Future<ConnectUserDto> future = threadService.submit(new CollectReadTask(selector, key, this.serviceType, logger));
120	169	list.add(future);
121	170	// threadService.submit(selector, key, 2);
...	...	@@ -132,11 +181,16 @@
132	181	} catch (ExecutionException e) {
133	182	}
134	183
135		- if (connectUserDto == null) {
136		- saveSystemLog("Future : " + future);
137		- } else {
138		- saveSystemLog("Future : " + connectUserDto.toString());
	184	+ if (connectUserDto != null) {
	185	+ saveSystemLog("[READ USER : " + connectUserDto.toString() + "]");
139	186	}
	187	+ }
	188	+ }
	189	+
	190	+ private void execUserStatus() throws IOException {
	191	+ if (System.currentTimeMillis() - USER_STATUS_LAST_CHECK_TIME > USER_STATUS_CYCLE_TIME) {
	192	+ statusThreadService.execute(new StatusCheckTask(this.serviceType, logger));
	193	+ USER_STATUS_LAST_CHECK_TIME = System.currentTimeMillis();
140	194	}
141	195	}
142	196
...	...	@@ -149,10 +203,10 @@
149	203	channel.configureBlocking(false);
150	204	/* 소켓 취득 */
151	205	Socket socket = channel.socket();
152		- SocketAddress remoteAddr = socket.getRemoteSocketAddress();
153		- saveSystemLog("Connected to: " + remoteAddr);
	206	+ InetAddress inetAddress = socket.getInetAddress();
	207	+ saveSystemLog("[CLIENT CONNECTION IP : " + inetAddress.getHostAddress() + "]");
154	208	// Socket 채널을 channel에 수신 등록한다
155		- channel.register(selector, SelectionKey.OP_READ, ConnectUserDto.builder().serviceType(this.serviceType).lastTrafficTime(System.currentTimeMillis()).remoteIP(remoteAddr.toString()).build());
	209	+ channel.register(selector, SelectionKey.OP_READ, ConnectUserDto.builder().serviceType(this.serviceType).lastTrafficTime(System.currentTimeMillis()).remoteIP(inetAddress.getHostAddress()).build());
156	210	} catch (Exception e) {
157	211	throw new RuntimeException(e);
158	212	}
...	...	@@ -166,6 +220,7 @@
166	220	SocketChannel channel = (SocketChannel) key.channel();
167	221	ConnectUserDto userDto = (ConnectUserDto) key.attachment();
168	222	if (userDto != null && userDto.getUserId() != null) {
	223	+ saveSystemLog("[CLIENT USER IS DISCONNECT : " + userDto.toString() + "]");
169	224	collectUserQueue.removeUser(this.serviceType, userDto.getUserId());
170	225	// connectUserMap.remove(userDto.getUserId());
171	226	key.attach(null);
...	...	@@ -184,27 +239,22 @@
184	239	return null;
185	240	}
186	241
187		- private static class CollectThreadService {
	242	+ private static class StatusThreadService {
188	243	@Getter
189	244	private String serviceType;
190	245	@Getter
191		- private final int maxCore;
	246	+ private final int maxCore = 1;
192	247	private final ExecutorService executor;
193		- private final Map<String, ConnectUserDto> connectUserMap = new ConcurrentHashMap<>();
194	248	private final LogUtil logger;
195	249
196		- public CollectThreadService(String serviceType, LogUtil logger) {
197		- this(Runtime.getRuntime().availableProcessors(), serviceType, logger);
198		- }
199		-
200		- public CollectThreadService(int maxCore, String serviceType, LogUtil logger) {
201		- this.maxCore = maxCore;
	250	+ public StatusThreadService(String serviceType, LogUtil logger) {
202	251	this.executor = Executors.newFixedThreadPool(maxCore);
203	252	this.logger = logger;
	253	+ saveSystemLog("[STATUS_TASK_THREAD_POOL : " + maxCore + "]");
204	254	}
205	255
206		- public Future<ConnectUserDto> submit(CollectReadTask collectReadTask) {
207		- return executor.submit(collectReadTask);
	256	+ public void execute(StatusCheckTask statusCheckTask) {
	257	+ executor.execute(statusCheckTask);
208	258	}
209	259
210	260	private void saveSystemLog(Object obj) {
...	...	@@ -229,7 +279,61 @@
229	279
230	280	public void close() {
231	281	List<Runnable> unfinishedTasks = executor.shutdownNow();
232		- connectUserMap.clear();
	282	+ if (!unfinishedTasks.isEmpty()) {
	283	+ saveSystemLog("Not all tasks finished before calling close: " + unfinishedTasks.size());
	284	+ }
	285	+ }
	286	+ }
	287	+
	288	+ private static class CollectThreadService {
	289	+ @Getter
	290	+ private String serviceType;
	291	+ @Getter
	292	+ private final int maxCore;
	293	+ private final ExecutorService executor;
	294	+ private final LogUtil logger;
	295	+
	296	+ public CollectThreadService(String serviceType, LogUtil logger) {
	297	+ this(Runtime.getRuntime().availableProcessors(), serviceType, logger);
	298	+ }
	299	+
	300	+ public CollectThreadService(int maxCore, String serviceType, LogUtil logger) {
	301	+ this.maxCore = maxCore;
	302	+ this.executor = Executors.newFixedThreadPool(maxCore);
	303	+ this.logger = logger;
	304	+ saveSystemLog("[COLLECT_TASK_THREAD_POOL : " + maxCore + "]");
	305	+ }
	306	+
	307	+ public Future<ConnectUserDto> submit(CollectReadTask collectReadTask) {
	308	+ return executor.submit(collectReadTask);
	309	+ }
	310	+
	311	+ public void execute(SendReadTask sendReadTask) {
	312	+ executor.execute(sendReadTask);
	313	+ }
	314	+
	315	+ private void saveSystemLog(Object obj) {
	316	+ saveLog(obj, true);
	317	+ }
	318	+
	319	+ private void saveLog(Object obj) {
	320	+ saveLog(obj, false);
	321	+ }
	322	+
	323	+ private void saveLog(Object obj, boolean isConsoleOutput) {
	324	+ if (isConsoleOutput) {
	325	+ System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern(LOG_DATE_FORMAT)) + " {{" + serviceType + "}} " + obj);
	326	+ }
	327	+
	328	+ if (logger == null) {
	329	+ return;
	330	+ }
	331	+
	332	+ logger.log(obj);
	333	+ }
	334	+
	335	+ public void close() {
	336	+ List<Runnable> unfinishedTasks = executor.shutdownNow();
233	337	if (!unfinishedTasks.isEmpty()) {
234	338	saveSystemLog("Not all tasks finished before calling close: " + unfinishedTasks.size());
235	339	}

...	...	@@ -3,14 +3,18 @@
3	3	import com.munjaon.server.queue.dto.BasicMessageDto;
4	4	import com.munjaon.server.queue.enums.QueueTypeWorker;
5	5	import com.munjaon.server.queue.pool.ReadQueue;
	6	+import com.munjaon.server.queue.pool.SerialQueuePool;
6	7	import com.munjaon.server.queue.pool.WriteQueue;
7	8	import com.munjaon.server.util.CommonUtil;
	9	+import com.munjaon.server.util.MessageUtil;
8	10	import com.munjaon.server.util.ServiceUtil;
9	11	import org.json.simple.JSONObject;
10	12
11	13	import java.io.IOException;
12	14	import java.time.LocalDateTime;
13	15	import java.time.format.DateTimeFormatter;
	16	+import java.util.ArrayList;
	17	+import java.util.List;
14	18
15	19	public class QueueServerService extends Service {
16	20	/** 큐모드 설정(WAIT : 파일에 쓰기모드만 / DB : DB에 적재) */
...	...	@@ -21,6 +25,7 @@
21	25	private long QUEUE_INIT_CHECK_TIME = 0;
22	26	/** Commit 누적 카운트 */
23	27	private long SUM_COMMIT_COUNT = 0;
	28	+ SerialQueuePool queueInstance = SerialQueuePool.getInstance();
24	29	/* 쓰기큐 */
25	30	private WriteQueue writeQueue;
26	31	private ReadQueue readQueue;
...	...	@@ -49,7 +54,7 @@
49	54
50	55	@Override
51	56	public void checkReady() {
52		- this.IS_READY_YN = true;
	57	+ this.IS_READY_YN = queueInstance.isReady();
53	58	}
54	59
55	60	@Override
...	...	@@ -109,6 +114,8 @@
109	114	}
110	115	// 큐초기화 대상이면
111	116	if (isQueueInit) {
	117	+ /* 큐 백업 */
	118	+ writeQueue.backupQueue();
112	119	/* 커밋 카운트 초기화 */
113	120	SUM_COMMIT_COUNT = 0;
114	121	writeQueue.truncateQueue();
...	...	@@ -158,6 +165,8 @@
158	165	isQueueInit = true;
159	166	}
160	167	if (isQueueInit) {
	168	+ /* 큐 백업 */
	169	+ writeQueue.backupQueue();
161	170	/* 커밋 카운트 초기화 */
162	171	SUM_COMMIT_COUNT = 0;
163	172	// 큐를 초기화한다.
...	...	@@ -172,6 +181,34 @@
172	181
173	182	private void messageService() throws Exception {
174	183	int DB_PROC_COUNT = 0;
	184	+ List<BasicMessageDto> list = new ArrayList<>();
	185	+ for (int loopCnt = 0; loopCnt < ServiceUtil.COMMIT_COUNT; loopCnt++) {
	186	+ BasicMessageDto messageDto = readQueue.popMessageFromBuffer();
	187	+ if (messageDto == null) {
	188	+ break;
	189	+ }
	190	+ /* MSG ID 채번 */
	191	+ String msgId = queueInstance.getSerialNumber();
	192	+ msgId = MessageUtil.makeMessageKey(msgId);
	193	+ String msgGroupId = msgId.replace("MSGID", "MGRP");
	194	+ messageDto.setId(msgId);
	195	+ messageDto.setMsgGroupID(msgGroupId);
	196	+ list.add(messageDto);
	197	+ DB_PROC_COUNT++;
	198	+ SUM_COMMIT_COUNT++;
	199	+ }
	200	+
	201	+ // DB 처리한 카운트에 대한 처리
	202	+ if (DB_PROC_COUNT > 0) {
	203	+ worker.saveMessageForList(list);
	204	+ Thread.sleep(10);
	205	+ } else {
	206	+ Thread.sleep(100);
	207	+ }
	208	+ }
	209	+
	210	+ private void messageService_bak() throws Exception {
	211	+ int DB_PROC_COUNT = 0;
175	212	for (int loopCnt = 0; loopCnt < ServiceUtil.COMMIT_COUNT; loopCnt++) {
176	213	BasicMessageDto messageDto = readQueue.popMessageFromBuffer();
177	214	if (messageDto == null) {

...	...	@@ -17,10 +17,12 @@
17	17	private final ReportUserQueue reportUserQueue = ReportUserQueue.getInstance();
18	18	private QueueThreadService threadService;
19	19	private int queueMaxCore;
	20	+ private int maxWriteCount;
20	21
21	22	public ReportQueueServerService(String serviceName) {
22	23	super(serviceName);
23	24	this.queueMaxCore = Integer.parseInt(getProp("QUEUE_MAX_CORE").trim());
	25	+ this.maxWriteCount = Integer.parseInt(getProp("MAX_WRITE_COUNT").trim());
24	26	}
25	27
26	28	@Override
...	...	@@ -43,7 +45,7 @@
43	45	while (isRun()) {
44	46	try {
45	47	doQueueService();
46		- Thread.sleep(100);
	48	+ Thread.sleep(10);
47	49	} catch (Exception e) {
48	50	throw new RuntimeException(e);
49	51	}
...	...	@@ -57,6 +59,7 @@
57	59	}
58	60
59	61	for (ReportUserDto reportUserDto : reportUserList) {
	62	+ reportUserDto.setMaxWriteCount(this.maxWriteCount);
60	63	threadService.execute(new ReportQueueTask(reportUserDto, logger));
61	64	}
62	65	}

...	...	@@ -62,7 +62,7 @@
62	62	public void initResources() {
63	63	try {
64	64	initReportChannel();
65		- threadService = new ReadThreadService(8, logger);
	65	+ threadService = new ReadThreadService(readMaxCore, logger);
66	66	} catch (IOException e) {
67	67	saveSystemLog(e);
68	68	throw new RuntimeException(e);
...	...	@@ -142,7 +142,6 @@
142	142	try {
143	143	ReportDto reportDto = reportQueue.popReportFromQueue();
144	144	if (reportDto == null) {
145		- saveSystemLog("reportQueue.popReportFromQueue() : null");
146	145	continue;
147	146	}
148	147	saveSystemLog("reportQueue.popReportFromQueue() : " + reportDto.toString());

...	...	@@ -36,6 +36,16 @@
36	36	}
37	37
38	38	ReportQueue reportQueue = reportUserDto.getReportQueue();
	39	+ /* 리포트큐에 최대 크기까지 쓰고 모두 리포트는 전송했는지 체크 : 테스트후 적용 */
	40	+// if (reportQueue.isWriteLimit(reportUserDto.getMaxWriteCount())) {
	41	+// if (reportQueue.isTruncateQueue(reportUserDto.getMaxWriteCount())) {
	42	+// try {
	43	+// reportQueue.truncateQueue();
	44	+// } catch (Exception e) {}
	45	+// } else {
	46	+// return;
	47	+// }
	48	+// }
39	49	ReportService reportService = (ReportService) CacheService.REPORT_SERVICE.getService();
40	50	List<ReportDto> list = reportService.getReportListForUser(reportUserDto.getUserId());
41	51	if (list == null \|\| list.isEmpty()) {

...	...	@@ -87,20 +87,40 @@
87	87	private void recvReport(SocketChannel channel, ByteBuffer headBuffer) {
88	88	try {
89	89	ByteBuffer bodyBuffer = ByteBuffer.allocate(Report.REPORT_ACK_BODY_LENGTH);
90		- saveSystemLog("recv report");
91	90	int size = channel.read(bodyBuffer);
92		- if (size > 0) {
93		- ReportQueue reportQueue = reportUserDto.getReportQueue();
94		- reportUserDto.updateLastTrafficTime();
95		- if (reportQueue != null) {
96		- reportQueue.addReadCounter();
97		- }
	91	+ if (size != Report.REPORT_ACK_BODY_LENGTH) {
	92	+ return;
	93	+ }
	94	+
	95	+ saveSystemLog("recv report");
	96	+ ReportQueue reportQueue = reportUserDto.getReportQueue();
	97	+ reportUserDto.updateLastTrafficTime();
	98	+ if (reportQueue != null) {
	99	+ reportQueue.addReadCounter();
98	100	}
99	101	} catch (Exception e) {
100	102	e.printStackTrace();
101	103	}
102	104	}
103	105
	106	+ private String checkBind(MemberDto memberDto, String id, String pwd) {
	107	+ if (id == null \|\| pwd == null) {
	108	+ return "50";
	109	+ }
	110	+ if (reportUserQueue.isExist(id)) {
	111	+ return "60";
	112	+ }
	113	+ if (memberDto == null \|\| !pwd.equals(memberDto.getAccessKey())) {
	114	+ return "20";
	115	+ }
	116	+ /* 회원 사용 상태 */
	117	+ if (memberDto.getMberSttus() == null \|\| "N".equals(memberDto.getMberSttus())) {
	118	+ return "30";
	119	+ }
	120	+
	121	+ return "00";
	122	+ }
	123	+
104	124	private void recvBind(SocketChannel channel, ByteBuffer headBuffer) {
105	125	String resultCode = "00";
106	126	try {
...	...	@@ -111,6 +131,77 @@
111	131
112	132	String id = Bind.getBindId(bindBuffer);
113	133	String pwd = Bind.getBindPwd(bindBuffer);
	134	+
	135	+ MemberService svc = (MemberService) CacheService.LOGIN_SERVICE.getService();
	136	+ MemberDto memberDto = null;
	137	+ if (svc != null) {
	138	+ memberDto = svc.get(id);
	139	+ }
	140	+ saveSystemLog("[BIND REQUEST] [ID : " + id + ", PWD : " + pwd + "]");
	141	+ /* Bind Check */
	142	+ resultCode = checkBind(memberDto, id, pwd);
	143	+
	144	+ /* 접속 IP 체크 */
	145	+ if ("00".equals(resultCode)) {
	146	+ boolean isPermit = false;
	147	+ if (memberDto.getIpLimitYn() == null \|\| "Y".equals(memberDto.getIpLimitYn())) {
	148	+ saveSystemLog("connectUserDto.getRemoteIP() : " + reportUserDto.getRemoteIP());
	149	+ saveSystemLog("Customize Toolbar... : " + memberDto.getAllowIpBasic());
	150	+ saveSystemLog("memberDto.getAllowIpExtend() : " + memberDto.getAllowIpExtend());
	151	+ if (memberDto.getAllowIpBasic() != null && reportUserDto.getRemoteIP().equals(memberDto.getAllowIpBasic())) {
	152	+ isPermit = true;
	153	+ }
	154	+ if (memberDto.getAllowIpExtend() != null && reportUserDto.getRemoteIP().equals(memberDto.getAllowIpExtend())) {
	155	+ isPermit = true;
	156	+ }
	157	+ } else {
	158	+ isPermit = true;
	159	+ }
	160	+ if (isPermit) {
	161	+ resultCode = "00";
	162	+ } else {
	163	+ resultCode = "40";
	164	+ }
	165	+ }
	166	+
	167	+ if ("00".equals(resultCode)) {
	168	+ reportUserDto.setUserId(id);
	169	+ reportUserDto.setLogin(true);
	170	+ reportUserDto.setMemberDto(memberDto);
	171	+ /* 리포트 큐 생성 */
	172	+ ReportQueue reportQueue = new ReportQueue(reportUserDto.getQueuePath(), reportUserDto.getUserId());
	173	+ reportUserDto.setReportQueue(reportQueue);
	174	+ /* 사용자 Pool에 저장 */
	175	+ reportUserQueue.putUser(reportUserDto);
	176	+ /* 세션통신 시간 업데이트 */
	177	+ reportUserDto.updateLastTrafficTime();
	178	+ }
	179	+ } catch (Exception e) {
	180	+ resultCode = "10";
	181	+ e.printStackTrace();
	182	+ }
	183	+
	184	+ try {
	185	+ saveSystemLog("Bind ResultCode : " + resultCode);
	186	+ channel.write(Bind.makeBindAckBuffer(resultCode));
	187	+ if ("00".equals(resultCode) == false) {
	188	+ expireConnectUser();
	189	+ }
	190	+ } catch (IOException e) {
	191	+ e.printStackTrace();
	192	+ }
	193	+ }
	194	+
	195	+ private void recvBind_bak(SocketChannel channel, ByteBuffer headBuffer) {
	196	+ String resultCode = "00";
	197	+ try {
	198	+ ByteBuffer bindBuffer = ByteBuffer.allocate(Header.HEADER_LENGTH + Bind.BIND_BODY_LENGTH);
	199	+ ByteBuffer bodyBuffer = ByteBuffer.allocate(Bind.BIND_BODY_LENGTH);
	200	+ channel.read(bodyBuffer);
	201	+ Packet.mergeBuffers(bindBuffer, headBuffer, bodyBuffer);
	202	+
	203	+ String id = Bind.getBindId(bindBuffer);
	204	+ String pwd = Bind.getBindPwd(bindBuffer);
114	205	saveSystemLog("Bind id : " + id);
115	206	saveSystemLog("Bind pwd : " + pwd);
116	207	if (id == null \|\| pwd == null) {

...	...	@@ -4,6 +4,10 @@
4	4	profiles:
5	5	default: local
6	6
	7	+logging:
	8	+ level:
	9	+ root: info
	10	+
7	11	mybatis:
8	12	configuration:
9	13	map-underscore-to-camel-case: true

...	...	@@ -2,7 +2,9 @@
2	2	datasource:
3	3	server:
4	4	driver-class-name: org.mariadb.jdbc.Driver
5		- jdbc-url: jdbc:mariadb://119.193.215.98:3306/mjon_agent_back
	5	+ url: jdbc:mariadb://192.168.0.125:3306/mjon_agent_back
	6	+ jdbc-url: jdbc:mariadb://192.168.0.125:3306/mjon_agent_back
	7	+# jdbc-url: jdbc:mariadb://119.193.215.98:3306/mjon_agent_back
6	8	username: mjonUr_agent
7	9	password: mjagent123$
8	10

Delete comment

...	...	@@ -10,7 +10,7 @@
10	10	<pattern>${LOG_PATTERN}</pattern>
11	11	</encoder>
12	12	</appender>
13		- <logger name="com.munjaon.server" level="DEBUG" />
	13	+ <logger name="com.munjaon.server" level="INFO" />
14	14	<root level="ERROR">
15	15	<appender-ref ref="CONSOLE"/>
16	16	</root>

...	...	@@ -2,6 +2,7 @@
2	2	datasource:
3	3	server:
4	4	driver-class-name: org.mariadb.jdbc.Driver
	5	+ url: jdbc:mariadb://119.193.215.98:3306/mjon_agent
5	6	jdbc-url: jdbc:mariadb://119.193.215.98:3306/mjon_agent
6	7	username: mjonUr_agent
7	8	password: mjagent123$

...	...	@@ -21,6 +21,22 @@
21	21	, BIZ_KAKAO_RESEND_DATA
22	22	, BIZ_KAKAO_RESEND_TYPE
23	23	, BIZ_KAKAO_JSON_FILE
24		- ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '8', 'N', null, null, #{kakaoJsonFile})
	24	+ ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '8', 'N', null, null, #{kakaoJsonFile})
	25	+ </insert>
	26	+
	27	+ <insert id="insertForList" parameterType="java.util.List">
	28	+ INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, MSG_NOTICETALK_SENDER_KEY, MSG_NOTICETALK_TMP_KEY, REQ_DATE, CALL_TO, CALL_FROM, SMS_TXT, BIZ_KAKAO_TITLE, MSG_TYPE, BIZ_KAKAO_RESEND_YN, BIZ_KAKAO_RESEND_DATA, BIZ_KAKAO_RESEND_TYPE, BIZ_KAKAO_JSON_FILE)
	29	+ VALUES
	30	+ <foreach separator="," item="item" collection="list">
	31	+ (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, #{item.kakaoSenderKey}, #{item.kakaoTemplateCode}, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, '8', 'N', null, null, #{item.kakaoJsonFile})
	32	+ </foreach>
	33	+ </insert>
	34	+
	35	+ <insert id="insertGroupForList" parameterType="java.util.List">
	36	+ INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
	37	+ VALUES
	38	+ <foreach separator="," item="item" collection="list">
	39	+ (#{item.msgGroupID}, #{item.userId}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '8', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'Y', '' )
	40	+ </foreach>
25	41	</insert>
26	42	</mapper> (No newline at end of file)

...	...	@@ -20,6 +20,22 @@
20	20	, BIZ_KAKAO_RESEND_DATA
21	21	, BIZ_KAKAO_RESEND_TYPE
22	22	, BIZ_KAKAO_JSON_FILE
23		- ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '9', 'N', null, null, #{kakaoJsonFile})
	23	+ ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, #{kakaoSenderKey}, #{kakaoTemplateCode}, NOW(), #{userReceiver}, #{userSender}, #{userMessage}, #{userSubject}, '9', 'N', null, null, #{kakaoJsonFile})
	24	+ </insert>
	25	+
	26	+ <insert id="insertForList" parameterType="java.util.List">
	27	+ INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, MSG_NOTICETALK_SENDER_KEY, MSG_NOTICETALK_TMP_KEY, REQ_DATE, CALL_TO, CALL_FROM, SMS_TXT, BIZ_KAKAO_TITLE, MSG_TYPE, BIZ_KAKAO_RESEND_YN, BIZ_KAKAO_RESEND_DATA, BIZ_KAKAO_RESEND_TYPE, BIZ_KAKAO_JSON_FILE)
	28	+ VALUES
	29	+ <foreach separator="," item="item" collection="list">
	30	+ (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, #{item.kakaoSenderKey}, #{item.kakaoTemplateCode}, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, '8', 'N', null, null, #{item.kakaoJsonFile})
	31	+ </foreach>
	32	+ </insert>
	33	+
	34	+ <insert id="insertGroupForList" parameterType="java.util.List">
	35	+ INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
	36	+ VALUES
	37	+ <foreach separator="," item="item" collection="list">
	38	+ (#{item.msgGroupID}, #{item.userId}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '9', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'Y', '' )
	39	+ </foreach>
24	40	</insert>
25	41	</mapper> (No newline at end of file)

...	...	@@ -16,6 +16,22 @@
16	16	, SMS_TXT
17	17	, MSG_TYPE
18	18	, CONT_SEQ, FILE_CNT
19		- ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, '0' )
	19	+ ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, '0' )
	20	+ </insert>
	21	+
	22	+ <insert id="insertForList" parameterType="java.util.List">
	23	+ INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, REQ_DATE, CALL_TO, CALL_FROM, SUBJECT, SMS_TXT, MSG_TYPE, CONT_SEQ, FILE_CNT)
	24	+ VALUES
	25	+ <foreach separator="," item="item" collection="list">
	26	+ (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userSubject}, #{item.userMessage}, '6', null, '0' )
	27	+ </foreach>
	28	+ </insert>
	29	+
	30	+ <insert id="insertGroupForList" parameterType="java.util.List">
	31	+ INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
	32	+ VALUES
	33	+ <foreach separator="," item="item" collection="list">
	34	+ (#{item.msgGroupID}, #{item.userId}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '6', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'N', '' )
	35	+ </foreach>
20	36	</insert>
21	37	</mapper> (No newline at end of file)

...	...	@@ -21,6 +21,22 @@
21	21	, FILE_PATH2
22	22	, FILE_PATH3
23	23	, NEO_TYPE
24		- ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, #{userFileCnt}, #{userFileName01}, #{userFileName02}, #{userFileName03}, null)
	24	+ ) VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, NOW(), #{userReceiver}, #{userSender}, #{userSubject}, #{userMessage}, '6', null, #{userFileCnt}, #{userFileName01}, #{userFileName02}, #{userFileName03}, null)
	25	+ </insert>
	26	+
	27	+ <insert id="insertForList" parameterType="java.util.List">
	28	+ INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, REQ_DATE, CALL_TO, CALL_FROM, SUBJECT, SMS_TXT, MSG_TYPE, CONT_SEQ, FILE_CNT, FILE_PATH1, FILE_PATH2, FILE_PATH3, NEO_TYPE)
	29	+ VALUES
	30	+ <foreach separator="," item="item" collection="list">
	31	+ (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, NOW(), #{item.userReceiver}, #{item.userSender}, #{item.userSubject}, #{item.userMessage}, '6', null, #{item.userFileCnt}, #{item.userFileName01}, #{item.userFileName02}, #{item.userFileName03}, null)
	32	+ </foreach>
	33	+ </insert>
	34	+
	35	+ <insert id="insertGroupForList" parameterType="java.util.List">
	36	+ INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
	37	+ VALUES
	38	+ <foreach separator="," item="item" collection="list">
	39	+ (#{item.msgGroupID}, #{item.userId}, #{item.userSender}, #{item.userMessage}, #{item.userSubject}, NOW(), '1', NULL, '6', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, #{item.userFileCnt}, '0.0', NULL, NULL, 'N', '' )
	40	+ </foreach>
25	41	</insert>
26	42	</mapper> (No newline at end of file)

...	...	@@ -15,6 +15,22 @@
15	15	, SUBJECT
16	16	, SMS_TXT
17	17	, MSG_TYPE
18		- )VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, '04', 0, NOW(), #{userReceiver}, #{userSender}, NULL, #{userMessage}, '4' )
	18	+ )VALUES (#{id}, #{msgGroupID}, #{userId}, #{userMsgID}, #{routerSeq}, 0, NOW(), #{userReceiver}, #{userSender}, NULL, #{userMessage}, '4' )
	19	+ </insert>
	20	+
	21	+ <insert id="insertForList" parameterType="java.util.List">
	22	+ INSERT INTO MJ_MSG_DATA (MSG_ID, MSG_GROUP_ID, USER_ID, AGENT_MSG_ID, AGENT_CODE, CUR_STATE, REQ_DATE, CALL_TO, CALL_FROM, SUBJECT, SMS_TXT, MSG_TYPE)
	23	+ VALUES
	24	+ <foreach separator="," item="item" collection="list">
	25	+ (#{item.id}, #{item.msgGroupID}, #{item.userId}, #{item.userMsgID}, #{item.routerSeq}, 0, NOW(), #{item.userReceiver}, #{item.userSender}, NULL, #{item.userMessage}, '4' )
	26	+ </foreach>
	27	+ </insert>
	28	+
	29	+ <insert id="insertGroupForList" parameterType="java.util.List">
	30	+ INSERT INTO MJ_MSG_GROUP_DATA (MSG_GROUP_ID, USER_ID, CALL_FROM, SMS_TXT, SUBJECT, REQ_DATE, MSG_GROUP_CNT, CONECT_MTHD, MSG_TYPE, MSG_KIND, AGENT_CODE, EACH_PRICE, RESERVE_YN, BEF_CASH, BEF_POINT, RECOMM_ID, FILE_CNT, TOT_PRICE, EVENT_YN, DELAY_YN, AT_DELAY_YN, BIZ_KAKAO_RESEND_ORGNL_TXT)
	31	+ VALUES
	32	+ <foreach separator="," item="item" collection="list">
	33	+ (#{item.msgGroupID}, #{item.userId}, #{item.userSender}, #{item.userMessage}, NULL, NOW(), '1', NULL, '4', NULL, #{item.routerSeq}, '0.0', 'N', '0.00', '0', NULL, '0', '0.0', NULL, NULL, 'N', '' )
	34	+ </foreach>
19	35	</insert>
20	36	</mapper> (No newline at end of file)