ADD req fields

README.md

 https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-document-delete.html
 
 
-https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-document-update-by-query.html
+https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-document-update-by-query.html
+
+
+
+```
+
+```

elastic-publish-service/pom.xml

         </dependency>
 
         <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+
+        <dependency>
             <groupId>org.mybatis.spring.boot</groupId>
             <artifactId>mybatis-spring-boot-starter</artifactId>
             <version>2.1.1</version>
 
     </dependencies>
 
+
     <build>
         <plugins>
-            <!--            <plugin>-->
-            <!--                <groupId>org.springframework.boot</groupId>-->
-            <!--                <artifactId>spring-boot-maven-plugin</artifactId>-->
-            <!--            </plugin>-->
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <addClasspath>true</addClasspath>
+                            <classpathPrefix>lib/</classpathPrefix>
+                            <mainClass>com.vcarecity.publish.ElasticPublishApplication</mainClass>
+                        </manifest>
+                    </archive>
+                    <excludes>
+                        <exclude>rebel.xml</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+
+
+            <plugin>
+                <artifactId>maven-resources-plugin</artifactId>
+                <configuration>
+                    <encoding>UTF-8</encoding>
+                </configuration>
+
+                <executions>
+                    <execution>
+                        <id>copy-resource-config</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>copy-resources</goal>
+                        </goals>
+
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/config</outputDirectory>
+                            <resources>
+                                <resource>
+                                    <directory>${project.basedir}/src/main/resources</directory>
+                                    <include>*.yml</include>
+                                    <include>*.properties</include>
+                                </resource>
+                            </resources>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>copy-resource-logback</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>copy-resources</goal>
+                        </goals>
+
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/config</outputDirectory>
+                            <resources>
+                                <resource>
+                                    <directory>${project.basedir}/config</directory>
+                                    <include>logback-my.xml</include>
+                                </resource>
+                            </resources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.21.0</version>
+                <configuration>
+                    <skipTests>true</skipTests>
+                </configuration>
+            </plugin>
+
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <version>3.0.1</version>
+                <executions>
+
+                    <execution>
+                        <id>copy-dependencies</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>copy-dependencies</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
+
         </plugins>
     </build>
 

