Merge branch 'lyh-mq' into release

# Conflicts:
#	src/main/java/com/fdkankan/modeling/receiver/RabbitMqListener.java

pom.xml

@@ -22,11 +22,11 @@
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
 		</dependency>
-		<dependency>
-			<groupId>com.fdkankan</groupId>
-			<artifactId>4dkankan-utils-rubber-sheeting</artifactId>
-			<version>3.0.0-SNAPSHOT</version>
-		</dependency>
+<!--		<dependency>-->
+<!--			<groupId>com.fdkankan</groupId>-->
+<!--			<artifactId>4dkankan-utils-rubber-sheeting</artifactId>-->
+<!--			<version>3.0.0-SNAPSHOT</version>-->
+<!--		</dependency>-->
 
 		<dependency>
 			<groupId>com.fdkankan</groupId>

src/main/java/com/fdkankan/modeling/constants/RedisKey.java

@@ -0,0 +1,6 @@
+package com.fdkankan.modeling.constants;
+
+public class RedisKey {
+    public static String modelingKey = "4dkankan:modeling:scaling:hostname:%s";
+    public static String ecsStopKey = "4dkankan:modeling:scaling:hostname:stop:%s";
+}

src/main/java/com/fdkankan/modeling/constants/SysConstants.java

@@ -1,9 +1,12 @@
 package com.fdkankan.modeling.constants;
 
 import com.fdkankan.common.util.FileUtils;
+import com.fdkankan.modeling.entity.MqEcs;
+import com.fdkankan.modeling.service.IMqEcsService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
@@ -12,6 +15,7 @@ import org.springframework.core.env.StandardEnvironment;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
 
 import java.util.Arrays;
 import java.util.HashMap;
