Merge remote-tracking branch 'origin/master'

# Conflicts:
#	4dkankan-common/pom.xml

.gitignore

@@ -35,6 +35,8 @@ gen
 /4dkankan-center-scene/target/
 /4dkankan-common/target/
 /4dkankan-gateway/target/
+/4dkankan-pom/target/
+/4dkankan-center-platform/target/
 
 
 4dkankan-pom/src/test/java/TestAutoGenerate.java

4dkankan-center-platform/pom.xml

@@ -21,6 +21,10 @@
       </dependency>
 
       <dependency>
+          <groupId>org.projectlombok</groupId>
+          <artifactId>lombok</artifactId>
+      </dependency>
+      <dependency>
           <groupId>com.fdkankan</groupId>
           <artifactId>4dkankan-pom</artifactId>
           <version>2.0.0</version>

4dkankan-center-platform/src/main/java/com/fdkankan/agent/controller/AgentAuditController.java

@@ -14,8 +14,13 @@ import org.springframework.web.bind.annotation.RestController;
  * @since 2021-12-22
  */
 @RestController
-@RequestMapping("/agent/agent-audit")
+@RequestMapping("/agent")
 public class AgentAuditController {
 
+    @RequestMapping("/one")
+    public String getOne (){
+        return "??";
+    }
+
 }
 

4dkankan-center-platform/src/main/resources/logback-spring.xml

@@ -16,7 +16,8 @@
 	<conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
 	<!-- 彩色日志格式 -->
 	<property name="CONSOLE_LOG_PATTERN"
-		value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
+		value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %L %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
+	<!--		value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %L - %msg%n" />-->
 
 	<!--输出到控制台 -->
 	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
@@ -38,7 +39,7 @@
 		<file>${log.path}/log_debug.log</file>
 		<!--日志文件输出格式 -->
 		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %L - %msg%n</pattern>
 			<charset>UTF-8</charset> <!-- 设置字符集 -->
 		</encoder>
 		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
@@ -66,7 +67,7 @@
 		<file>${log.path}/log_info.log</file>
 		<!--日志文件输出格式 -->
 		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %L - %msg%n</pattern>
 			<charset>UTF-8</charset>
 		</encoder>
 		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
@@ -94,7 +95,7 @@
 		<file>${log.path}/log_warn.log</file>
 		<!--日志文件输出格式 -->
 		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %L - %msg%n</pattern>
 			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
 		</encoder>
 		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
@@ -122,7 +123,7 @@
 		<file>${log.path}/log_error.log</file>
 		<!--日志文件输出格式 -->
 		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %L - %msg%n</pattern>
 			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
 		</encoder>
 		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
@@ -148,7 +149,7 @@
 		<file>${log.path}/program/log_program.log</file>
 		<!--日志文件输出格式 -->
 		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %L - %msg%n</pattern>
 			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
 		</encoder>
 		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
@@ -176,7 +177,7 @@
 		<file>${log.path}/visit/log_visit.log</file>
 		<!--日志文件输出格式 -->
 		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
+			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %L - %msg%n</pattern>
 			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
 		</encoder>
 		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->

4dkankan-center-platform/target/classes/application.yml