elastic-publish-service/req/main-controller.http

 
 {
   "agencyPath": "/1",
-  "keyword": "鱼峰区",
-  "page": 2,
+  "keyword": "",
+  "page": 1,
   "size": 10,
-  "regulatoryLevelId": "27,28",
+  "regulatoryLevelId": "",
   "property": "",
   "classify": "",
   "agencyAttributeClassId": ""
 
 {
   "agencyPath": "/1",
-  "keyword": "鱼峰区",
-  "page": 2,
+  "keyword": "",
+  "page": 1,
   "size": 10,
-  "regulatoryLevelId": "27,28",
+  "regulatoryLevelId": "",
   "property": "",
   "classify": "",
   "agencyAttributeClassId": ""

elastic-publish-service/src/main/java/com/vcarecity/publish/annotation/SkipMethod.java

+package com.vcarecity.publish.annotation;
+
+/**
+ * @author VcKerry on 12/20/19
+ */
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author VcKerry
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = {ElementType.METHOD})
+public @interface SkipMethod {
+    String value() default "";
+}

elastic-publish-service/src/main/java/com/vcarecity/publish/aop/PrepareAopController.java

+package com.vcarecity.publish.aop;
+
+import com.vcarecity.publish.api.ApiResult;
+import com.vcarecity.publish.controller.PrepareController;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author VcKerry on 12/20/19
+ */
+
+@Aspect
+@Component
+public class PrepareAopController {
+
+
+    @Pointcut("execution(public * com.vcarecity.publish.controller.*.*(..))")
+    public void preparePointcut() {
+
+    }
+
+
+    @Around("preparePointcut()")
+    public Object check(ProceedingJoinPoint pjp) throws Throwable {
+        Object target = pjp.getTarget();
+
+        if (target instanceof PrepareController) {
+
+            if (((PrepareController) target).isPrepare()) {
+                return pjp.proceed();
+            }
+            // 数据没有准备好...
+            return ApiResult.builder().status(40000).message("data loading ").build();
+        }
+
+        return pjp.proceed();
+    }
+
+}

elastic-publish-service/src/main/java/com/vcarecity/publish/constants/ElasticConstant.java

 package com.vcarecity.publish.constants;
 
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+
 /**
  * @author VcKerry on 12/18/19
  */
 
 
     public static final int QUERY_PAGE_COUNT = 2000;
+
+
+    /**
+     * ElasticSearch 查询时的时间格式,插入JSON时的时间格式
+     */
+    public static final String ES_DATETIME_PATTERN = "yyyy/MM/dd HH:mm:ss";
+    public static final DateTimeFormatter ES_DT_FORMATTER = DateTimeFormatter.ofPattern(ES_DATETIME_PATTERN);
+
+
+    public static final String SYSTEM_TIMEZONE = ZoneId.systemDefault().getId();
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/controller/MainController.java

 package com.vcarecity.publish.controller;
 
+import com.vcarecity.publish.annotation.SkipMethod;
 import com.vcarecity.publish.api.ApiResult;
 import com.vcarecity.publish.api.ApiStatus;
 import com.vcarecity.publish.constants.ElasticConstant;
+import com.vcarecity.publish.elastic.service.ElasticLoadDataService;
 import com.vcarecity.publish.pojo.dto.UnitAgencyDTO;
+import com.vcarecity.publish.pojo.dto.UnitIdDTO;
 import com.vcarecity.publish.pojo.query.UnitAgencyQuery;
 import com.vcarecity.publish.sql.service.UnitService;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 import javax.validation.Valid;
 import java.io.IOException;
 import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * @author Kerry on 19/12/11
  */
 
 @RestController
-public class MainController {
+public class MainController implements PrepareController {
+
+    private int status = -1;
 
     private final UnitService unitService;
+    private final ElasticLoadDataService elasticLoadDataService;
 
-    public MainController(UnitService unitService) {
+    public MainController(UnitService unitService, ElasticLoadDataService elasticLoadDataService) {
         this.unitService = unitService;
+        this.elasticLoadDataService = elasticLoadDataService;
+    }
+
+
+    @RequestMapping(value = "/load", method = {RequestMethod.GET, RequestMethod.POST})
+    public ApiResult loadData() {
+        if (status == -1) {
+            status = 0;
+            synchronized (this) {
+                new Thread(() -> {
+                    try {
+                        elasticLoadDataService.loadData();
+                        status = 1;
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                        status = -1;
+                    }
+                }).start();
+            }
+        }
+        return ApiResult.builder().status(40000).message("loading data").build();
     }
 
+
     @PostMapping("/query-unit-agency")
     public ApiResult queryUnitAgency(@RequestBody @Valid UnitAgencyQuery unitAgencyQuery) throws IOException {
-        final List<UnitAgencyDTO> unitAgencyByQuery = unitService.getUnitAgencyByQuery(unitAgencyQuery, ElasticConstant.UNIT_AGENCY_INDEX);
 
-        List<Long> data = unitAgencyByQuery.stream().map(UnitAgencyDTO::getUnitId).collect(Collectors.toList());
+        List<UnitIdDTO> data = unitService.getUnitAgencyByQuery(unitAgencyQuery, UnitIdDTO.class, ElasticConstant.UNIT_AGENCY_INDEX);
+
         return ApiResult.builder().status(ApiStatus.SUCCESS_CODE).data(data).build();
     }
 
     @PostMapping("/test/query-unit-agency")
     public ApiResult testQueryUnitAgency(@RequestBody @Valid UnitAgencyQuery unitAgencyQuery) throws IOException {
-        List<UnitAgencyDTO> data = unitService.getUnitAgencyByQuery(unitAgencyQuery, ElasticConstant.UNIT_AGENCY_INDEX);
+        List<UnitAgencyDTO> data = unitService.getUnitAgencyByQuery(unitAgencyQuery, UnitAgencyDTO.class, ElasticConstant.UNIT_AGENCY_INDEX);
         return ApiResult.builder().status(ApiStatus.SUCCESS_CODE).data(data).build();
     }
 
-
+    @SkipMethod
+    @Override
+    public boolean isPrepare() {
+        return false;
+    }
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/controller/PrepareController.java

+package com.vcarecity.publish.controller;
+
+import com.vcarecity.publish.annotation.SkipMethod;
+
+/**
+ * @author VcKerry on 12/20/19
+ */
+
+public interface PrepareController {
+
+
+    /**
+     * is success
+     *
+     * @return
+     */
+    @SkipMethod
+    boolean isPrepare();
+
+}

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/ElasticIndexService.java

      * create index
      *
      * @param indices
+     * @return
+     * @throws IOException
      */
-    void createIndex(String... indices);
+    boolean createIndex(String indices) throws IOException;
 
     /**
      * delete index

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/impl/ElasticIndexServiceImpl.java

 import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
 import org.elasticsearch.client.RequestOptions;
 import org.elasticsearch.client.RestHighLevelClient;
+import org.elasticsearch.client.indices.CreateIndexRequest;
+import org.elasticsearch.client.indices.CreateIndexResponse;
 import org.elasticsearch.client.indices.GetIndexRequest;
+import org.elasticsearch.common.xcontent.XContentType;
 import org.springframework.stereotype.Service;
 
 import java.io.IOException;
     }
 
     @Override
-    public void createIndex(String... indices) {
+    public boolean createIndex(String index) throws IOException {
+
+        CreateIndexRequest request = new CreateIndexRequest(index);
+
+        // mapping
+        //language=JSON
+        String mapping = "{\n" +
+                "  \"properties\": {\n" +
+                "    \"agencyName\": {\n" +
+                "      \"type\": \"text\",\n" +
+                "      \"analyzer\": \"ik_max_word\",\n" +
+                "      \"search_analyzer\": \"ik_smart\"\n" +
+                "    },\n" +
+                "    \"agencyDetail\": {\n" +
+                "      \"type\": \"text\",\n" +
+                "      \"analyzer\": \"ik_max_word\",\n" +
+                "      \"search_analyzer\": \"ik_smart\"\n" +
+                "    },\n" +
+                "    \"nameOfBuilding\": {\n" +
+                "      \"type\": \"text\",\n" +
+                "      \"analyzer\": \"ik_max_word\",\n" +
+                "      \"search_analyzer\": \"ik_smart\"\n" +
+                "    }\n" +
+                "  " +
+                "}\n" +
+                "}";
+
+        request.mapping(mapping, XContentType.JSON);
+
+        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
+
+        return createIndexResponse.isAcknowledged();
 
     }
 
     public List<String> indices() {
         return null;
     }
+
+
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/entity/UnitAgencyMergeEntity.java

 package com.vcarecity.publish.entity;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.vcarecity.publish.constants.ElasticConstant;
 import lombok.Data;
 
+import java.util.Date;
+
 /**
  * @author VcKerry on 12/17/19
  */
 
     private String puserCode;
 
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = ElasticConstant.ES_DATETIME_PATTERN, timezone = "GMT+8")
+    private Date unitUpdateStamp;
+
     private Long agencyId;
 
     private String agencyPath;

elastic-publish-service/src/main/java/com/vcarecity/publish/pojo/dto/UnitAgencyDTO.java

 package com.vcarecity.publish.pojo.dto;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
 
 /**
  * @author Kerry on 19/12/11
  */
 
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
 @Data
-public class UnitAgencyDTO {
-    private Long unitId;
+public class UnitAgencyDTO extends UnitIdDTO {
     private String agencyName;
     private String agencyDetail;
     private String nameOfBuilding;
+    private String unitType;
+    private String unitUpdateStamp;
     private Long classify;
     private Long property;
     private Long regulatoryLevelId;

elastic-publish-service/src/main/java/com/vcarecity/publish/pojo/dto/UnitIdDTO.java

+package com.vcarecity.publish.pojo.dto;
+
+import lombok.Data;
+
+/**
+ * @author VcKerry on 12/19/19
+ */
+
+@Data
+public class UnitIdDTO {
+    private Long unitId;
+}

elastic-publish-service/src/main/java/com/vcarecity/publish/sql/service/UnitService.java

 package com.vcarecity.publish.sql.service;
 
-import com.vcarecity.publish.pojo.dto.UnitAgencyDTO;
+import com.vcarecity.publish.pojo.dto.UnitIdDTO;
 import com.vcarecity.publish.pojo.query.UnitAgencyQuery;
 
 import java.io.IOException;
      * test
      *
      * @param queryParam
+     * @param cls
      * @param indices
      * @return
      * @throws IOException
      */
-    List<UnitAgencyDTO> getUnitAgencyByQuery(UnitAgencyQuery queryParam, String... indices) throws IOException;
+    <T extends UnitIdDTO> List<T> getUnitAgencyByQuery(UnitAgencyQuery queryParam, Class<T> cls, String... indices) throws IOException;
 
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/sql/service/impl/UnitServiceImpl.java

 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.vcarecity.elastic.util.AgencyPathUtil;
-import com.vcarecity.publish.pojo.dto.UnitAgencyDTO;
+import com.vcarecity.publish.pojo.dto.UnitIdDTO;
 import com.vcarecity.publish.pojo.query.UnitAgencyQuery;
 import com.vcarecity.publish.sql.service.UnitService;
+import com.vcarecity.publish.util.ObjectFieldToMap;
 import com.vcarecity.publish.util.Utils;
 import lombok.extern.slf4j.Slf4j;
 import org.elasticsearch.action.search.SearchRequest;
 import org.elasticsearch.search.SearchHit;
 import org.elasticsearch.search.SearchHits;
 import org.elasticsearch.search.builder.SearchSourceBuilder;
+import org.elasticsearch.search.sort.SortOrder;
 import org.springframework.stereotype.Service;
 
 import java.io.IOException;
             "classify"
     };
 
-    static String[] queryColumns = new String[]{"unitId", "nameOfBuilding", "agencyDetail", "agencyName", "agencyAttributeClassId", "regulatoryLevelId", "property", "classify"};
 
     public UnitServiceImpl(RestHighLevelClient restHighLevelClient,
                            ObjectMapper objectMapper) {
     }
 
     @Override
-    public List<UnitAgencyDTO> getUnitAgencyByQuery(UnitAgencyQuery queryParam, String... indices) throws IOException {
+    public <T extends UnitIdDTO> List<T> getUnitAgencyByQuery(UnitAgencyQuery queryParam, Class<T> cls, String... indices) throws IOException {
+
+
         List<Integer> agencyIdList = AgencyPathUtil.splitAgencyId(queryParam.getAgencyPath());
         if (agencyIdList.isEmpty()) {
             return Collections.emptyList();
         }
+
+        String[] queryFields = ObjectFieldToMap.getField(cls);
+
         QueryBuilder agencyIdBoolQuery = agencyIdListCondition(agencyIdList);
         QueryBuilder keywordBoolQuery = multiInputParamKeywordBool(queryParam.getKeyword());
 
         SearchRequest searchRequest = new SearchRequest();
         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         searchSourceBuilder.query(queryBuilder);
-        searchSourceBuilder.fetchSource(queryColumns, new String[]{});
+        searchSourceBuilder.fetchSource(queryFields, new String[]{});
         searchSourceBuilder.from(from);
         searchSourceBuilder.size(queryParam.getSize());
+
+        searchSourceBuilder.sort("property", SortOrder.ASC);
+        searchSourceBuilder.sort("unitUpdateStamp", SortOrder.ASC);
+        searchSourceBuilder.sort("unitId", SortOrder.ASC);
+
         searchRequest.source(searchSourceBuilder);
         searchRequest.indices(indices);
 
         SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
 
         final SearchHits hits = searchResponse.getHits();
-        List<UnitAgencyDTO> res = new ArrayList<>(hits.getHits().length);
+
+
+        List<T> res = new ArrayList<>(hits.getHits().length);
         for (SearchHit hit : hits.getHits()) {
-            UnitAgencyDTO unitAgencyDTO = objectMapper.readValue(hit.getSourceAsString(), UnitAgencyDTO.class);
-            res.add(unitAgencyDTO);
+            T t = objectMapper.readValue(hit.getSourceAsString(), cls);
+            res.add(t);
         }
         return res;
     }

elastic-publish-service/src/main/java/com/vcarecity/publish/util/ObjectFieldToMap.java

+package com.vcarecity.publish.util;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author VcKerry on 12/19/19
+ */
+
+public class ObjectFieldToMap {
+
+    private static Map<Class<?>, String[]> fieldCache = new HashMap<>();
+
+
+    public static String[] getField(Class<?> cls) {
+
+        String[] fields = fieldCache.get(cls);
+
+        if (fields != null) {
+            return fields;
+        }
+
+        Class<?> clazz = cls;
+
+        List<String> fieldList = new ArrayList<>();
+        while (clazz != Object.class) {
+            Field[] declaredFields = clazz.getDeclaredFields();
+            for (Field declaredField : declaredFields) {
+                fieldList.add(declaredField.getName());
+            }
+            clazz = clazz.getSuperclass();
+        }
+        String[] strings = fieldList.toArray(new String[]{});
+        fieldCache.put(cls, strings);
+        return strings;
+    }
+
+}

elastic-publish-service/src/main/resources/application-beta.yml

+server:
+  port: 7080
+spring:
+  datasource:
+    url: jdbc:mysql:replication://192.168.10.210:6446,192.168.10.210:6447/fmmp?serverTimezone=Asia/Shanghai
+    username: root
+    password: R00T@mysql
+  elasticsearch:
+    rest:
+      uris:
+        - http://192.168.10.104:9200
+        - http://192.168.10.105:9200
+      username: kerry
+      password: abcd!234
+  redis:
+    database: 2
+    host: 192.168.10.112
+    port: 6379
+    password: admin~1(^-^)
+mybatis:
+  type-aliases-package: com.vcarecity.publish.entity
+  mapper-locations: classpath:mapper/*.xml
+  configuration:
+    map-underscore-to-camel-case: true
+debug: true
+app:
+  scheduling:
+    enable: true

elastic-publish-service/src/main/resources/application-dev.yml

 debug: true
 app:
   scheduling:
-    enable: false
+    enable: true

elastic-publish-service/src/main/resources/application.yml

 spring:
   profiles:
-    active: dev
+    active: dev
+    #active: beta

elastic-publish-service/src/main/resources/logback-spring.xml

 
     <springProfile name="dev">
 
+        <logger name="com.vcarecity" level="DEBUG" additivity="false">
+            <appender-ref ref="CONSOLE"/>
+        </logger>
+
+        <logger name="com.vcarecity.publish.mapper.AgencyMapper" level="INFO" additivity="false">
+            <appender-ref ref="CONSOLE"/>
+        </logger>
+
+
+    </springProfile>
+
+
+    <springProfile name="beta">
+
 
         <logger name="com.vcarecity" level="DEBUG" additivity="false">
             <appender-ref ref="CONSOLE"/>

elastic-publish-service/src/main/resources/mapper/AgencyMapper.xml

         <result column="UNIT_ID" property="unitId"/>
         <result column="DTU_NO" property="dtuNo"/>
         <result column="PUSER_CODE" property="puserCode"/>
+        <result column="UNIT_UPDATE_STAMP" property="unitUpdateStamp" javaType="java.util.Date"/>
         <result column="ISDELETED" property="isDeleted"/>
         <result column="AGENCY_ID" property="agencyId"/>
         <result column="AGENCY_PATH" property="agencyPath"/>
         SELECT TU.UNIT_ID,
                TU.DTU_NO,
                TU.PUSER_CODE,
+               TU.UPDATESTAMP UNIT_UPDATE_STAMP,
                TAG.AGENCY_ID,
                TAG.AGENCY_PATH,
                TAG.AGENCY_NAME,

elastic-publish-service/src/main/resources/mapper/UnitMapper.xml

 <?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.vcarecity.publish.mapper.UnitMapper">
+
     <resultMap id="unitAgencyMergeEntityMap" type="unitAgencyMergeEntity">
         <result column="UNIT_ID" property="unitId"/>
         <result column="DTU_NO" property="dtuNo"/>
         <result column="PUSER_CODE" property="puserCode"/>
+        <result column="UNIT_UPDATE_STAMP" property="unitUpdateStamp" javaType="java.util.Date"/>
         <result column="ISDELETED" property="isDeleted"/>
         <result column="AGENCY_ID" property="agencyId"/>
         <result column="AGENCY_PATH" property="agencyPath"/>
         SELECT TU.UNIT_ID,
                TU.DTU_NO,
                TU.PUSER_CODE,
+               TU.UPDATESTAMP UNIT_UPDATE_STAMP,
                TU.ISDELETED,
                TAG.AGENCY_ID,
                TAG.AGENCY_PATH,
         SELECT TU.UNIT_ID,
                TU.DTU_NO,
                TU.PUSER_CODE,
+               TU.UPDATESTAMP UNIT_UPDATE_STAMP,
                TAG.AGENCY_ID,
                TAG.AGENCY_PATH,
                TAG.AGENCY_NAME,

elastic-publish-service/src/test/java/com/vcarecity/publish/elastic/service/impl/ElasticIndexServiceImplTest.java

+package com.vcarecity.publish.elastic.service.impl;
+
+import com.vcarecity.publish.elastic.service.ElasticIndexService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.io.IOException;
+
+@SpringBootTest
+class ElasticIndexServiceImplTest {
+
+    @Autowired
+    private ElasticIndexService elasticIndexService;
+
+
+    @Test
+    void indexExist() {
+    }
+
+    @Test
+    void createIndex() throws IOException {
+        elasticIndexService.createIndex("test");
+    }
+
+    @Test
+    void deleteIndex() {
+    }
+
+    @Test
+    void indices() {
+    }
+}

elastic-publish-service/src/test/java/com/vcarecity/publish/elastic/service/impl/ElasticLoadDataServiceImplTest.java

 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.TestPropertySource;
 
 import java.io.IOException;
 
+
+@TestPropertySource(properties = "app.scheduling.enable=false")
 @SpringBootTest
 class ElasticLoadDataServiceImplTest {
 
 
     @Test
     void loadData() throws IOException {
+
         elasticLoadDataService.loadData();
     }
 }