@@ -29,10 +33,10 @@ public class SysConstants implements ApplicationContextAware {
 
     public static boolean isResidenceService = true;
 
-    public static volatile Boolean SYSTEM_BUILDING = false;
-    public static volatile Boolean SYSTEM_OFFING = false;
+//    public static volatile Boolean SYSTEM_BUILDING = false;
+//    public static volatile Boolean SYSTEM_OFFING = false;
 
-    private List<String> residenceServices = null;
+//    private List<String> residenceServices = null;
 
     public static final String SYSTEM_PREFIX = "model-center";
 
@@ -50,7 +54,8 @@ public class SysConstants implements ApplicationContextAware {
                 SysConstants.hostName = SysConstants.hostName.trim().replaceAll("\\s","");
             }
             log.error("从文件({})中获取服务器名称:{}", filePath,hostName);
-            initIsResidenceService();
+            String queueName = initIsResidenceService();
+            log.info("initIsResidenceService--hostName:{},queueName:{}",SysConstants.hostName,queueName);
         } catch (Exception e) {
             log.error("从文件中获取服务器名称失败,文件路径{}", filePath);
             e.printStackTrace();
@@ -69,23 +74,39 @@ public class SysConstants implements ApplicationContextAware {
     /**
      * 常驻服务实例ID集合
      */
-    @Value("${residenceService.hostNames:#{null}}")
-    public void setResidenceServiceHostName(String[] hostNames){
-        if (!ObjectUtils.isEmpty(hostNames)) {
-            residenceServices = Arrays.asList(hostNames);
-            initIsResidenceService();
+//    @Value("${residenceService.hostNames:#{null}}")
+//    public void setResidenceServiceHostName(String[] hostNames){
+//        if (!ObjectUtils.isEmpty(hostNames)) {
+//            residenceServices = Arrays.asList(hostNames);
+//            initIsResidenceService();
+//        }
+//    }
+    @Autowired
+    IMqEcsService mqEcsService;
+
+    @Value("${queue.modeling.modeling-call}")
+    private String queueNameDf;
+
+
+    public String initIsResidenceService() {
+        if(StringUtils.isEmpty(SysConstants.hostName)){
+            SysConstants.isResidenceService = true;
+            return queueNameDf;
         }
-    }
-
-    private void initIsResidenceService() {
-        if(CollectionUtils.isEmpty(residenceServices) || ObjectUtils.isEmpty(SysConstants.hostName)){
-            log.error("判断常驻服务失败！");
-            return;
+        MqEcs mqEcs = mqEcsService.getByHostName(SysConstants.hostName);
+        if(mqEcs != null && mqEcs.getIsScaling() == 0){ //设置为常驻
+            SysConstants.isResidenceService = true;
+        }else {
+            SysConstants.isResidenceService = false;
+        }
+        if(mqEcs == null){
+            List<MqEcs> list = mqEcsService.getNotUse();
+            mqEcs = list.get(0);
+            mqEcs.setEcsName(SysConstants.hostName);
+            mqEcs.setUpdateTime(null);
+            mqEcsService.updateById(mqEcs);
         }
-        log.info("常驻服务列表：{}", residenceServices);
-        log.info("当前服务名称：{}", SysConstants.hostName);
-        isResidenceService = residenceServices.contains(hostName);
-        log.info("当前服务是否是常驻服务：{}", isResidenceService);
+        return mqEcs.getQueueName();
     }
 
     @Override

src/main/java/com/fdkankan/modeling/controller/BuildLogController.java

@@ -1,21 +0,0 @@
-package com.fdkankan.modeling.controller;
-
-
-import org.springframework.web.bind.annotation.RequestMapping;
-
-import org.springframework.web.bind.annotation.RestController;
-
-/**
- * <p>
- *  前端控制器
- * </p>
- *
- * @author 
- * @since 2022-04-07
- */
-@RestController
-@RequestMapping("/modeling/buildLog")
-public class BuildLogController {
-
-}
-

src/main/java/com/fdkankan/modeling/entity/MqEcs.java

@@ -0,0 +1,58 @@
+package com.fdkankan.modeling.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.io.Serializable;
+import java.util.Date;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author 
+ * @since 2024-04-03
+ */
+@Getter
+@Setter
+@TableName("mq_ecs")
+public class MqEcs implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @TableField("ecs_name")
+    private String ecsName;
+
+    @TableField("queue_name")
+    private String queueName;
+
+    @TableField("create_time")
+    private Date createTime;
+
+    @TableField("update_time")
+    private Date updateTime;
+
+    @TableField("remark")
+    private String remark;
+
+    /**
+     * 0运行中未计算，1运行中计算中，2停止运行
+     */
+    @TableField("status")
+    private Integer status;
+
+    /**
+     * 是否是弹性伸缩0否1是
+     */
+    @TableField("is_scaling")
+    private Integer isScaling;
+
+
+}

src/main/java/com/fdkankan/modeling/generate/AutoGenerate.java

@@ -17,7 +17,7 @@ public class AutoGenerate {
         String path =System.getProperty("user.dir");
 
         generate(path,"modeling", getTables(new String[]{
-                "t_scene_build_process_log"
+                "mq_ecs"
         }));
 
 //        generate(path,"goods", getTables(new String[]{

src/main/java/com/fdkankan/modeling/job/EcsJob.java

@@ -1,81 +1,81 @@
-package com.fdkankan.modeling.job;
-
-import com.fdkankan.modeling.constants.SysConstants;
-import com.fdkankan.rubbersheeting.ScalingService;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Component;
-import org.springframework.util.ObjectUtils;
-
-import javax.annotation.PostConstruct;
-import java.util.Random;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-
-@Component
-public class EcsJob {
-
-    private static final Logger log = LoggerFactory.getLogger(EcsJob.class);
-
-    @Autowired
-    @Lazy
-    private ScalingService scalingService;
-
-    @PostConstruct
-    public void deleteEcs() {
-        if (SysConstants.isResidenceService) {
-            log.info("此服务是常驻服务,不启动关闭弹性伸缩定时任务！");
-            return;
-        }
-        log.info("此服务非常驻服务,开始启动关闭弹性伸缩定时任务");
-        Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(() -> {
-                    // 判断是否有任务执行
-                    if (SysConstants.SYSTEM_BUILDING) {
-                        log.error("{} 服务构建中，退出停止服务请求！", SysConstants.hostName);
-                        return;
-                    }
-                    log.info("服务未构建，准备停止服务！");
-                    if (!SysConstants.executorService.isShutdown()) {
-                        SysConstants.SYSTEM_OFFING = true;
-                        if (!SysConstants.SYSTEM_BUILDING) {
-                            SysConstants.executorService.shutdown();
-                            log.error("{} 线程池关闭，不接受新的构建请求！", SysConstants.hostName);
-                        }else{
-                            SysConstants.SYSTEM_OFFING = false;
-                            log.error("{} 服务构建中，退出停止服务请求！", SysConstants.hostName);
-                        }
-                    }
-                    // 因为 阿里云同一时间不能删除多台实例，因此做随机睡眠，错开时间。
-                    try {
-                        Thread.sleep((new Random().nextInt(30) + 10) * 1000);
-                    } catch (InterruptedException e) {
-                        e.printStackTrace();
-                    }
-                    // 没有任务执行时，则退出
-                    if (SysConstants.executorService.isShutdown() && SysConstants.executorService.isTerminated()) {
-                        log.error("{} 请求阿里云关闭弹性伸缩", SysConstants.hostName);
-                        String result = null;
-                        int tryTimes = -1;
-                        do {
-                            tryTimes++;
-                            result = scalingService.deleteEcs(SysConstants.hostName);
-                            if (ObjectUtils.isEmpty(result)) {
-                                int time = new Random().nextInt(10) + 30;
-                                log.error("{} 关闭弹性伸缩失败,{}秒后重试", SysConstants.hostName, time);
-                                try {
-                                    Thread.sleep(time * 1000);
-                                } catch (InterruptedException e) {
-                                    e.printStackTrace();
-                                }
-                            }
-                        } while (ObjectUtils.isEmpty(result) && tryTimes < 5);
-                        log.error("{} 关闭弹性伸缩成功！", SysConstants.hostName);
-                    } else {
-                        log.error("{} 服务构建中，退出删除程序失败！", SysConstants.hostName);
-                    }
-                },
-                50, 60, TimeUnit.MINUTES);
-    }
-}
+//package com.fdkankan.modeling.job;
+//
+//import com.fdkankan.modeling.constants.SysConstants;
+//import com.fdkankan.rubbersheeting.ScalingService;
+//import org.slf4j.Logger;
+//import org.slf4j.LoggerFactory;
+//import org.springframework.beans.factory.annotation.Autowired;
+//import org.springframework.context.annotation.Lazy;
+//import org.springframework.stereotype.Component;
+//import org.springframework.util.ObjectUtils;
+//
+//import javax.annotation.PostConstruct;
+//import java.util.Random;
+//import java.util.concurrent.Executors;
+//import java.util.concurrent.TimeUnit;
+//
+//@Component
+//public class EcsJob {
+//
+//    private static final Logger log = LoggerFactory.getLogger(EcsJob.class);
+//
+//    @Autowired
+//    @Lazy
+//    private ScalingService scalingService;
+//
+//    @PostConstruct
+//    public void deleteEcs() {
+//        if (SysConstants.isResidenceService) {
+//            log.info("此服务是常驻服务,不启动关闭弹性伸缩定时任务！");
+//            return;
+//        }
+//        log.info("此服务非常驻服务,开始启动关闭弹性伸缩定时任务");
+//        Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(() -> {
+//                    // 判断是否有任务执行
+//                    if (SysConstants.SYSTEM_BUILDING) {
+//                        log.error("{} 服务构建中，退出停止服务请求！", SysConstants.hostName);
+//                        return;
+//                    }
+//                    log.info("服务未构建，准备停止服务！");
+//                    if (!SysConstants.executorService.isShutdown()) {
+//                        SysConstants.SYSTEM_OFFING = true;
+//                        if (!SysConstants.SYSTEM_BUILDING) {
+//                            SysConstants.executorService.shutdown();
+//                            log.error("{} 线程池关闭，不接受新的构建请求！", SysConstants.hostName);
+//                        }else{
+//                            SysConstants.SYSTEM_OFFING = false;
+//                            log.error("{} 服务构建中，退出停止服务请求！", SysConstants.hostName);
+//                        }
+//                    }
+//                    // 因为 阿里云同一时间不能删除多台实例，因此做随机睡眠，错开时间。
+//                    try {
+//                        Thread.sleep((new Random().nextInt(30) + 10) * 1000);
+//                    } catch (InterruptedException e) {
+//                        e.printStackTrace();
+//                    }
+//                    // 没有任务执行时，则退出
+//                    if (SysConstants.executorService.isShutdown() && SysConstants.executorService.isTerminated()) {
+//                        log.error("{} 请求阿里云关闭弹性伸缩", SysConstants.hostName);
+//                        String result = null;
+//                        int tryTimes = -1;
+//                        do {
+//                            tryTimes++;
+//                            result = scalingService.deleteEcs(SysConstants.hostName);
+//                            if (ObjectUtils.isEmpty(result)) {
+//                                int time = new Random().nextInt(10) + 30;
+//                                log.error("{} 关闭弹性伸缩失败,{}秒后重试", SysConstants.hostName, time);
+//                                try {
+//                                    Thread.sleep(time * 1000);
+//                                } catch (InterruptedException e) {
+//                                    e.printStackTrace();
+//                                }
+//                            }
+//                        } while (ObjectUtils.isEmpty(result) && tryTimes < 5);
+//                        log.error("{} 关闭弹性伸缩成功！", SysConstants.hostName);
+//                    } else {
+//                        log.error("{} 服务构建中，退出删除程序失败！", SysConstants.hostName);
+//                    }
+//                },
+//                50, 60, TimeUnit.MINUTES);
+//    }
+//}

src/main/java/com/fdkankan/modeling/mapper/IMqEcsMapper.java

@@ -0,0 +1,18 @@
+package com.fdkankan.modeling.mapper;
+
+import com.fdkankan.modeling.entity.MqEcs;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * <p>
+ *  Mapper 接口
+ * </p>
+ *
+ * @author 
+ * @since 2024-04-03
+ */
+@Mapper
+public interface IMqEcsMapper extends BaseMapper<MqEcs> {
+
+}

src/main/java/com/fdkankan/modeling/receiver/QueueNameService.java

@@ -0,0 +1,37 @@
+package com.fdkankan.modeling.receiver;
+
+import com.fdkankan.modeling.constants.SysConstants;
+import com.fdkankan.modeling.entity.MqEcs;
+import com.fdkankan.modeling.service.IMqEcsService;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Service
+@Slf4j
+public class QueueNameService {
+
+    @Value("${queue.modeling.modeling-call}")
+    private String queue;
+    @Autowired
+    IMqEcsService mqEcsService;
+
+
+    public String getQueueName(){
+        String queueName = queue;
+        if(StringUtils.isBlank(SysConstants.hostName)){
+            log.info("获取hostName失败,监听队列名为：{}",queueName);
+            return queueName;
+        }
+        MqEcs mqEcs = mqEcsService.getByHostName(SysConstants.hostName);
+        if(mqEcs != null ){
+            queueName = mqEcs.getQueueName();
+            log.info("获取hostNam成功,监听队列名为：{}",queueName);
+            return queueName;
+        }
+        log.info("获取hostName失败,监听队列名为：{}",queueName);
+        return queueName;
+    }
+}

src/main/java/com/fdkankan/modeling/receiver/RabbitMqListener.java

@@ -7,13 +7,16 @@ import com.fdkankan.common.constant.ModelingBuildStatus;
 import com.fdkankan.common.util.FileUtils;
 import com.fdkankan.model.utils.ComputerUtil;
 import com.fdkankan.modeling.bean.BuildSceneResultBean;
+import com.fdkankan.modeling.constants.RedisKey;
 import com.fdkankan.modeling.constants.SysConstants;
 import com.fdkankan.modeling.entity.BuildLog;
 import com.fdkankan.modeling.exception.BuildException;
 import com.fdkankan.modeling.handler.LaserSceneObjGenerateHandler;
 import com.fdkankan.modeling.service.IBuildLogService;
 import com.fdkankan.modeling.service.IBuildService;
+import com.fdkankan.modeling.service.IMqEcsService;
 import com.fdkankan.modeling.service.ISceneBuildProcessLogService;
+import com.fdkankan.modeling.service.impl.MqEcsServiceImpl;
 import com.fdkankan.rabbitmq.bean.BuildSceneCallMessage;
 import com.fdkankan.rabbitmq.bean.BuildSceneProcessLogMessage;
 import com.fdkankan.rabbitmq.bean.BuildSceneResultMqMessage;
@@ -78,6 +81,8 @@ public class RabbitMqListener {
     private LaserSceneObjGenerateHandler laserSceneObjGenerateHandler;
     @Autowired
     private ISceneBuildProcessLogService sceneBuildProcessLogService;
+    @Autowired
+    QueueNameService queueNameService;
 
     @Autowired
     private IBuildService buildService;
@@ -89,34 +94,38 @@ public class RabbitMqListener {
      * @throws Exception
      */
     @RabbitListener(
-            queuesToDeclare = @Queue("${queue.modeling.modeling-call}"),
+            //queuesToDeclare = @Queue("${queue.modeling.modeling-call}"),
+            queuesToDeclare = @Queue("#{queueNameService.getQueueName()}"),
             concurrency = "${maxThread.modeling.modeling-call}",
             priority = "${mq.consumerPriority}"
     )
     public void buildSceneHandler(Channel channel, Message message) throws Exception {
-        SysConstants.SYSTEM_BUILDING = true;
-        long deliveryTag = message.getMessageProperties().getDeliveryTag();
-        if (SysConstants.SYSTEM_OFFING) {
-            SysConstants.SYSTEM_BUILDING = false;
-            channel.basicNack(deliveryTag, true, true);
-            log.error("服务实例：{} 正在关闭，退出构建！", SysConstants.hostName);
-            return;
-        }
-
         if (ObjectUtils.isEmpty(message.getBody())) {
-            SysConstants.SYSTEM_BUILDING = false;
             log.error("消息内容为空,退出构建,当前服务器id:{}", SysConstants.hostName);
             return;
         }
+        long deliveryTag = message.getMessageProperties().getDeliveryTag();
         String msg = new String(message.getBody(), StandardCharsets.UTF_8);
         BuildSceneCallMessage buildSceneMessage = JSONObject.parseObject(msg, BuildSceneCallMessage.class);
-
         String messageId = message.getMessageProperties().getMessageId();
         if(Objects.isNull(buildSceneMessage) || StrUtil.isBlank(buildSceneMessage.getSceneNum())){
             log.error("消息内容错误,id:{},消息体:{}", messageId, msg);
             return;
         }
 
+        //计算暂停锁，计算中锁。弹性伸缩控制服务使用
+        String modelingKey = String.format(RedisKey.modelingKey,SysConstants.hostName);
+        String stopKey = String.format(RedisKey.ecsStopKey,SysConstants.hostName);
+        //设置为计算超时时间过期
+        redisUtil.set(modelingKey,msg,SysConstants.modelTimeOut * 3600L);
+
+        if(redisUtil.hasKey(stopKey)){
+            log.error("服务实例：{} 正在关闭，退出构建！", SysConstants.hostName);
+            redisUtil.del(modelingKey);
+            channel.basicNack(deliveryTag, true, true);
+            return;
+        }
+
         BuildLog buildLog = new BuildLog();
         log.info("场景计算开始,队列名:{},id:{},deliveryTag:{},消息体:{}", queueModelingCall, messageId,deliveryTag,msg);
         buildLog.setMessageId(messageId);
@@ -126,7 +135,7 @@ public class RabbitMqListener {
         log.info("场景计算结束,队列名:{},id:{}", queueModelingCall, messageId);
 
         //计算完毕，将当前系统构建状态改为false
-        SysConstants.SYSTEM_BUILDING = false;
+        redisUtil.del(modelingKey);
 
         channel.basicAck(deliveryTag, false);
     }
@@ -291,7 +300,7 @@ public class RabbitMqListener {
      */
     private void sendCallBuildProcessLog(BuildSceneCallMessage message, ModelingBuildStatus buildStatus){
         rabbitMqProducer.sendByWorkQueue(queueModelingProcessLog,
-                BuildSceneProcessLogMessage.builder().num(message.getSceneNum()).buildStatus(buildStatus.code()).build());
+                BuildSceneProcessLogMessage.builder().num(message.getSceneNum()).buildStatus(buildStatus.code()).queueName(queueNameService.getQueueName()).build());
     }
 
     private void preBuild(Map<String,Object> buildContext,BuildSceneCallMessage message, BuildLog buildLog) throws BuildException {

src/main/java/com/fdkankan/modeling/service/IMqEcsService.java

@@ -0,0 +1,22 @@
+package com.fdkankan.modeling.service;
+
+import com.fdkankan.modeling.entity.MqEcs;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author 
+ * @since 2024-04-03
+ */
+public interface IMqEcsService extends IService<MqEcs> {
+
+
+    MqEcs getByHostName(String hostName);
+
+    List<MqEcs> getNotUse();
+}

src/main/java/com/fdkankan/modeling/service/impl/MqEcsServiceImpl.java

@@ -0,0 +1,41 @@
+package com.fdkankan.modeling.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.fdkankan.modeling.entity.MqEcs;
+import com.fdkankan.modeling.mapper.IMqEcsMapper;
+import com.fdkankan.modeling.service.IMqEcsService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author 
+ * @since 2024-04-03
+ */
+@Service
+public class MqEcsServiceImpl extends ServiceImpl<IMqEcsMapper, MqEcs> implements IMqEcsService {
+
+
+    @Override
+    public MqEcs getByHostName(String hostName) {
+        LambdaQueryWrapper<MqEcs> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(MqEcs::getEcsName,hostName);
+        return this.getOne(wrapper);
+    }
+
+    @Override
+    public List<MqEcs> getNotUse() {
+        LambdaQueryWrapper<MqEcs> wrapper = new LambdaQueryWrapper<>();
+        wrapper.isNull(MqEcs::getEcsName);
+        wrapper.eq(MqEcs::getStatus,0);
+        wrapper.eq(MqEcs::getIsScaling,1);
+        wrapper.orderByAsc(MqEcs::getId);
+        return this.list(wrapper);
+    }
+}

src/main/resources/mapper/modeling/MqEcsMapper.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.fdkankan.modeling.mapper.IMqEcsMapper">
+
+</mapper>