@@ -1,51 +0,0 @@
-server:
-  port: 8084
-  servlet:
-    context-path: /platform
-  tomcat:
-    accesslog:
-      buffered: true
-      directory: /home/logs/tomcat
-      enabled: true
-      file-date-format: .yyyy-MM-dd
-      pattern: '%t | %{X-Real-IP}i | %b | %B | %H | %l | %m | %p | %q | %r | %s | %S | %u | %U | %v | %D | %T | %{Cookie}i | %{User-Agent}i | %{a}r'
-      prefix: access_log
-      rename-on-rotate: false
-      request-attributes-enabled: false
-      rotate: true
-      suffix: .log
-spring:
-  cloud:
-    nacos:
-      discovery:
-        port: ${discoveryPort:8848}
-        server-addr: 192.168.0.47
-  application:
-    name: platform
-  datasource:
-    name: test
-    url: jdbc:mysql://localhost:3306/4dkankan_center_application?useUnicode:true&characterEncoding:utf-8&useSSL:true&serverTimezone:UTC&allowMultiQueries:true
-    username: root
-    password: 123456
-    type: com.alibaba.druid.pool.DruidDataSource
-    driver-class-name: com.mysql.cj.jdbc.Driver
-mybatis:
-  mapper-locations: classpath:mapper/*/*.xml
-  type-aliases-package: com.4dkankan_center_application.www
-  configuration:
-    map-underscore-to-camel-case: true
-logging:
-  config: classpath:logback-spring.xml
-
-prefix:
-  ali: https://4dkk.4dage.com/
-
-oss:
-  point: http://oss-cn-shenzhen-internal.aliyuncs.com
-  key: LTAIUrvuHqj8pvry
-  secrey: JLOVl0k8Ke0aaM8nLMMiUAZ3EiiqI4
-  bucket: 4dkankan
-  type: oss
-  s3key: AKIAWCV5QFZ3ZNELKYUY
-  s3secrey: epS5ghyR4LJ7rxk/qJO9ZYh6m9Oz6g5haKDu4yws
-  s3bucket: 4dkankan

4dkankan-center-platform/target/classes/logback-spring.xml

@@ -1,230 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
-<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
-<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
-<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
-<configuration scan="true" scanPeriod="10 seconds">
-
-	<contextName>logback</contextName>
-	<!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
-	<property name="log.path" value="/home/logs/4dkankan_center_application" />
-
-	<!-- 彩色日志 -->
-	<!-- 彩色日志依赖的渲染类 -->
-	<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
-	<conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
-	<conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
-	<!-- 彩色日志格式 -->
-	<property name="CONSOLE_LOG_PATTERN"
-		value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
-
-	<!--输出到控制台 -->
-	<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
-		<!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息 -->
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>info</level>
-		</filter>
-		<encoder>
-			<Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
-			<!-- 设置字符集 -->
-			<charset>UTF-8</charset>
-		</encoder>
-	</appender>
-	<!--输出到文件 -->
-
-	<!-- 时间滚动输出 level为 DEBUG 日志 -->
-	<appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<!-- 正在记录的日志文件的路径及文件名 -->
-		<file>${log.path}/log_debug.log</file>
-		<!--日志文件输出格式 -->
-		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
-			<charset>UTF-8</charset> <!-- 设置字符集 -->
-		</encoder>
-		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<!-- 日志归档 -->
-			<fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log
-			</fileNamePattern>
-			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
-				<maxFileSize>100MB</maxFileSize>
-			</timeBasedFileNamingAndTriggeringPolicy>
-			<!--日志文件保留天数 -->
-			<maxHistory>15</maxHistory>
-		</rollingPolicy>
-		<!-- 此日志文件只记录debug级别的 -->
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>debug</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-	</appender>
-
-	<!-- 时间滚动输出 level为 INFO 日志 -->
-	<appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<!-- 正在记录的日志文件的路径及文件名 -->
-		<file>${log.path}/log_info.log</file>
-		<!--日志文件输出格式 -->
-		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
-			<charset>UTF-8</charset>
-		</encoder>
-		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<!-- 每天日志归档路径以及格式 -->
-			<fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log
-			</fileNamePattern>
-			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
-				<maxFileSize>100MB</maxFileSize>
-			</timeBasedFileNamingAndTriggeringPolicy>
-			<!--日志文件保留天数 -->
-			<maxHistory>15</maxHistory>
-		</rollingPolicy>
-		<!-- 此日志文件只记录info级别的 -->
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>info</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-	</appender>
-
-	<!-- 时间滚动输出 level为 WARN 日志 -->
-	<appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<!-- 正在记录的日志文件的路径及文件名 -->
-		<file>${log.path}/log_warn.log</file>
-		<!--日志文件输出格式 -->
-		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
-			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
-		</encoder>
-		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log
-			</fileNamePattern>
-			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
-				<maxFileSize>100MB</maxFileSize>
-			</timeBasedFileNamingAndTriggeringPolicy>
-			<!--日志文件保留天数 -->
-			<maxHistory>15</maxHistory>
-		</rollingPolicy>
-		<!-- 此日志文件只记录warn级别的 -->
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>warn</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-	</appender>
-
-
-	<!-- 时间滚动输出 level为 ERROR 日志 -->
-	<appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<!-- 正在记录的日志文件的路径及文件名 -->
-		<file>${log.path}/log_error.log</file>
-		<!--日志文件输出格式 -->
-		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
-			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
-		</encoder>
-		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log
-			</fileNamePattern>
-			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
-				<maxFileSize>100MB</maxFileSize>
-			</timeBasedFileNamingAndTriggeringPolicy>
-			<!--日志文件保留天数 -->
-			<maxHistory>15</maxHistory>
-		</rollingPolicy>
-		<!-- 此日志文件只记录ERROR级别的 -->
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>ERROR</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-	</appender>
-	
-	<appender name="PROGRAM_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<!-- 正在记录的日志文件的路径及文件名 -->
-		<file>${log.path}/program/log_program.log</file>
-		<!--日志文件输出格式 -->
-		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
-			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
-		</encoder>
-		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${log.path}/program/log-program-%d{yyyy-MM-dd}.%i.log
-			</fileNamePattern>
-			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
-				<maxFileSize>100MB</maxFileSize>
-			</timeBasedFileNamingAndTriggeringPolicy>
-			<!--日志文件保留天数 -->
-			<maxHistory>15</maxHistory>
-		</rollingPolicy>
-		<!-- 此日志文件只记录ERROR级别的 -->
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-	</appender>
-	<logger name="programLog" level="INFO" additivity="true">
-        <appender-ref ref="PROGRAM_FILE"/>
-    </logger>
-
-	<appender name="VISIT_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<!-- 正在记录的日志文件的路径及文件名 -->
-		<file>${log.path}/visit/log_visit.log</file>
-		<!--日志文件输出格式 -->
-		<encoder>
-			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
-			<charset>UTF-8</charset> <!-- 此处设置字符集 -->
-		</encoder>
-		<!-- 日志记录器的滚动策略，按日期，按大小记录 -->
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${log.path}/visit/log-visit-%d{yyyy-MM-dd}.%i.log
-			</fileNamePattern>
-			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
-				<maxFileSize>100MB</maxFileSize>
-			</timeBasedFileNamingAndTriggeringPolicy>
-			<!--日志文件保留天数 -->
-			<maxHistory>15</maxHistory>
-		</rollingPolicy>
-		<!-- 此日志文件只记录ERROR级别的 -->
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-	</appender>
-	<logger name="visitLog" level="INFO" additivity="true">
-        <appender-ref ref="VISIT_FILE"/>
-    </logger>
-
-	<!-- <logger>用来设置某一个包或者具体的某一个类的日志打印级别、 以及指定<appender>。<logger>仅有一个name属性， 一个可选的level和一个可选的addtivity属性。 name:用来指定受此logger约束的某一个包或者具体的某一个类。 level:用来设置打印级别，大小写无关：TRACE, 
-		DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。 如果未设置此属性，那么当前logger将会继承上级的级别。 addtivity:是否向上级logger传递打印信息。默认是true。 -->
-	<!--<logger name="org.springframework.web" level="info"/> -->
-	<!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/> -->
-	<!-- 使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作： 第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息 第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别： -->
-	<!-- root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性 level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 不能设置为INHERITED或者同义词NULL。默认是DEBUG 可以包含零个或多个元素，标识这个appender将会添加到这个logger。 -->
-
-	<root level="info">
-		<appender-ref ref="CONSOLE" />
-		<appender-ref ref="DEBUG_FILE" />
-		<appender-ref ref="INFO_FILE" />
-		<appender-ref ref="WARN_FILE" />
-		<appender-ref ref="ERROR_FILE" />
-	</root>
-
-	<!--生产环境:输出到文件 -->
-	<!--<springProfile name="pro"> -->
-	<!--<root level="info"> -->
-	<!--<appender-ref ref="CONSOLE" /> -->
-	<!--<appender-ref ref="DEBUG_FILE" /> -->
-	<!--<appender-ref ref="INFO_FILE" /> -->
-	<!--<appender-ref ref="ERROR_FILE" /> -->
-	<!--<appender-ref ref="WARN_FILE" /> -->
-	<!--</root> -->
-	<!--</springProfile> -->
-
-</configuration>
-
-

4dkankan-center-platform/target/classes/mapper/agent/AgentAuditMapper.xml

@@ -1,128 +0,0 @@
-<?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.agent.mapper.IAgentAuditMapper">
-	<resultMap id="resultMap" type="com.fdkankan.agent.entity.AgentAudit">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="audit_name" jdbcType="VARCHAR" property="auditName" />
-		<result column="country" jdbcType="VARCHAR" property="country" />
-		<result column="region" jdbcType="VARCHAR" property="region" />
-		<result column="address" jdbcType="VARCHAR" property="address" />
-		<result column="audit_type" jdbcType="INTEGER" property="auditType" />
-		<result column="store_address" jdbcType="VARCHAR" property="storeAddress" />
-		<result column="sur_name" jdbcType="VARCHAR" property="surName" />
-		<result column="user_name" jdbcType="VARCHAR" property="userName" />
-		<result column="post" jdbcType="VARCHAR" property="post" />
-		<result column="area_code" jdbcType="VARCHAR" property="areaCode" />
-		<result column="phone" jdbcType="VARCHAR" property="phone" />
-		<result column="email" jdbcType="VARCHAR" property="email" />
-		<result column="state" jdbcType="INTEGER" property="state" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="note_type" jdbcType="INTEGER" property="noteType" />
-		<result column="note_content" jdbcType="VARCHAR" property="noteContent" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,audit_name,country,region,address,audit_type,store_address,sur_name,user_name,post,area_code,phone,email,state,create_time,update_time,rec_status,note_type,note_content,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		audit_name, country, region, address, audit_type, store_address, sur_name, user_name, post, area_code, phone, email, state, rec_status, note_type, note_content
-		) VALUES (
-		#{entity.auditName}, #{entity.country}, #{entity.region}, #{entity.address}, #{entity.auditType}, #{entity.storeAddress}, #{entity.surName}, #{entity.userName}, #{entity.post}, #{entity.areaCode}, #{entity.phone}, #{entity.email}, #{entity.state}, #{entity.recStatus}, #{entity.noteType}, #{entity.noteContent}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		audit_name, country, region, address, audit_type, store_address, sur_name, user_name, post, area_code, phone, email, state, rec_status, note_type, note_content
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.auditName}, #{entity.country}, #{entity.region}, #{entity.address}, #{entity.auditType}, #{entity.storeAddress}, #{entity.surName}, #{entity.userName}, #{entity.post}, #{entity.areaCode}, #{entity.phone}, #{entity.email}, #{entity.state}, #{entity.recStatus}, #{entity.noteType}, #{entity.noteContent})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		audit_name=#{entity.auditName}, country=#{entity.country}, region=#{entity.region}, address=#{entity.address}, audit_type=#{entity.auditType}, store_address=#{entity.storeAddress}, sur_name=#{entity.surName}, user_name=#{entity.userName}, post=#{entity.post}, area_code=#{entity.areaCode}, phone=#{entity.phone}, email=#{entity.email}, state=#{entity.state}, rec_status=#{entity.recStatus}, note_type=#{entity.noteType}, note_content=#{entity.noteContent}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/agent/AgentFrameworkMapper.xml

@@ -1,116 +0,0 @@
-<?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.agent.mapper.IAgentFrameworkMapper">
-	<resultMap id="resultMap" type="com.fdkankan.agent.entity.AgentFramework">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="parent_id" jdbcType="VARCHAR" property="parentId" />
-		<result column="agent_name" jdbcType="VARCHAR" property="agentName" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,parent_id,agent_name,rec_status,create_time,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		parent_id, agent_name, rec_status
-		) VALUES (
-		#{entity.parentId}, #{entity.agentName}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		parent_id, agent_name, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.parentId}, #{entity.agentName}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		parent_id=#{entity.parentId}, agent_name=#{entity.agentName}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/agent/AgentMapper.xml

@@ -1,122 +0,0 @@
-<?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.agent.mapper.IAgentMapper">
-	<resultMap id="resultMap" type="com.fdkankan.agent.entity.Agent">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="agent_id" jdbcType="VARCHAR" property="agentId" />
-		<result column="agent_name" jdbcType="VARCHAR" property="agentName" />
-		<result column="agent_password" jdbcType="VARCHAR" property="agentPassword" />
-		<result column="agent_area" jdbcType="VARCHAR" property="agentArea" />
-		<result column="agent_email" jdbcType="VARCHAR" property="agentEmail" />
-		<result column="agent_phone" jdbcType="VARCHAR" property="agentPhone" />
-		<result column="state" jdbcType="INTEGER" property="state" />
-		<result column="agent_num" jdbcType="INTEGER" property="agentNum" />
-		<result column="agent_country" jdbcType="VARCHAR" property="agentCountry" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,agent_id,agent_name,agent_password,agent_area,agent_email,agent_phone,state,agent_num,agent_country,create_time,update_time,rec_status,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		agent_id, agent_name, agent_password, agent_area, agent_email, agent_phone, state, agent_num, agent_country, rec_status
-		) VALUES (
-		#{entity.agentId}, #{entity.agentName}, #{entity.agentPassword}, #{entity.agentArea}, #{entity.agentEmail}, #{entity.agentPhone}, #{entity.state}, #{entity.agentNum}, #{entity.agentCountry}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		agent_id, agent_name, agent_password, agent_area, agent_email, agent_phone, state, agent_num, agent_country, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.agentId}, #{entity.agentName}, #{entity.agentPassword}, #{entity.agentArea}, #{entity.agentEmail}, #{entity.agentPhone}, #{entity.state}, #{entity.agentNum}, #{entity.agentCountry}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		agent_id=#{entity.agentId}, agent_name=#{entity.agentName}, agent_password=#{entity.agentPassword}, agent_area=#{entity.agentArea}, agent_email=#{entity.agentEmail}, agent_phone=#{entity.agentPhone}, state=#{entity.state}, agent_num=#{entity.agentNum}, agent_country=#{entity.agentCountry}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/agent/AgentNoticeMapper.xml

@@ -1,115 +0,0 @@
-<?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.agent.mapper.IAgentNoticeMapper">
-	<resultMap id="resultMap" type="com.fdkankan.agent.entity.AgentNotice">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="title" jdbcType="VARCHAR" property="title" />
-		<result column="content" jdbcType="VARCHAR" property="content" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,title,content,create_time,update_time,rec_status,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		title, content, rec_status
-		) VALUES (
-		#{entity.title}, #{entity.content}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		title, content, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.title}, #{entity.content}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		title=#{entity.title}, content=#{entity.content}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/CameraMapper.xml

@@ -1,119 +0,0 @@
-<?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.goods.mapper.ICameraMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.Camera">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="child_name" jdbcType="VARCHAR" property="childName" />
-		<result column="activated_time" jdbcType="TIMESTAMP" property="activatedTime" />
-		<result column="child_password" jdbcType="VARCHAR" property="childPassword" />
-		<result column="sn_code" jdbcType="VARCHAR" property="snCode" />
-		<result column="wifi_name" jdbcType="VARCHAR" property="wifiName" />
-		<result column="wifi_password" jdbcType="VARCHAR" property="wifiPassword" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,child_name,activated_time,child_password,sn_code,wifi_name,wifi_password,create_time,update_time,rec_status,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		child_name, activated_time, child_password, sn_code, wifi_name, wifi_password, rec_status
-		) VALUES (
-		#{entity.childName}, #{entity.activatedTime}, #{entity.childPassword}, #{entity.snCode}, #{entity.wifiName}, #{entity.wifiPassword}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		child_name, activated_time, child_password, sn_code, wifi_name, wifi_password, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.childName}, #{entity.activatedTime}, #{entity.childPassword}, #{entity.snCode}, #{entity.wifiName}, #{entity.wifiPassword}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		child_name=#{entity.childName}, activated_time=#{entity.activatedTime}, child_password=#{entity.childPassword}, sn_code=#{entity.snCode}, wifi_name=#{entity.wifiName}, wifi_password=#{entity.wifiPassword}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/CameraOutMapper.xml

@@ -1,117 +0,0 @@
-<?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.goods.mapper.ICameraOutMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.CameraOut">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="camera_id" jdbcType="VARCHAR" property="cameraId" />
-		<result column="order_id" jdbcType="VARCHAR" property="orderId" />
-		<result column="agent_name" jdbcType="VARCHAR" property="agentName" />
-		<result column="out_type" jdbcType="INTEGER" property="outType" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,camera_id,order_id,agent_name,out_type,create_time,update_time,rec_status,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		camera_id, order_id, agent_name, out_type, rec_status
-		) VALUES (
-		#{entity.cameraId}, #{entity.orderId}, #{entity.agentName}, #{entity.outType}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		camera_id, order_id, agent_name, out_type, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.cameraId}, #{entity.orderId}, #{entity.agentName}, #{entity.outType}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		camera_id=#{entity.cameraId}, order_id=#{entity.orderId}, agent_name=#{entity.agentName}, out_type=#{entity.outType}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/CameraSpaceMapper.xml

@@ -1,120 +0,0 @@
-<?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.goods.mapper.ICameraSpaceMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.CameraSpace">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="camera_id" jdbcType="VARCHAR" property="cameraId" />
-		<result column="space" jdbcType="VARCHAR" property="space" />
-		<result column="space_type" jdbcType="INTEGER" property="spaceType" />
-		<result column="space_start_time" jdbcType="TIMESTAMP" property="spaceStartTime" />
-		<result column="space_end_time" jdbcType="TIMESTAMP" property="spaceEndTime" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="order_sn" jdbcType="LONGVARCHAR" property="orderSn" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,user_id,camera_id,space,space_type,space_start_time,space_end_time,create_time,rec_status,update_time,order_sn,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		user_id, camera_id, space, space_type, space_start_time, space_end_time, rec_status, order_sn
-		) VALUES (
-		#{entity.userId}, #{entity.cameraId}, #{entity.space}, #{entity.spaceType}, #{entity.spaceStartTime}, #{entity.spaceEndTime}, #{entity.recStatus}, #{entity.orderSn}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		user_id, camera_id, space, space_type, space_start_time, space_end_time, rec_status, order_sn
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.userId}, #{entity.cameraId}, #{entity.space}, #{entity.spaceType}, #{entity.spaceStartTime}, #{entity.spaceEndTime}, #{entity.recStatus}, #{entity.orderSn})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		user_id=#{entity.userId}, camera_id=#{entity.cameraId}, space=#{entity.space}, space_type=#{entity.spaceType}, space_start_time=#{entity.spaceStartTime}, space_end_time=#{entity.spaceEndTime}, rec_status=#{entity.recStatus}, order_sn=#{entity.orderSn}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/CameraVersionMapper.xml

@@ -1,121 +0,0 @@
-<?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.goods.mapper.ICameraVersionMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.CameraVersion">
-		<id column="id" jdbcType="INTEGER" property="id" />
-		<result column="file_name" jdbcType="VARCHAR" property="fileName" />
-		<result column="file_url" jdbcType="VARCHAR" property="fileUrl" />
-		<result column="file_md5" jdbcType="VARCHAR" property="fileMd5" />
-		<result column="description" jdbcType="VARCHAR" property="description" />
-		<result column="version" jdbcType="VARCHAR" property="version" />
-		<result column="camera_type" jdbcType="INTEGER" property="cameraType" />
-		<result column="ac_status" jdbcType="VARCHAR" property="acStatus" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="min_version" jdbcType="VARCHAR" property="minVersion" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,file_name,file_url,file_md5,description,version,camera_type,ac_status,rec_status,create_time,update_time,min_version,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		file_name, file_url, file_md5, description, version, camera_type, ac_status, rec_status, min_version
-		) VALUES (
-		#{entity.fileName}, #{entity.fileUrl}, #{entity.fileMd5}, #{entity.description}, #{entity.version}, #{entity.cameraType}, #{entity.acStatus}, #{entity.recStatus}, #{entity.minVersion}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		file_name, file_url, file_md5, description, version, camera_type, ac_status, rec_status, min_version
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.fileName}, #{entity.fileUrl}, #{entity.fileMd5}, #{entity.description}, #{entity.version}, #{entity.cameraType}, #{entity.acStatus}, #{entity.recStatus}, #{entity.minVersion})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		file_name=#{entity.fileName}, file_url=#{entity.fileUrl}, file_md5=#{entity.fileMd5}, description=#{entity.description}, version=#{entity.version}, camera_type=#{entity.cameraType}, ac_status=#{entity.acStatus}, rec_status=#{entity.recStatus}, min_version=#{entity.minVersion}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/CartMapper.xml

@@ -1,120 +0,0 @@
-<?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.goods.mapper.ICartMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.Cart">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="goods_id" jdbcType="VARCHAR" property="goodsId" />
-		<result column="sku_sn" jdbcType="VARCHAR" property="skuSn" />
-		<result column="goods_count" jdbcType="INTEGER" property="goodsCount" />
-		<result column="price" jdbcType="DECIMAL" property="price" />
-		<result column="amount" jdbcType="DECIMAL" property="amount" />
-		<result column="pay_status" jdbcType="INTEGER" property="payStatus" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,user_id,goods_id,sku_sn,goods_count,price,amount,pay_status,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		user_id, goods_id, sku_sn, goods_count, price, amount, pay_status, rec_status
-		) VALUES (
-		#{entity.userId}, #{entity.goodsId}, #{entity.skuSn}, #{entity.goodsCount}, #{entity.price}, #{entity.amount}, #{entity.payStatus}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		user_id, goods_id, sku_sn, goods_count, price, amount, pay_status, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.userId}, #{entity.goodsId}, #{entity.skuSn}, #{entity.goodsCount}, #{entity.price}, #{entity.amount}, #{entity.payStatus}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		user_id=#{entity.userId}, goods_id=#{entity.goodsId}, sku_sn=#{entity.skuSn}, goods_count=#{entity.goodsCount}, price=#{entity.price}, amount=#{entity.amount}, pay_status=#{entity.payStatus}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/CommerceOrderMapper.xml

@@ -1,124 +0,0 @@
-<?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.goods.mapper.ICommerceOrderMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.CommerceOrder">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="order_sn" jdbcType="VARCHAR" property="orderSn" />
-		<result column="amount" jdbcType="DECIMAL" property="amount" />
-		<result column="number" jdbcType="VARCHAR" property="number" />
-		<result column="pay_type" jdbcType="INTEGER" property="payType" />
-		<result column="pay_status" jdbcType="INTEGER" property="payStatus" />
-		<result column="trade_time" jdbcType="TIMESTAMP" property="tradeTime" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="camera_id" jdbcType="VARCHAR" property="cameraId" />
-		<result column="commerce_type" jdbcType="INTEGER" property="commerceType" />
-		<result column="count" jdbcType="INTEGER" property="count" />
-		<result column="abroad" jdbcType="INTEGER" property="abroad" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,order_sn,amount,number,pay_type,pay_status,trade_time,user_id,camera_id,commerce_type,count,abroad,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, trade_time, user_id, camera_id, commerce_type, count, abroad, rec_status
-		) VALUES (
-		#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.tradeTime}, #{entity.userId}, #{entity.cameraId}, #{entity.commerceType}, #{entity.count}, #{entity.abroad}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, trade_time, user_id, camera_id, commerce_type, count, abroad, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.tradeTime}, #{entity.userId}, #{entity.cameraId}, #{entity.commerceType}, #{entity.count}, #{entity.abroad}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		order_sn=#{entity.orderSn}, amount=#{entity.amount}, number=#{entity.number}, pay_type=#{entity.payType}, pay_status=#{entity.payStatus}, trade_time=#{entity.tradeTime}, user_id=#{entity.userId}, camera_id=#{entity.cameraId}, commerce_type=#{entity.commerceType}, count=#{entity.count}, abroad=#{entity.abroad}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/CompanyMapper.xml

@@ -1,121 +0,0 @@
-<?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.goods.mapper.ICompanyMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.Company">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="company_name" jdbcType="VARCHAR" property="companyName" />
-		<result column="top_logo" jdbcType="VARCHAR" property="topLogo" />
-		<result column="floor_logo" jdbcType="VARCHAR" property="floorLogo" />
-		<result column="marker_logo" jdbcType="VARCHAR" property="markerLogo" />
-		<result column="qr_logo" jdbcType="VARCHAR" property="qrLogo" />
-		<result column="show_logo" jdbcType="INTEGER" property="showLogo" />
-		<result column="manager_id" jdbcType="VARCHAR" property="managerId" />
-		<result column="camera_delete" jdbcType="INTEGER" property="cameraDelete" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,company_name,top_logo,floor_logo,marker_logo,qr_logo,show_logo,manager_id,camera_delete,create_time,update_time,rec_status,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		company_name, top_logo, floor_logo, marker_logo, qr_logo, show_logo, manager_id, camera_delete, rec_status
-		) VALUES (
-		#{entity.companyName}, #{entity.topLogo}, #{entity.floorLogo}, #{entity.markerLogo}, #{entity.qrLogo}, #{entity.showLogo}, #{entity.managerId}, #{entity.cameraDelete}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		company_name, top_logo, floor_logo, marker_logo, qr_logo, show_logo, manager_id, camera_delete, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.companyName}, #{entity.topLogo}, #{entity.floorLogo}, #{entity.markerLogo}, #{entity.qrLogo}, #{entity.showLogo}, #{entity.managerId}, #{entity.cameraDelete}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		company_name=#{entity.companyName}, top_logo=#{entity.topLogo}, floor_logo=#{entity.floorLogo}, marker_logo=#{entity.markerLogo}, qr_logo=#{entity.qrLogo}, show_logo=#{entity.showLogo}, manager_id=#{entity.managerId}, camera_delete=#{entity.cameraDelete}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/DownloadOrderMapper.xml

@@ -1,125 +0,0 @@
-<?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.goods.mapper.IDownloadOrderMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.DownloadOrder">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="order_sn" jdbcType="VARCHAR" property="orderSn" />
-		<result column="amount" jdbcType="DECIMAL" property="amount" />
-		<result column="number" jdbcType="VARCHAR" property="number" />
-		<result column="pay_type" jdbcType="INTEGER" property="payType" />
-		<result column="pay_status" jdbcType="INTEGER" property="payStatus" />
-		<result column="down_status" jdbcType="INTEGER" property="downStatus" />
-		<result column="trade_time" jdbcType="TIMESTAMP" property="tradeTime" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="count" jdbcType="INTEGER" property="count" />
-		<result column="abroad" jdbcType="INTEGER" property="abroad" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="scene_num" jdbcType="VARCHAR" property="sceneNum" />
-		<result column="scene_name" jdbcType="VARCHAR" property="sceneName" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,order_sn,amount,number,pay_type,pay_status,down_status,trade_time,user_id,count,abroad,create_time,rec_status,update_time,scene_num,scene_name,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, down_status, trade_time, user_id, count, abroad, rec_status, scene_num, scene_name
-		) VALUES (
-		#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.downStatus}, #{entity.tradeTime}, #{entity.userId}, #{entity.count}, #{entity.abroad}, #{entity.recStatus}, #{entity.sceneNum}, #{entity.sceneName}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, down_status, trade_time, user_id, count, abroad, rec_status, scene_num, scene_name
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.downStatus}, #{entity.tradeTime}, #{entity.userId}, #{entity.count}, #{entity.abroad}, #{entity.recStatus}, #{entity.sceneNum}, #{entity.sceneName})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		order_sn=#{entity.orderSn}, amount=#{entity.amount}, number=#{entity.number}, pay_type=#{entity.payType}, pay_status=#{entity.payStatus}, down_status=#{entity.downStatus}, trade_time=#{entity.tradeTime}, user_id=#{entity.userId}, count=#{entity.count}, abroad=#{entity.abroad}, rec_status=#{entity.recStatus}, scene_num=#{entity.sceneNum}, scene_name=#{entity.sceneName}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/ExpansionOrderMapper.xml

@@ -1,128 +0,0 @@
-<?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.goods.mapper.IExpansionOrderMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.ExpansionOrder">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="order_sn" jdbcType="VARCHAR" property="orderSn" />
-		<result column="amount" jdbcType="DECIMAL" property="amount" />
-		<result column="number" jdbcType="VARCHAR" property="number" />
-		<result column="pay_type" jdbcType="INTEGER" property="payType" />
-		<result column="pay_status" jdbcType="INTEGER" property="payStatus" />
-		<result column="status" jdbcType="INTEGER" property="status" />
-		<result column="trade_time" jdbcType="TIMESTAMP" property="tradeTime" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="month" jdbcType="INTEGER" property="month" />
-		<result column="years" jdbcType="INTEGER" property="years" />
-		<result column="delay" jdbcType="INTEGER" property="delay" />
-		<result column="unit_size" jdbcType="INTEGER" property="unitSize" />
-		<result column="unit" jdbcType="VARCHAR" property="unit" />
-		<result column="camera_id" jdbcType="VARCHAR" property="cameraId" />
-		<result column="abroad" jdbcType="INTEGER" property="abroad" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,order_sn,amount,number,pay_type,pay_status,status,trade_time,user_id,month,years,delay,unit_size,unit,camera_id,abroad,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, status, trade_time, user_id, month, years, delay, unit_size, unit, camera_id, abroad, rec_status
-		) VALUES (
-		#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.status}, #{entity.tradeTime}, #{entity.userId}, #{entity.month}, #{entity.years}, #{entity.delay}, #{entity.unitSize}, #{entity.unit}, #{entity.cameraId}, #{entity.abroad}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, status, trade_time, user_id, month, years, delay, unit_size, unit, camera_id, abroad, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.status}, #{entity.tradeTime}, #{entity.userId}, #{entity.month}, #{entity.years}, #{entity.delay}, #{entity.unitSize}, #{entity.unit}, #{entity.cameraId}, #{entity.abroad}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		order_sn=#{entity.orderSn}, amount=#{entity.amount}, number=#{entity.number}, pay_type=#{entity.payType}, pay_status=#{entity.payStatus}, status=#{entity.status}, trade_time=#{entity.tradeTime}, user_id=#{entity.userId}, month=#{entity.month}, years=#{entity.years}, delay=#{entity.delay}, unit_size=#{entity.unitSize}, unit=#{entity.unit}, camera_id=#{entity.cameraId}, abroad=#{entity.abroad}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/GoodsMapper.xml

@@ -1,123 +0,0 @@
-<?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.goods.mapper.IGoodsMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.Goods">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="good_name" jdbcType="VARCHAR" property="goodName" />
-		<result column="description" jdbcType="VARCHAR" property="description" />
-		<result column="goods_sn" jdbcType="VARCHAR" property="goodsSn" />
-		<result column="goods_status" jdbcType="VARCHAR" property="goodsStatus" />
-		<result column="image_url" jdbcType="VARCHAR" property="imageUrl" />
-		<result column="pic" jdbcType="VARCHAR" property="pic" />
-		<result column="express_price" jdbcType="DECIMAL" property="expressPrice" />
-		<result column="sort" jdbcType="INTEGER" property="sort" />
-		<result column="goods_price" jdbcType="DECIMAL" property="goodsPrice" />
-		<result column="goods_dollar_price" jdbcType="DECIMAL" property="goodsDollarPrice" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,good_name,description,goods_sn,goods_status,image_url,pic,express_price,sort,goods_price,goods_dollar_price,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		good_name, description, goods_sn, goods_status, image_url, pic, express_price, sort, goods_price, goods_dollar_price, rec_status
-		) VALUES (
-		#{entity.goodName}, #{entity.description}, #{entity.goodsSn}, #{entity.goodsStatus}, #{entity.imageUrl}, #{entity.pic}, #{entity.expressPrice}, #{entity.sort}, #{entity.goodsPrice}, #{entity.goodsDollarPrice}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		good_name, description, goods_sn, goods_status, image_url, pic, express_price, sort, goods_price, goods_dollar_price, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.goodName}, #{entity.description}, #{entity.goodsSn}, #{entity.goodsStatus}, #{entity.imageUrl}, #{entity.pic}, #{entity.expressPrice}, #{entity.sort}, #{entity.goodsPrice}, #{entity.goodsDollarPrice}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		good_name=#{entity.goodName}, description=#{entity.description}, goods_sn=#{entity.goodsSn}, goods_status=#{entity.goodsStatus}, image_url=#{entity.imageUrl}, pic=#{entity.pic}, express_price=#{entity.expressPrice}, sort=#{entity.sort}, goods_price=#{entity.goodsPrice}, goods_dollar_price=#{entity.goodsDollarPrice}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/GoodsSkuMapper.xml

@@ -1,122 +0,0 @@
-<?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.goods.mapper.IGoodsSkuMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.GoodsSku">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="goods_id" jdbcType="VARCHAR" property="goodsId" />
-		<result column="sku_sn" jdbcType="VARCHAR" property="skuSn" />
-		<result column="description" jdbcType="VARCHAR" property="description" />
-		<result column="stock" jdbcType="INTEGER" property="stock" />
-		<result column="price" jdbcType="DECIMAL" property="price" />
-		<result column="dollar_price" jdbcType="DECIMAL" property="dollarPrice" />
-		<result column="unit_size" jdbcType="INTEGER" property="unitSize" />
-		<result column="unit" jdbcType="VARCHAR" property="unit" />
-		<result column="month" jdbcType="INTEGER" property="month" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,goods_id,sku_sn,description,stock,price,dollar_price,unit_size,unit,month,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		goods_id, sku_sn, description, stock, price, dollar_price, unit_size, unit, month, rec_status
-		) VALUES (
-		#{entity.goodsId}, #{entity.skuSn}, #{entity.description}, #{entity.stock}, #{entity.price}, #{entity.dollarPrice}, #{entity.unitSize}, #{entity.unit}, #{entity.month}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		goods_id, sku_sn, description, stock, price, dollar_price, unit_size, unit, month, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.goodsId}, #{entity.skuSn}, #{entity.description}, #{entity.stock}, #{entity.price}, #{entity.dollarPrice}, #{entity.unitSize}, #{entity.unit}, #{entity.month}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		goods_id=#{entity.goodsId}, sku_sn=#{entity.skuSn}, description=#{entity.description}, stock=#{entity.stock}, price=#{entity.price}, dollar_price=#{entity.dollarPrice}, unit_size=#{entity.unitSize}, unit=#{entity.unit}, month=#{entity.month}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/GoodsSpecMapper.xml

@@ -1,114 +0,0 @@
-<?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.goods.mapper.IGoodsSpecMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.GoodsSpec">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="spec_name" jdbcType="VARCHAR" property="specName" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,spec_name,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		spec_name, rec_status
-		) VALUES (
-		#{entity.specName}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		spec_name, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.specName}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		spec_name=#{entity.specName}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/GoodsSpecValueMapper.xml

@@ -1,115 +0,0 @@
-<?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.goods.mapper.IGoodsSpecValueMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.GoodsSpecValue">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="goods_spec_id" jdbcType="VARCHAR" property="goodsSpecId" />
-		<result column="goods_spec_value" jdbcType="VARCHAR" property="goodsSpecValue" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,goods_spec_id,goods_spec_value,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		goods_spec_id, goods_spec_value, rec_status
-		) VALUES (
-		#{entity.goodsSpecId}, #{entity.goodsSpecValue}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		goods_spec_id, goods_spec_value, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.goodsSpecId}, #{entity.goodsSpecValue}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		goods_spec_id=#{entity.goodsSpecId}, goods_spec_value=#{entity.goodsSpecValue}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/goods/GoodsSpuSpecMapper.xml

@@ -1,115 +0,0 @@
-<?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.goods.mapper.IGoodsSpuSpecMapper">
-	<resultMap id="resultMap" type="com.fdkankan.goods.entity.GoodsSpuSpec">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="goods_id" jdbcType="VARCHAR" property="goodsId" />
-		<result column="goods_spec_id" jdbcType="VARCHAR" property="goodsSpecId" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,goods_id,goods_spec_id,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		goods_id, goods_spec_id, rec_status
-		) VALUES (
-		#{entity.goodsId}, #{entity.goodsSpecId}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		goods_id, goods_spec_id, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.goodsId}, #{entity.goodsSpecId}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		goods_id=#{entity.goodsId}, goods_spec_id=#{entity.goodsSpecId}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/order/IncrementOrderMapper.xml

@@ -1,124 +0,0 @@
-<?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.order.mapper.IIncrementOrderMapper">
-	<resultMap id="resultMap" type="com.fdkankan.order.entity.IncrementOrder">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="order_sn" jdbcType="VARCHAR" property="orderSn" />
-		<result column="amount" jdbcType="DECIMAL" property="amount" />
-		<result column="number" jdbcType="VARCHAR" property="number" />
-		<result column="pay_type" jdbcType="INTEGER" property="payType" />
-		<result column="pay_status" jdbcType="INTEGER" property="payStatus" />
-		<result column="status" jdbcType="INTEGER" property="status" />
-		<result column="trade_time" jdbcType="TIMESTAMP" property="tradeTime" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="increment_id" jdbcType="VARCHAR" property="incrementId" />
-		<result column="count" jdbcType="INTEGER" property="count" />
-		<result column="abroad" jdbcType="INTEGER" property="abroad" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,order_sn,amount,number,pay_type,pay_status,status,trade_time,user_id,increment_id,count,abroad,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, status, trade_time, user_id, increment_id, count, abroad, rec_status
-		) VALUES (
-		#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.status}, #{entity.tradeTime}, #{entity.userId}, #{entity.incrementId}, #{entity.count}, #{entity.abroad}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		order_sn, amount, number, pay_type, pay_status, status, trade_time, user_id, increment_id, count, abroad, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.orderSn}, #{entity.amount}, #{entity.number}, #{entity.payType}, #{entity.payStatus}, #{entity.status}, #{entity.tradeTime}, #{entity.userId}, #{entity.incrementId}, #{entity.count}, #{entity.abroad}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		order_sn=#{entity.orderSn}, amount=#{entity.amount}, number=#{entity.number}, pay_type=#{entity.payType}, pay_status=#{entity.payStatus}, status=#{entity.status}, trade_time=#{entity.tradeTime}, user_id=#{entity.userId}, increment_id=#{entity.incrementId}, count=#{entity.count}, abroad=#{entity.abroad}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/order/IncrementTypeMapper.xml

@@ -1,122 +0,0 @@
-<?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.order.mapper.IIncrementTypeMapper">
-	<resultMap id="resultMap" type="com.fdkankan.order.entity.IncrementType">
-		<id column="id" jdbcType="INTEGER" property="id" />
-		<result column="increment_name" jdbcType="VARCHAR" property="incrementName" />
-		<result column="download_num" jdbcType="INTEGER" property="downloadNum" />
-		<result column="duration" jdbcType="INTEGER" property="duration" />
-		<result column="duration_type" jdbcType="INTEGER" property="durationType" />
-		<result column="end_time" jdbcType="TIMESTAMP" property="endTime" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="CHAR" property="recStatus" />
-		<result column="create_user" jdbcType="INTEGER" property="createUser" />
-		<result column="update_user" jdbcType="INTEGER" property="updateUser" />
-		<result column="price" jdbcType="DOUBLE" property="price" />
-		<result column="start_time" jdbcType="TIMESTAMP" property="startTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,increment_name,download_num,duration,duration_type,end_time,create_time,update_time,rec_status,create_user,update_user,price,start_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		increment_name, download_num, duration, duration_type, end_time, rec_status, create_user, update_user, price, start_time
-		) VALUES (
-		#{entity.incrementName}, #{entity.downloadNum}, #{entity.duration}, #{entity.durationType}, #{entity.endTime}, #{entity.recStatus}, #{entity.createUser}, #{entity.updateUser}, #{entity.price}, #{entity.startTime}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		increment_name, download_num, duration, duration_type, end_time, rec_status, create_user, update_user, price, start_time
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.incrementName}, #{entity.downloadNum}, #{entity.duration}, #{entity.durationType}, #{entity.endTime}, #{entity.recStatus}, #{entity.createUser}, #{entity.updateUser}, #{entity.price}, #{entity.startTime})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		increment_name=#{entity.incrementName}, download_num=#{entity.downloadNum}, duration=#{entity.duration}, duration_type=#{entity.durationType}, end_time=#{entity.endTime}, rec_status=#{entity.recStatus}, create_user=#{entity.createUser}, update_user=#{entity.updateUser}, price=#{entity.price}, start_time=#{entity.startTime}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/order/IntercomMessageMapper.xml

@@ -1,120 +0,0 @@
-<?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.order.mapper.IIntercomMessageMapper">
-	<resultMap id="resultMap" type="com.fdkankan.order.entity.IntercomMessage">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="email" jdbcType="VARCHAR" property="email" />
-		<result column="content" jdbcType="VARCHAR" property="content" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="phone" jdbcType="VARCHAR" property="phone" />
-		<result column="note_type" jdbcType="INTEGER" property="noteType" />
-		<result column="note_content" jdbcType="VARCHAR" property="noteContent" />
-		<result column="state" jdbcType="INTEGER" property="state" />
-		<result column="contact" jdbcType="VARCHAR" property="contact" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,email,content,create_time,update_time,rec_status,phone,note_type,note_content,state,contact,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		email, content, rec_status, phone, note_type, note_content, state, contact
-		) VALUES (
-		#{entity.email}, #{entity.content}, #{entity.recStatus}, #{entity.phone}, #{entity.noteType}, #{entity.noteContent}, #{entity.state}, #{entity.contact}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		email, content, rec_status, phone, note_type, note_content, state, contact
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.email}, #{entity.content}, #{entity.recStatus}, #{entity.phone}, #{entity.noteType}, #{entity.noteContent}, #{entity.state}, #{entity.contact})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		email=#{entity.email}, content=#{entity.content}, rec_status=#{entity.recStatus}, phone=#{entity.phone}, note_type=#{entity.noteType}, note_content=#{entity.noteContent}, state=#{entity.state}, contact=#{entity.contact}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/order/ManagerMapper.xml

@@ -1,119 +0,0 @@
-<?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.order.mapper.IManagerMapper">
-	<resultMap id="resultMap" type="com.fdkankan.order.entity.Manager">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="nickname" jdbcType="VARCHAR" property="nickname" />
-		<result column="username" jdbcType="VARCHAR" property="username" />
-		<result column="password" jdbcType="VARCHAR" property="password" />
-		<result column="is_company" jdbcType="INTEGER" property="isCompany" />
-		<result column="agent_framework_id" jdbcType="VARCHAR" property="agentFrameworkId" />
-		<result column="manager_role_id" jdbcType="VARCHAR" property="managerRoleId" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,nickname,username,password,is_company,agent_framework_id,manager_role_id,create_time,update_time,rec_status,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		nickname, username, password, is_company, agent_framework_id, manager_role_id, rec_status
-		) VALUES (
-		#{entity.nickname}, #{entity.username}, #{entity.password}, #{entity.isCompany}, #{entity.agentFrameworkId}, #{entity.managerRoleId}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		nickname, username, password, is_company, agent_framework_id, manager_role_id, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.nickname}, #{entity.username}, #{entity.password}, #{entity.isCompany}, #{entity.agentFrameworkId}, #{entity.managerRoleId}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		nickname=#{entity.nickname}, username=#{entity.username}, password=#{entity.password}, is_company=#{entity.isCompany}, agent_framework_id=#{entity.agentFrameworkId}, manager_role_id=#{entity.managerRoleId}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/order/OrderItemMapper.xml

@@ -1,123 +0,0 @@
-<?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.order.mapper.IOrderItemMapper">
-	<resultMap id="resultMap" type="com.fdkankan.order.entity.OrderItem">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="goods_name" jdbcType="VARCHAR" property="goodsName" />
-		<result column="goods_price" jdbcType="DECIMAL" property="goodsPrice" />
-		<result column="goods_count" jdbcType="INTEGER" property="goodsCount" />
-		<result column="goods_sn" jdbcType="VARCHAR" property="goodsSn" />
-		<result column="sku_sn" jdbcType="VARCHAR" property="skuSn" />
-		<result column="goods_id" jdbcType="VARCHAR" property="goodsId" />
-		<result column="order_id" jdbcType="VARCHAR" property="orderId" />
-		<result column="express_name" jdbcType="VARCHAR" property="expressName" />
-		<result column="express_num" jdbcType="VARCHAR" property="expressNum" />
-		<result column="shipping_status" jdbcType="VARCHAR" property="shippingStatus" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,goods_name,goods_price,goods_count,goods_sn,sku_sn,goods_id,order_id,express_name,express_num,shipping_status,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		goods_name, goods_price, goods_count, goods_sn, sku_sn, goods_id, order_id, express_name, express_num, shipping_status, rec_status
-		) VALUES (
-		#{entity.goodsName}, #{entity.goodsPrice}, #{entity.goodsCount}, #{entity.goodsSn}, #{entity.skuSn}, #{entity.goodsId}, #{entity.orderId}, #{entity.expressName}, #{entity.expressNum}, #{entity.shippingStatus}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		goods_name, goods_price, goods_count, goods_sn, sku_sn, goods_id, order_id, express_name, express_num, shipping_status, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.goodsName}, #{entity.goodsPrice}, #{entity.goodsCount}, #{entity.goodsSn}, #{entity.skuSn}, #{entity.goodsId}, #{entity.orderId}, #{entity.expressName}, #{entity.expressNum}, #{entity.shippingStatus}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		goods_name=#{entity.goodsName}, goods_price=#{entity.goodsPrice}, goods_count=#{entity.goodsCount}, goods_sn=#{entity.goodsSn}, sku_sn=#{entity.skuSn}, goods_id=#{entity.goodsId}, order_id=#{entity.orderId}, express_name=#{entity.expressName}, express_num=#{entity.expressNum}, shipping_status=#{entity.shippingStatus}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/PreSaleMapper.xml

@@ -1,121 +0,0 @@
-<?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.user.mapper.IPreSaleMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.PreSale">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="user_name" jdbcType="VARCHAR" property="userName" />
-		<result column="phone" jdbcType="VARCHAR" property="phone" />
-		<result column="scene_index" jdbcType="INTEGER" property="sceneIndex" />
-		<result column="description" jdbcType="VARCHAR" property="description" />
-		<result column="weixin" jdbcType="VARCHAR" property="weixin" />
-		<result column="enterprise_name" jdbcType="VARCHAR" property="enterpriseName" />
-		<result column="count" jdbcType="INTEGER" property="count" />
-		<result column="order_time" jdbcType="TIMESTAMP" property="orderTime" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,user_name,phone,scene_index,description,weixin,enterprise_name,count,order_time,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		user_name, phone, scene_index, description, weixin, enterprise_name, count, order_time, rec_status
-		) VALUES (
-		#{entity.userName}, #{entity.phone}, #{entity.sceneIndex}, #{entity.description}, #{entity.weixin}, #{entity.enterpriseName}, #{entity.count}, #{entity.orderTime}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		user_name, phone, scene_index, description, weixin, enterprise_name, count, order_time, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.userName}, #{entity.phone}, #{entity.sceneIndex}, #{entity.description}, #{entity.weixin}, #{entity.enterpriseName}, #{entity.count}, #{entity.orderTime}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		user_name=#{entity.userName}, phone=#{entity.phone}, scene_index=#{entity.sceneIndex}, description=#{entity.description}, weixin=#{entity.weixin}, enterprise_name=#{entity.enterpriseName}, count=#{entity.count}, order_time=#{entity.orderTime}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/ProvinceMapper.xml

@@ -1,114 +0,0 @@
-<?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.user.mapper.IProvinceMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.Province">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="name" jdbcType="VARCHAR" property="name" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,name,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		name, rec_status
-		) VALUES (
-		#{entity.name}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		name, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.name}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		name=#{entity.name}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/ReceiverInfoMapper.xml

@@ -1,123 +0,0 @@
-<?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.user.mapper.IReceiverInfoMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.ReceiverInfo">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="ship_name" jdbcType="VARCHAR" property="shipName" />
-		<result column="ship_mobile" jdbcType="VARCHAR" property="shipMobile" />
-		<result column="ship_area" jdbcType="VARCHAR" property="shipArea" />
-		<result column="ship_address" jdbcType="VARCHAR" property="shipAddress" />
-		<result column="set_default" jdbcType="INTEGER" property="setDefault" />
-		<result column="country" jdbcType="VARCHAR" property="country" />
-		<result column="ship_area_path" jdbcType="VARCHAR" property="shipAreaPath" />
-		<result column="ship_phone" jdbcType="VARCHAR" property="shipPhone" />
-		<result column="ship_zip_code" jdbcType="VARCHAR" property="shipZipCode" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,user_id,ship_name,ship_mobile,ship_area,ship_address,set_default,country,ship_area_path,ship_phone,ship_zip_code,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		user_id, ship_name, ship_mobile, ship_area, ship_address, set_default, country, ship_area_path, ship_phone, ship_zip_code, rec_status
-		) VALUES (
-		#{entity.userId}, #{entity.shipName}, #{entity.shipMobile}, #{entity.shipArea}, #{entity.shipAddress}, #{entity.setDefault}, #{entity.country}, #{entity.shipAreaPath}, #{entity.shipPhone}, #{entity.shipZipCode}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		user_id, ship_name, ship_mobile, ship_area, ship_address, set_default, country, ship_area_path, ship_phone, ship_zip_code, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.userId}, #{entity.shipName}, #{entity.shipMobile}, #{entity.shipArea}, #{entity.shipAddress}, #{entity.setDefault}, #{entity.country}, #{entity.shipAreaPath}, #{entity.shipPhone}, #{entity.shipZipCode}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		user_id=#{entity.userId}, ship_name=#{entity.shipName}, ship_mobile=#{entity.shipMobile}, ship_area=#{entity.shipArea}, ship_address=#{entity.shipAddress}, set_default=#{entity.setDefault}, country=#{entity.country}, ship_area_path=#{entity.shipAreaPath}, ship_phone=#{entity.shipPhone}, ship_zip_code=#{entity.shipZipCode}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/SnCodeMapper.xml

@@ -1,113 +0,0 @@
-<?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.user.mapper.ISnCodeMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.SnCode">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="sn_code" jdbcType="VARCHAR" property="snCode" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,sn_code,create_time,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		sn_code
-		) VALUES (
-		#{entity.snCode}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		sn_code
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.snCode})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		sn_code=#{entity.snCode}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/SpaceSdkMapper.xml

@@ -1,122 +0,0 @@
-<?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.user.mapper.ISpaceSdkMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.SpaceSdk">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="version" jdbcType="VARCHAR" property="version" />
-		<result column="imprint_ch" jdbcType="VARCHAR" property="imprintCh" />
-		<result column="imprint_en" jdbcType="VARCHAR" property="imprintEn" />
-		<result column="publish_time" jdbcType="TIMESTAMP" property="publishTime" />
-		<result column="is_top" jdbcType="INTEGER" property="isTop" />
-		<result column="status" jdbcType="INTEGER" property="status" />
-		<result column="platform_type" jdbcType="VARCHAR" property="platformType" />
-		<result column="file_name" jdbcType="VARCHAR" property="fileName" />
-		<result column="file_url" jdbcType="VARCHAR" property="fileUrl" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,version,imprint_ch,imprint_en,publish_time,is_top,status,platform_type,file_name,file_url,create_time,update_time,rec_status,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		version, imprint_ch, imprint_en, publish_time, is_top, status, platform_type, file_name, file_url, rec_status
-		) VALUES (
-		#{entity.version}, #{entity.imprintCh}, #{entity.imprintEn}, #{entity.publishTime}, #{entity.isTop}, #{entity.status}, #{entity.platformType}, #{entity.fileName}, #{entity.fileUrl}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		version, imprint_ch, imprint_en, publish_time, is_top, status, platform_type, file_name, file_url, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.version}, #{entity.imprintCh}, #{entity.imprintEn}, #{entity.publishTime}, #{entity.isTop}, #{entity.status}, #{entity.platformType}, #{entity.fileName}, #{entity.fileUrl}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		version=#{entity.version}, imprint_ch=#{entity.imprintCh}, imprint_en=#{entity.imprintEn}, publish_time=#{entity.publishTime}, is_top=#{entity.isTop}, status=#{entity.status}, platform_type=#{entity.platformType}, file_name=#{entity.fileName}, file_url=#{entity.fileUrl}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/TradeLogMapper.xml

@@ -1,122 +0,0 @@
-<?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.user.mapper.ITradeLogMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.TradeLog">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="number" jdbcType="VARCHAR" property="number" />
-		<result column="order_sn" jdbcType="VARCHAR" property="orderSn" />
-		<result column="amount" jdbcType="DECIMAL" property="amount" />
-		<result column="trade_time" jdbcType="TIMESTAMP" property="tradeTime" />
-		<result column="pay_type" jdbcType="INTEGER" property="payType" />
-		<result column="pay_status" jdbcType="INTEGER" property="payStatus" />
-		<result column="openid" jdbcType="VARCHAR" property="openid" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="abroad" jdbcType="INTEGER" property="abroad" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,number,order_sn,amount,trade_time,pay_type,pay_status,openid,user_id,abroad,create_time,rec_status,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		number, order_sn, amount, trade_time, pay_type, pay_status, openid, user_id, abroad, rec_status
-		) VALUES (
-		#{entity.number}, #{entity.orderSn}, #{entity.amount}, #{entity.tradeTime}, #{entity.payType}, #{entity.payStatus}, #{entity.openid}, #{entity.userId}, #{entity.abroad}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		number, order_sn, amount, trade_time, pay_type, pay_status, openid, user_id, abroad, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.number}, #{entity.orderSn}, #{entity.amount}, #{entity.tradeTime}, #{entity.payType}, #{entity.payStatus}, #{entity.openid}, #{entity.userId}, #{entity.abroad}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		number=#{entity.number}, order_sn=#{entity.orderSn}, amount=#{entity.amount}, trade_time=#{entity.tradeTime}, pay_type=#{entity.payType}, pay_status=#{entity.payStatus}, openid=#{entity.openid}, user_id=#{entity.userId}, abroad=#{entity.abroad}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/UserIncrementMapper.xml

@@ -1,122 +0,0 @@
-<?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.user.mapper.IUserIncrementMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.UserIncrement">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="key_word" jdbcType="VARCHAR" property="keyWord" />
-		<result column="user_id" jdbcType="VARCHAR" property="userId" />
-		<result column="camera_id" jdbcType="VARCHAR" property="cameraId" />
-		<result column="increment_type_id" jdbcType="INTEGER" property="incrementTypeId" />
-		<result column="increment_end_time" jdbcType="TIMESTAMP" property="incrementEndTime" />
-		<result column="is_expired" jdbcType="INTEGER" property="isExpired" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="order_sn" jdbcType="LONGVARCHAR" property="orderSn" />
-		<result column="increment_start_time" jdbcType="TIMESTAMP" property="incrementStartTime" />
-		<result column="download_num" jdbcType="INTEGER" property="downloadNum" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,key_word,user_id,camera_id,increment_type_id,increment_end_time,is_expired,create_time,rec_status,update_time,order_sn,increment_start_time,download_num,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		key_word, user_id, camera_id, increment_type_id, increment_end_time, is_expired, rec_status, order_sn, increment_start_time, download_num
-		) VALUES (
-		#{entity.keyWord}, #{entity.userId}, #{entity.cameraId}, #{entity.incrementTypeId}, #{entity.incrementEndTime}, #{entity.isExpired}, #{entity.recStatus}, #{entity.orderSn}, #{entity.incrementStartTime}, #{entity.downloadNum}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		key_word, user_id, camera_id, increment_type_id, increment_end_time, is_expired, rec_status, order_sn, increment_start_time, download_num
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.keyWord}, #{entity.userId}, #{entity.cameraId}, #{entity.incrementTypeId}, #{entity.incrementEndTime}, #{entity.isExpired}, #{entity.recStatus}, #{entity.orderSn}, #{entity.incrementStartTime}, #{entity.downloadNum})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		key_word=#{entity.keyWord}, user_id=#{entity.userId}, camera_id=#{entity.cameraId}, increment_type_id=#{entity.incrementTypeId}, increment_end_time=#{entity.incrementEndTime}, is_expired=#{entity.isExpired}, rec_status=#{entity.recStatus}, order_sn=#{entity.orderSn}, increment_start_time=#{entity.incrementStartTime}, download_num=#{entity.downloadNum}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-center-platform/target/classes/mapper/user/VaildCamerasMapper.xml

@@ -1,117 +0,0 @@
-<?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.user.mapper.IVaildCamerasMapper">
-	<resultMap id="resultMap" type="com.fdkankan.user.entity.VaildCameras">
-		<id column="id" jdbcType="VARCHAR" property="id" />
-		<result column="company_name" jdbcType="VARCHAR" property="companyName" />
-		<result column="file_path" jdbcType="VARCHAR" property="filePath" />
-		<result column="wifi_name" jdbcType="VARCHAR" property="wifiName" />
-		<result column="devicemac" jdbcType="VARCHAR" property="devicemac" />
-		<result column="rec_status" jdbcType="VARCHAR" property="recStatus" />
-		<result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
-		<result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
-		<result column="tb_status" jdbcType="INTEGER" property="tbStatus" />
-	</resultMap>
-	<sql id="columnList">
-id,company_name,file_path,wifi_name,devicemac,rec_status,create_time,update_time,tb_status	</sql>
-		<insert id="insert" useGeneratedKeys="true" keyProperty="entity.id">
-		INSERT INTO ${tableName} (
-		company_name, file_path, wifi_name, devicemac, rec_status
-		) VALUES (
-		#{entity.companyName}, #{entity.filePath}, #{entity.wifiName}, #{entity.devicemac}, #{entity.recStatus}
-		)	</insert>
-		<insert id="insertByBatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id" >
-		INSERT INTO ${tableName} (
-		company_name, file_path, wifi_name, devicemac, rec_status
-		) VALUES 
-		<foreach collection="list" item="entity" index="index" separator=",">
-			(#{entity.companyName}, #{entity.filePath}, #{entity.wifiName}, #{entity.devicemac}, #{entity.recStatus})
-		</foreach>
-	</insert>
-		<update id="update"  parameterType="java.util.List" >
-		<foreach collection="list" item="entity" index="index" separator=";">
-		UPDATE ${tableName} SET 
-		company_name=#{entity.companyName}, file_path=#{entity.filePath}, wifi_name=#{entity.wifiName}, devicemac=#{entity.devicemac}, rec_status=#{entity.recStatus}, tb_status=#{entity.tbStatus}
-		 WHERE 
-		id = #{entity.id}
-
-		</foreach>
-	</update>
-	<update id="updateByBatch" >
-			UPDATE ${tableName} SET
-				${field}
-			<where>
-				<foreach collection="condition" index="key" item="value">
-					${value} ${key}
-				</foreach>
-			</where>
-	</update>
-	<select id="getById" parameterType="java.lang.Integer" resultMap="resultMap">
-		select
-		<include refid="columnList" />
-		from ${tableName} 
-		where id = #{id}
-	</select>
-	<select id="getOne" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		limit 1;
-	</select>
-	<select id="getCount" parameterType="java.util.Map" resultType="java.lang.Integer">
-		select
-		count(id)
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-	</select>
-	<!-- 这部分为根据传递参数，自动生成SQL -->
-	<select id="getList" parameterType="java.util.Map" resultMap="resultMap">
-		select
-		<if test="field == null">
-			<include refid="columnList" />
-		</if>
-		<if test="field != null">
-			${field}
-		</if>
-		from ${tableName} 
-		<where>
-			<foreach collection="condition" index="key" item="value">
-				${value} ${key}
-			</foreach>
-		</where>
-		<if test="order != null">
-			order by ${order}
-		</if>
-		<if test="limit != 0">
-			<if test="offset != 0">
-				limit ${offset}, ${limit}
-			</if>
-			<if test="offset == 0">
-				limit ${limit}
-			</if>
-		</if>
-	</select>
-	<!-- 判断表格是否存在，如果不存在可以配合createTable使用，用于动态创建表格 -->
-	<select id="existTable" parameterType="String" resultType="java.lang.Integer">
-		select count(table_name) from information_schema.TABLES WHERE table_name=#{tableName} ;
-	</select>
-	<update id="createTable" parameterType="String">
-		<!-- 这里是创建表格的SQL，复制过来，表名作为参数传递 -->
-		<!-- create table ${tableName} (   //  表名要这样写 -->
-	</update>
-</mapper>

4dkankan-common/pom.xml

@@ -14,11 +14,6 @@
     <artifactId>4dkankan-common</artifactId>
 
     <dependencies>
-<!--        <dependency>-->
-<!--            <groupId>org.mybatis.spring.boot</groupId>-->
-<!--            <artifactId>mybatis-spring-boot-starter</artifactId>-->
-<!--        </dependency>-->
-
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

4dkankan-common/src/main/java/com/fdkankan/common/base/request/RequestBase.java

@@ -1,16 +0,0 @@
-package com.fdkankan.common.base.request;
-
-import lombok.Data;
-
-import java.io.Serializable;
-
-@Data
-public class RequestBase implements Serializable {
-
-    private int pageNum;
-
-    private int pageSize;
-
-    private int start;
-
-}

4dkankan-common/src/main/java/com/fdkankan/common/response/BaseResponseAdvice.java

@@ -0,0 +1,31 @@
+package com.fdkankan.common.response;
+
+
+import com.alibaba.fastjson.JSON;
+import org.springframework.core.MethodParameter;
+import org.springframework.http.MediaType;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.server.ServerHttpRequest;
+import org.springframework.http.server.ServerHttpResponse;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
+
+@RestControllerAdvice
+public class BaseResponseAdvice implements ResponseBodyAdvice<Object> {
+    @Override
+    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
+        return true;
+    }
+
+    @Override
+    public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
+        System.out.println("响应拦截成功");
+        if (body instanceof ResultData) {
+            return body;
+        } else if (body == null) {
+            return JSON.toJSONString(ResultData.ok());
+        } else {
+            return JSON.toJSONString( ResultData.ok(body));
+        }
+    }
+}

4dkankan-pom/pom.xml

@@ -67,6 +67,7 @@
             <scope>runtime</scope>
         </dependency>
 
+
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>