'开发data-agbox-java边缘网关查询用能电、水表统计数据信息两个接口'

data-agbox-java-demo/data-agbox-java-demo-api/pom.xml

@@ -22,8 +22,4 @@
         </dependency>
     </dependencies>
 
-    <build>
-        <finalName>${project.artifactId}</finalName>
-    </build>
-
 </project>

data-agbox-java-demo/data-agbox-java-demo-biz/pom.xml

@@ -9,6 +9,7 @@
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
+
     <artifactId>data-agbox-java-demo-biz</artifactId>
     <dependencies>
         <!--MQTT依赖-->
@@ -20,11 +21,6 @@
             <groupId>org.springframework.integration</groupId>
             <artifactId>spring-integration-mqtt</artifactId>
         </dependency>
-        <!--redis-->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-redis</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis-spring</artifactId>
@@ -35,40 +31,74 @@
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-openfeign-core</artifactId>
         </dependency>
-        <dependency>
-            <groupId>io.springfox</groupId>
-            <artifactId>springfox-swagger2</artifactId>
-            <version>3.0.0</version>
-        </dependency>
         <dependency>
             <groupId>com.usky</groupId>
             <artifactId>usky-common-core</artifactId>
         </dependency>
 
+        <!-- SpringBoot Actuator -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
 
+        <!-- Mysql Connector -->
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-generator</artifactId>
+        </dependency>
 
+        <dependency>
+            <groupId>org.apache.velocity</groupId>
+            <artifactId>velocity-engine-core</artifactId>
+        </dependency>
 
 
         <dependency>
             <groupId>com.usky</groupId>
-            <artifactId>common-cloud-starter</artifactId>
+            <artifactId>service-system-api</artifactId>
         </dependency>
 
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <version>6.0.18.Final</version>
         </dependency>
-        <!-- Pagehelper -->
+
+        <dependency>
+            <groupId>com.usky</groupId>
+            <artifactId>usky-common-security</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.usky</groupId>
+            <artifactId>usky-common-mybatis</artifactId>
+        </dependency>
+
         <dependency>
-            <groupId>com.github.pagehelper</groupId>
-            <artifactId>pagehelper-spring-boot-starter</artifactId>
+            <groupId>com.usky</groupId>
+            <artifactId>usky-common-log</artifactId>
         </dependency>
 
         <dependency>
             <groupId>com.usky</groupId>
             <artifactId>ruoyi-common-swagger</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.7</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-text</artifactId>
+            <version>1.6</version>
+        </dependency>
 
     </dependencies>
 
@@ -87,21 +117,6 @@
                     </execution>
                 </executions>
             </plugin>
-            <plugin>
-                <groupId>com.github.shalousun</groupId>
-                <artifactId>smart-doc-maven-plugin</artifactId>
-                <version>2.1.1</version>
-                <configuration>
-                    <!--指定生成文档的使用的配置文件,配置文件放在自己的项目中-->
-                    <configFile>./src/main/resources/smart-doc.json</configFile>
-                    <!--指定项目名称-->
-                    <projectName>test</projectName>
-                    <!--                    <excludes>-->
-                    <!--                        <exclude>com.bizmatics:product-service-provider</exclude>-->
-                    <!--                        <exclude>cn.afterturn:easypoi-web</exclude>-->
-                    <!--                    </excludes>-->
-                </configuration>
-            </plugin>
         </plugins>
     </build>
 

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/Globals.java

@@ -0,0 +1,34 @@
+package com.usky.demo;
+
+
+/**
+ * 全局变量定义
+ */
+public interface Globals {
+
+    /**
+     * 运营商标识
+     */
+    String OPERATOR_ID = "000000001";
+    /**
+     * 运营商秘钥
+     */
+    String OPERATOR_SECRET = "M0cVKl0q75T4s8NJ";
+    /**
+     * 运营商数据秘钥
+     */
+    String DATA_SECRET = "hs5SBC5TSrAmj6lh";
+    /**
+     * 数据秘钥初始化向量
+     */
+    String DATA_SECRET_IV = "l50WPY1IkFEvKzLu";
+    /**
+     * 签名秘钥
+     */
+    String SIGN_KEY = "ALI7MqP3xhheoMBP";
+    /**
+     * 请求地址前缀
+     */
+    String URL_PREFIX = "http://172.20.19.1:8181/ems-share-api";
+
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/controller/web/TaskController.java

@@ -0,0 +1,22 @@
+package com.usky.demo.controller.web;
+
+import com.usky.demo.service.job.QueryEnergyUnitUsed;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@EnableScheduling
+@Component
+public class TaskController {
+    @Autowired
+    private QueryEnergyUnitUsed queryEnergyUnitUsed;
+
+    @Scheduled(cron = "0 10 */1 * * ?") //每小时的第10分钟执行一次
+    public void task(){
+        System.out.println(Thread.currentThread().getName() + "定时任务执行中");
+        queryEnergyUnitUsed.QueryEnergyElectricUsed();
+        queryEnergyUnitUsed.QueryEnergyWaterUsed();
+    }
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/service/config/mqtt/MqttBaseConfig.java

@@ -0,0 +1,54 @@
+package com.usky.demo.service.config.mqtt;
+
+import lombok.Data;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.integration.mqtt.core.DefaultMqttPahoClientFactory;
+import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@Component
+public class MqttBaseConfig {
+
+	@Value("${mqtt.username}")
+	private String username;
+
+	@Value("${mqtt.password}")
+	private String password;
+
+	@Value("${mqtt.url}")
+	private String hostUrl;
+
+	@Value("${mqtt.keep-alive-interval}")
+	//心跳间隔
+	private int keepAliveInterval;
+	@Value("${mqtt.completionTimeout}")
+	//心跳间隔
+	private int completionTimeout;
+	/**
+	 * 连接工厂配置
+	 */
+	private static final String CLIENT_FACTORY = "mqttClientFactory";
+
+	@Bean(name = CLIENT_FACTORY)
+	public MqttPahoClientFactory mqttClientFactory() {
+		List<String> urlList = new ArrayList<>();
+		urlList.add(this.getHostUrl());
+		String[] serverURIs = new String[urlList.size()];
+		urlList.toArray(serverURIs);
+		DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
+		MqttConnectOptions options = new MqttConnectOptions();
+		options.setServerURIs(serverURIs);
+		options.setUserName(this.getUsername());
+		options.setPassword(this.getPassword().toCharArray());
+		factory.setConnectionOptions(options);
+		return factory;
+	}
+
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/service/config/mqtt/MqttOutConfig.java

@@ -0,0 +1,84 @@
+package com.usky.demo.service.config.mqtt;
+
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.integration.annotation.MessagingGateway;
+import org.springframework.integration.annotation.ServiceActivator;
+import org.springframework.integration.channel.DirectChannel;
+import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;
+import org.springframework.integration.mqtt.support.MqttHeaders;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.MessageHandler;
+import org.springframework.messaging.handler.annotation.Header;
+
+@ConditionalOnProperty(prefix = "mqtt", value = {"enabled"}, havingValue = "true")
+@Configuration
+public class MqttOutConfig {
+
+    @Autowired
+    public MqttBaseConfig mqttBaseConfig;
+
+    public static final String CHANNEL_NAME_OUT = "mqttOutboundChannel";
+
+    public static final String MESSAGE_NAME = "messageOut";
+
+    public static final String DEFAULT_TOPIC = "testTopic";
+
+    /**
+     * 连接通道
+     *
+     * @return
+     */
+    @Bean(name = CHANNEL_NAME_OUT)
+    public MessageChannel mqttOutboundChannel() {
+        return new DirectChannel();
+    }
+
+    /**
+     * 发送消息和消费消息Channel可以使用相同MqttPahoClientFactory
+     *
+     * @return
+     */
+    @Bean(name = MESSAGE_NAME)
+    @ServiceActivator(inputChannel = CHANNEL_NAME_OUT)
+    public MessageHandler outbound() {
+        // 在这里进行mqttOutboundChannel的相关设置
+        String clientId = "h-backend-mqtt-out-" + System.currentTimeMillis();
+        MqttPahoMessageHandler messageHandler =
+                new MqttPahoMessageHandler(clientId, mqttBaseConfig.mqttClientFactory());
+        //如果设置成true，发送消息时将不会阻塞。
+        messageHandler.setAsync(true);
+        messageHandler.setDefaultTopic(DEFAULT_TOPIC);
+        return messageHandler;
+    }
+
+    @MessagingGateway(defaultRequestChannel = CHANNEL_NAME_OUT)
+    public interface MqttGateway {
+        /**
+         * 发送消息
+         *
+         * @param payload
+         */
+        void sendToMqtt(String payload);
+
+        /**
+         * 指定top发送消息
+         *
+         * @param topic
+         * @param payload
+         */
+        void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, String payload);
+
+        /**
+         * 指定队列和qos
+         *
+         * @param topic
+         * @param qos
+         * @param payload
+         */
+        void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, @Header(MqttHeaders.QOS) int qos, String payload);
+    }
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/service/job/QueryEnergyUnitUsed.java

@@ -0,0 +1,219 @@
+package com.usky.demo.service.job;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.usky.demo.Globals;
+import com.usky.demo.service.config.mqtt.MqttOutConfig;
+import com.usky.demo.service.vo.MqttDataInfoVO;
+import com.usky.demo.util.*;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+@Service
+@Configuration
+public class QueryEnergyUnitUsed {
+    @Resource
+    private MqttOutConfig.MqttGateway mqttGateway;
+
+    static String token = "c19ac221e0504552b6c2ebed4b2b069b";
+
+    /* 除获取token外的所有请求都需要带有token数据，demo中简单起见未做token的保存处理，实际使用中请自行实现 */
+    public static void getToken() {
+        HashMap<String, String> map = new HashMap<>();
+        map.put("operatorSecret", Globals.OPERATOR_SECRET);
+        try {
+            JSONObject jsonObject = queryData("queryToken", map, null);
+            String data = jsonObject.getString("data");
+            JSONObject dataObject = JSONObject.parseObject(data);
+            token = dataObject.getString("accessToken");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    //将字符串转换为时间戳
+    public static long getStringToDate(String time){
+        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        Date date = new Date();
+        try {
+            date = sf.parse(time);
+        }catch (ParseException e){
+            e.printStackTrace();
+        }
+        return date.getTime();
+    }
+
+    // 查询用能电表统计数据信息
+    public void QueryEnergyElectricUsed() {
+        getToken();
+
+        String ownerId = "";
+
+        try{
+            JSONObject jsonObject = queryData("queryEnergyUnit", new HashMap<>(), token);
+            String data = jsonObject.getString("data");
+            JSONObject dataObject = JSONObject.parseObject(data);
+            ownerId = dataObject.getString("ownerId");
+
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+
+        Calendar calendar = Calendar.getInstance();
+        calendar.add(Calendar.HOUR,-1);
+        String time = new SimpleDateFormat("yyyyMMddHH").format(calendar.getTime());
+
+        HashMap<String, String> map = new HashMap<>();
+        map.put("energyUnitId", ownerId);//用能单位编码
+        map.put("energyUnitType","12");//用能单位类型(11：企业，12：单位)
+        map.put("energyType","1");//能源类型(1：电，2：水)
+        map.put("circleType","1");//统计周期(1：小时，2：日，3：月)
+        map.put("dataTime",time);//查询时间(格式 yyyyMMddHH/yyyyMMdd/yyyyMM)
+        try {
+            JSONObject electricObject = queryData("queryEnergyUnitUsed", map, token);
+            String electricData = electricObject.getString("data");
+            JSONObject dataObj = JSONObject.parseObject(electricData);
+            String dataTime = dataObj.getString("dataTime");
+            String energyValue = dataObj.getString("used");
+
+            MqttDataInfoVO mqttDataInfoVO = new MqttDataInfoVO();
+            Map<String,Object> map1 = new HashMap<>();
+            map1.put("energy_used",energyValue);
+            mqttDataInfoVO.setMetrics(map1);
+            mqttDataInfoVO.setDevice_id("ysdb0001");
+            mqttDataInfoVO.setProduct_id("512_YSNH");
+            mqttDataInfoVO.setTimestamp(getStringToDate(dataTime));
+            mqttDataInfoVO.setDevice_type("512");
+
+            if(mqttDataInfoVO != null){
+                mqttGateway.sendToMqtt("data-collector", JSONArray.toJSON(mqttDataInfoVO).toString());
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    // 查询用能电表统计数据信息
+    public void QueryEnergyWaterUsed() {
+        getToken();
+
+        String ownerId = "";
+
+        try{
+            JSONObject jsonObject = queryData("queryEnergyUnit", new HashMap<>(), token);
+            String data = jsonObject.getString("data");
+            JSONObject dataObject = JSONObject.parseObject(data);
+            ownerId = dataObject.getString("ownerId");
+
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+
+        Calendar calendar = Calendar.getInstance();
+        calendar.add(Calendar.HOUR,-1);
+        String time = new SimpleDateFormat("yyyyMMddHH").format(calendar.getTime());
+
+        HashMap<String, String> map = new HashMap<>();
+        map.put("energyUnitId", ownerId);//用能单位编码
+        map.put("energyUnitType","12");//用能单位类型(11：企业，12：单位)
+        map.put("energyType","2");//能源类型(1：电，2：水)
+        map.put("circleType","1");//统计周期(1：小时，2：日，3：月)
+        map.put("dataTime",time);//查询时间(格式 yyyyMMddHH/yyyyMMdd/yyyyMM)
+        try {
+            JSONObject electricObject = queryData("queryEnergyUnitUsed", map, token);
+            String electricData = electricObject.getString("data");
+            JSONObject dataObj = JSONObject.parseObject(electricData);
+            String dataTime = dataObj.getString("dataTime");
+            String energyValue = dataObj.getString("used");
+
+            MqttDataInfoVO mqttDataInfoVO = new MqttDataInfoVO();
+            Map<String,Object> map1 = new HashMap<>();
+            map1.put("energy_used",energyValue);
+            mqttDataInfoVO.setMetrics(map1);
+            mqttDataInfoVO.setDevice_id("yssb0001");
+            mqttDataInfoVO.setProduct_id("512_YSNH");
+            mqttDataInfoVO.setTimestamp(getStringToDate(dataTime));
+            mqttDataInfoVO.setDevice_type("512");
+
+            if(mqttDataInfoVO != null){
+                mqttGateway.sendToMqtt("data-collector", JSONArray.toJSON(mqttDataInfoVO).toString());
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 请求数据
+     *
+     * @param path    请求接口
+     * @param dataMap 所需的数据Map
+     */
+    public static JSONObject queryData(String path, Map<String, String> dataMap, String token) throws Exception {
+        // 加密data部分
+        String encode = CodeUtil.dataEncode(JSON.toJSONString(dataMap), Globals.DATA_SECRET, Globals.DATA_SECRET_IV);
+        /*组装必要参数 start */
+        String seq = "0001";
+        String timeStamp = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
+        Map<String, String> map = new HashMap<>();
+        map.put("operatorId", Globals.OPERATOR_ID);
+        map.put("data", encode);
+        map.put("timeStamp", timeStamp);
+        map.put("seq", seq);
+        /*组装必要参数 end */
+        if (encode == null) return null;
+
+        /*生成签名 start*/
+        // 为防止+在收发过程中被变成空格，将加密后的密文中的所有空格替换一下
+        // 需要签名的参数: operatorId + 加密后的data + 时间戳 + 自增序列
+        String signSrc = Globals.OPERATOR_ID + encode.replaceAll(" ", "+") + timeStamp + seq;
+        String sig = CodeUtil.getSign(signSrc, Globals.SIGN_KEY);
+        //将签名放入参数Map
+        map.put("sig", sig);
+        /*生成签名 start*/
+        /*执行请求，使用可以附加token的doPost方*/
+        HttpClientHelper instance = HttpClientHelper.getInstance();
+        //token也可以放进参数列表
+        String result = instance.doPost(Globals.URL_PREFIX + (path.startsWith("/") ? path : ("/" + path)), map, token);
+        if (StringUtil.isEmpty(result)) return null;
+
+        /*解析数据 start*/
+        JSONObject jsonObject = JSON.parseObject(result);
+        // 失败
+        if (!"0".equals(jsonObject.getString("ret"))) {
+            printJsonMessage("send Error:", jsonObject);
+            return null;
+        }
+        // 验签，注意生成签名的参数顺序应和发送时一样
+        // 为防止'+'在收发过程中被变成' '，将加密后的密文中的所有空格替换一下
+        String resultSigStr = jsonObject.getString("operatorId") + jsonObject.getString("data").replaceAll(" ", "+")
+                + jsonObject.getString("msg") + jsonObject.getString("ret");
+        String resultSig = CodeUtil.getSign(resultSigStr, Globals.SIGN_KEY);
+        if (StringUtil.isNotEmpty(jsonObject.getString("sig")) && jsonObject.getString("sig").equals(resultSig)) {
+            // 解密数据，需要数据秘钥和秘钥初始化向量
+            String data = CodeUtil.dataDecode(jsonObject.getString("data"), Globals.DATA_SECRET, Globals.DATA_SECRET_IV);
+            jsonObject.put("data", data);
+        }
+        /*解析数据 end*/
+        // 打印 or 其他操作
+        printJsonMessage("Send Message:", map);
+        printJsonMessage("Receive Message:", result);
+        printJsonMessage("Decode Message:", jsonObject);
+        return jsonObject;
+    }
+
+    public static void printJsonMessage(String prefix, Object obj) {
+        System.out.println(prefix + JsonUtil.JsonFormart(JSON.toJSONString(obj)));
+    }
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/service/vo/MqttDataInfoVO.java

@@ -0,0 +1,36 @@
+package com.usky.demo.service.vo;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.util.Map;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class MqttDataInfoVO implements Serializable {
+    /**
+     * 属性值集合
+     */
+    private Map<String,Object> metrics;
+
+    /**
+     * 设备编号
+     */
+    private String device_id;
+
+    /**
+     * 产品Id
+     */
+    private String product_id;
+
+    /**
+     * 数据上报时间
+     */
+    private long timestamp;
+
+    /**
+     * 设备类型
+     */
+    private String device_type;
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/util/Base64.java

@@ -0,0 +1,133 @@
+package com.usky.demo.util;
+
+import java.io.ByteArrayOutputStream;
+
+public class Base64 {
+
+    // map 6-bit int to char
+    private static final char[] chars64 = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a',
+                                            'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1',
+                                            '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
+
+    // map char to 6-bit int
+    private static final int[]  ints64  = new int[128];
+    static {
+        for (int i = 0; i < 64; i++) {
+            ints64[chars64[i]] = i;
+        }
+    }
+
+    /**
+     * 转换byte数组成Base64 string
+     * 
+     * @param unencoded
+     * @return
+     */
+    public static final String encode(byte[] unencoded) {
+        // Take 24-bits from three octets, translate into four encoded chars.
+        // If necessary, pad with 0 bits on the right at the end
+        // Use = signs as padding at the end to ensure encodedLength % 4 == 0
+        if (unencoded == null || unencoded.length == 0) return null;
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream((int) (unencoded.length * 1.37));
+        int byteCount = 0;
+        int carryOver = 0;
+
+        for (int i = 0; i < unencoded.length; i++) {
+            int bc = (byteCount % 3);
+            byte b = unencoded[i];
+            int lookup = 0;
+
+            // First byte use first six bits, save last two bits
+            if (bc == 0) {
+                lookup = (b >> 2) & 0x3F;
+                carryOver = b & 0x03; // last two bits
+                out.write(chars64[lookup]);
+            } else if (bc == 1) {
+                // Second byte use previous two bits and first four new bits,
+                // save last four bits
+                lookup = ((carryOver << 4) | ((b >> 4) & 0x0F));
+                carryOver = b & 0x0F; // last four bits
+                out.write(chars64[lookup]);
+            } else if (bc == 2) {
+                // Third byte use previous four bits and first two new bits,
+                // then use last six new bits
+                lookup = ((carryOver << 2) | ((b >> 6) & 0x03));
+                out.write(chars64[lookup]);
+
+                lookup = b & 0x3F; // last six bits
+                out.write(chars64[lookup]);
+                carryOver = 0;
+            }
+            byteCount++;
+        }
+
+        if (byteCount % 3 == 1) { // one leftover
+            int lookup = (carryOver << 4) & 0xF0;
+            out.write(chars64[lookup]);
+            out.write('=');
+            out.write('=');
+        } else if (byteCount % 3 == 2) { // two leftovers
+            int lookup = (carryOver << 2) & 0x3C;
+            out.write(chars64[lookup]);
+            out.write('=');
+        }
+        return out.toString();
+    }
+
+    /**
+     * Decode Base64 string back to byte array
+     * 
+     * @param encoded
+     * @return
+     */
+    public static final byte[] decode(String encoded) {
+        if (encoded == null || encoded.length() == 0) return null;
+
+        byte[] bytes = encoded.getBytes();
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream((int) (bytes.length * 0.67));
+        int byteCount = 0;
+        int carryOver = 0;
+
+        DECODE_LOOP: for (int i = 0; i < bytes.length; i++) {
+            int ch = bytes[i];
+
+            // Read the next non-whitespace character
+            // if (Character.isWhitespace((char)ch))
+            // continue;
+
+            // The '=' sign is just padding; geffective end of stream
+            if (ch == '=') break DECODE_LOOP;
+
+            // Convert from raw form to 6-bit form
+            int newbits = ints64[ch];
+
+            int bc = (byteCount % 4);
+            if (bc == 0) {
+                // First char save all six bits, go for another
+                carryOver = newbits & 0x3F;
+            } else if (bc == 1) {
+                // second char use 6 previous bits and first 2 new bits
+                int data = ((carryOver << 2) + ((newbits >> 4) & 0x03));
+                out.write(data);
+                carryOver = newbits & 0x0F; // save 4 bits
+            } else if (bc == 2) {
+                // Third char use previous four bits and first four new bits,
+                // save last two bits
+                int data = ((carryOver << 4) + ((newbits >> 2) & 0x0F));
+                out.write(data);
+                carryOver = newbits & 0x03; // save 2 bits
+            } else if (bc == 3) {
+                // Fourth char use previous two bits and all six new bits
+                int data = ((carryOver << 6) + (newbits & 0x3F));
+                out.write(data);
+                carryOver = 0;
+            }
+            byteCount++;
+        }
+
+        return out.toByteArray();
+    }
+
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/util/CodeUtil.java

@@ -0,0 +1,198 @@
+package com.usky.demo.util;
+
+import javax.crypto.Cipher;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+public class CodeUtil {
+
+
+    /**
+     * 解密
+     * @param src       源数据
+     * @param secret    秘钥
+     * @param iv        初始化向量
+     * @return          String
+     */
+    public static String dataDecode(String src, String secret, String iv){
+        try {
+            // 判断Key是否正确
+            if (secret == null) {
+                System.out.print("Key为空null");
+                return null;
+            }
+            // 判断Key是否为16位
+            if (secret.length() != 16) {
+                System.out.print("Key长度不是16位");
+                return null;
+            }
+            byte[] raw = secret.getBytes(StandardCharsets.US_ASCII);
+            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
+            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+            IvParameterSpec ips  = new IvParameterSpec(iv.getBytes());
+            cipher.init(Cipher.DECRYPT_MODE, skeySpec, ips);
+            // byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);// 先用base64解密
+            byte[] encrypted1 = Base64.decode(src);
+            try {
+                byte[] original = cipher.doFinal(encrypted1);
+                return new String(original, StandardCharsets.UTF_8);
+            } catch (Exception e) {
+                System.out.println(e.toString());
+                return null;
+            }
+        } catch (Exception ex) {
+            System.out.println(ex.toString());
+            return null;
+        }
+    }
+
+    /**
+     *  加密
+     * @param src       源数据
+     * @param secret    秘钥
+     * @param iv        初始化向量
+     * @return          String
+     */
+    public static String dataEncode(String src, String secret, String iv) throws Exception {
+        if (secret == null) {
+            System.out.print("Key为空null");
+            return null;
+        }
+        // 判断Key是否为16位
+        if (secret.length() != 16) {
+            System.out.print("Key长度不是16位");
+            return null;
+        }
+        byte[] raw = secret.getBytes(StandardCharsets.UTF_8);
+        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
+        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");// "算法/模式/补码方式"
+        IvParameterSpec ips = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));// 使用CBC模式，需要一个向量iv，可增加加密算法的强度
+        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, ips);
+        byte[] encrypted = cipher.doFinal(src.getBytes(StandardCharsets.UTF_8));
+        // return new BASE64Encoder().encode(encrypted);// 此处使用BASE64做转码功能，同时能起到2次加密的作用。
+        return Base64.encode(encrypted);
+    }
+
+    /**
+     * 获取签名
+     * @param src       源数据
+     * @param signKey   签名秘钥
+     * @return          String
+     */
+    public static String getSign(String src,String signKey){
+        String result = "";
+        try {
+            byte[] keyByte = signKey.getBytes(StandardCharsets.UTF_8);
+            byte[] dataByte = src.getBytes(StandardCharsets.UTF_8);
+            byte[] hmacMd5Byte = getHmacMd5Bytes(keyByte, dataByte);
+            StringBuilder md5Str = new StringBuilder();
+            for (byte b : hmacMd5Byte) {
+                if (Integer.toHexString(0xFF & b).length() == 1) md5Str.append("0").append(Integer.toHexString(0xFF & b));
+                else md5Str.append(Integer.toHexString(0xFF & b));
+            }
+            result = md5Str.toString().toUpperCase();
+
+        } catch (Exception ignored) {
+        }
+        return result;
+
+    }
+
+
+    /**
+     * 将待加密数据data，通过密钥key，使用hmac-md5算法进行加密，然后返回加密结果。 参照rfc2104 HMAC算法介绍实现。
+     *
+     * @author sc
+     * @param key 密钥
+     * @param data 待加密数据
+     * @return 加密结果
+     */
+    private static byte[] getHmacMd5Bytes(byte[] key, byte[] data) throws NoSuchAlgorithmException {
+        /*
+         * HmacMd5 calculation formula: H(K XOR opad, H(K XOR ipad, text)) HmacMd5 计算公式：H(K XOR opad, H(K XOR ipad,
+         * text)) H代表hash算法，本类中使用MD5算法，K代表密钥，text代表要加密的数据 ipad为0x36，opad为0x5C。
+         */
+        int length = 64;
+        byte[] ipad = new byte[length];
+        byte[] opad = new byte[length];
+        for (int i = 0; i < 64; i++) {
+            ipad[i] = 0x36;
+            opad[i] = 0x5C;
+        }
+        byte[] actualKey = key; // Actual key.
+        byte[] keyArr = new byte[length]; // Key bytes of 64 bytes length
+        /*
+         * If key's length is longer than 64,then use hash to digest it and use the result as actual key.
+         * 如果密钥长度，大于64字节，就使用哈希算法，计算其摘要，作为真正的密钥。
+         */
+        if (key.length > length) {
+            actualKey = md5(key);
+        }
+        System.arraycopy(actualKey, 0, keyArr, 0, actualKey.length);
+        /*
+         * append zeros to K 如果密钥长度不足64字节，就使用0x00补齐到64字节。
+         */
+        if (actualKey.length < length) {
+            for (int i = actualKey.length; i < keyArr.length; i++)
+                keyArr[i] = 0x00;
+        }
+
+        /*
+         * calc K XOR ipad 使用密钥和ipad进行异或运算。
+         */
+        byte[] kIpadXorResult = new byte[length];
+        for (int i = 0; i < length; i++) {
+            kIpadXorResult[i] = (byte) (keyArr[i] ^ ipad[i]);
+        }
+
+        /*
+         * append "text" to the end of "K XOR ipad" 将待加密数据追加到K XOR ipad计算结果后面。
+         */
+        byte[] firstAppendResult = new byte[kIpadXorResult.length + data.length];
+        System.arraycopy(kIpadXorResult, 0, firstAppendResult, 0, kIpadXorResult.length);
+        System.arraycopy(data, 0, firstAppendResult, keyArr.length, data.length);
+
+        /*
+         * calc H(K XOR ipad, text) 使用哈希算法计算上面结果的摘要。
+         */
+        byte[] firstHashResult = md5(firstAppendResult);
+
+        /*
+         * calc K XOR opad 使用密钥和opad进行异或运算。
+         */
+        byte[] kOpadXorResult = new byte[length];
+        for (int i = 0; i < length; i++) {
+            kOpadXorResult[i] = (byte) (keyArr[i] ^ opad[i]);
+        }
+
+        /*
+         * append "H(K XOR ipad, text)" to the end of "K XOR opad" 将H(K XOR ipad, text)结果追加到K XOR opad结果后面
+         */
+        byte[] secondAppendResult = new byte[kOpadXorResult.length + firstHashResult.length];
+        System.arraycopy(kOpadXorResult, 0, secondAppendResult, 0, kOpadXorResult.length);
+        System.arraycopy(firstHashResult, 0, secondAppendResult, keyArr.length, firstHashResult.length);
+
+        /*
+         * H(K XOR opad, H(K XOR ipad, text)) 对上面的数据进行哈希运算。
+         */
+        return md5(secondAppendResult);
+    }
+
+
+    /**
+     * 计算参数的md5信息
+     *
+     * @param str 待处理的字节数组
+     * @return md5摘要信息
+     */
+    private static byte[] md5(byte[] str) throws NoSuchAlgorithmException {
+        MessageDigest md = MessageDigest.getInstance("MD5");
+        md.update(str);
+        return md.digest();
+    }
+
+
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/util/HttpClientHelper.java

@@ -0,0 +1,348 @@
+package com.usky.demo.util;
+
+import org.apache.http.*;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.config.Registry;
+import org.apache.http.config.RegistryBuilder;
+import org.apache.http.config.SocketConfig;
+import org.apache.http.conn.socket.ConnectionSocketFactory;
+import org.apache.http.conn.socket.PlainConnectionSocketFactory;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.DefaultProxyRoutePlanner;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.http.message.BasicHeader;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.protocol.HTTP;
+import org.apache.http.ssl.SSLContexts;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.net.ssl.SSLContext;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+public class HttpClientHelper {
+
+
+    private static final Logger logger = LoggerFactory.getLogger(HttpClientHelper.class);
+    private static PoolingHttpClientConnectionManager poolConnManager = null;
+    private int maxTotalPool = 200;
+    private int maxConPerRoute = 20;
+    private int socketTimeout = 100000;
+    private int connectionRequestTimeout = 90000;
+    private int connectTimeout = 90000;
+
+    // 代理信息
+    public static String proxy_ip;
+    public static int proxy_port;
+
+    private static HttpClientHelper httpClientHelper = null;
+
+    private HttpClientHelper() {
+        init();
+    }
+
+    private static synchronized void syncInit() {
+        if (httpClientHelper == null) {
+            httpClientHelper = new HttpClientHelper();
+        }
+    }
+
+    public static HttpClientHelper getInstance(String proxyIp, Integer proxyPort) {
+        proxy_port = proxyPort;
+        proxy_ip = proxyIp;
+        if (httpClientHelper == null) {
+            syncInit();
+        }
+        return httpClientHelper;
+    }
+
+    public static HttpClientHelper getInstance() {
+        if (httpClientHelper == null) {
+            syncInit();
+        }
+        return httpClientHelper;
+    }
+
+    public PoolingHttpClientConnectionManager getConnManager() {
+        PoolingHttpClientConnectionManager cm = null;
+        try {
+            SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).build();
+            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, NoopHostnameVerifier.INSTANCE);
+            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create().register("http",
+                    PlainConnectionSocketFactory.getSocketFactory()).register("https",
+                    sslsf).build();
+            cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
+            // 将最大连接数增加到200
+            cm.setMaxTotal(maxTotalPool);
+            // 将每个路由基础的连接增加到20
+            cm.setDefaultMaxPerRoute(maxConPerRoute);
+        } catch (Exception e) {
+            logger.error("InterfacePhpUtilManager init Exception" + e.toString());
+        }
+        return cm;
+    }
+
+    public void init() {
+        try {
+            SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).build();
+            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, NoopHostnameVerifier.INSTANCE);
+            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create().register("http",
+                    PlainConnectionSocketFactory.getSocketFactory()).register("https",
+                    sslsf).build();
+            poolConnManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
+            // Increase max total connection to 200
+            poolConnManager.setMaxTotal(maxTotalPool);
+            // Increase default max connection per route to 20
+            poolConnManager.setDefaultMaxPerRoute(maxConPerRoute);
+            SocketConfig socketConfig = SocketConfig.custom().setSoTimeout(socketTimeout).build();
+            poolConnManager.setDefaultSocketConfig(socketConfig);
+        } catch (Exception e) {
+            logger.error("InterfacePhpUtilManager init Exception" + e.toString());
+        }
+    }
+
+    public CloseableHttpClient getConnection() {
+        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout).setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();
+        HttpClientBuilder httpClientBuilder = HttpClients.custom();
+        httpClientBuilder.setConnectionManager(poolConnManager).setDefaultRequestConfig(requestConfig);// set proxy
+        if (!StringUtil.isEmpty(proxy_ip) && proxy_port > 0) {
+            HttpHost proxy = new HttpHost(proxy_ip, proxy_port);
+            DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);
+            httpClientBuilder.setRoutePlanner(routePlanner);
+        }
+
+        CloseableHttpClient httpClient = httpClientBuilder.build();
+        if (poolConnManager != null && poolConnManager.getTotalStats() != null) {
+            logger.info("now client pool " + poolConnManager.getTotalStats().toString());
+        }
+        return httpClient;
+    }
+
+    /**
+     * 发送 GET 请求（HTTP），不带输入数据
+     */
+    public String doGet(String url) {
+        return doGet(url, new HashMap<String,String>());
+    }
+
+    /**
+     * 发送 GET 请求（HTTP），K-V形式
+     */
+    public String doGet(String url, Map<String, String> params) {
+        String apiUrl = url;
+        StringBuffer param = new StringBuffer();
+        int i = 0;
+        for (String key : params.keySet()) {
+            if (i == 0) {
+                param.append("?");
+            } else {
+                param.append("&");
+            }
+            param.append(key).append("=").append(params.get(key));
+            i++;
+        }
+        apiUrl += param;
+        logger.info(apiUrl);
+        String result = null;
+        CloseableHttpClient httpClient = getConnection();
+        CloseableHttpResponse response = null;
+        HttpGet httpPost = null;
+        try {
+            httpPost = new HttpGet(apiUrl);
+            response = httpClient.execute(httpPost);
+            int status = response.getStatusLine().getStatusCode();
+            logger.info("http request url : " + url + " status : " + status);
+
+            if (status >= 200 && status < 300) {
+                HttpEntity entity = response.getEntity();
+                if (entity != null) {
+                    result = EntityUtils.toString(response.getEntity(), "UTF-8");
+                    logger.info("Request result : " + result);
+                }
+            }
+            EntityUtils.consume(response.getEntity());
+            response.close();
+            return result;
+
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+        } finally {
+            httpPost.releaseConnection();
+            if (response != null) {
+                try {
+                    EntityUtils.consume(response.getEntity());
+                    response.close();
+                } catch (IOException e) {
+                    logger.error(e.getMessage(), e);
+                }
+            }
+        }
+        return result;
+    }
+
+    public String doPost(String url) {
+        return doPost(url, new HashMap<String, String>());
+    }
+
+    /**
+     * 发送 POST json
+     *
+     * @param url 接口URL
+     */
+    public String doPostJson(String url, String jsonstr) {
+        String result = null;
+        HttpPost httpPost = new HttpPost(url);
+        CloseableHttpClient httpClient = getConnection();
+        CloseableHttpResponse response = null;
+        try {
+
+            StringEntity se = new StringEntity(jsonstr, Charset.forName("UTF-8"));
+            se.setContentType("text/json");
+            se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
+            httpPost.setEntity(se);
+            response = httpClient.execute(httpPost);
+            int status = response.getStatusLine().getStatusCode();
+            logger.info("http request url : " + url + " status : " + status);
+            if (status >= 200 && status < 300) {
+                HttpEntity entity = response.getEntity();
+                if (entity != null) {
+                    result = EntityUtils.toString(response.getEntity(), "UTF-8");
+                    logger.info("Request result : " + result);
+                }
+            }
+            EntityUtils.consume(response.getEntity());
+            response.close();
+            return result;
+
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+        } finally {
+            httpPost.releaseConnection();
+            if (response != null) {
+                try {
+                    EntityUtils.consume(response.getEntity());
+                    response.close();
+                } catch (IOException e) {
+                    logger.error(e.getMessage(), e);
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 发送 POST 请求（HTTP），K-V形式
+     *
+     * @param url    接口URL
+     * @param params 参数map
+     * @return
+     */
+    public String doPost(String url, Map<String, String> params) {
+        String result = null;
+        HttpPost httpPost = new HttpPost(url);
+        CloseableHttpClient httpClient = getConnection();
+        CloseableHttpResponse response = null;
+        try {
+            List<NameValuePair> pairList = new ArrayList<>(params.size());
+            for (Map.Entry<String, String> entry : params.entrySet()) {
+                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());
+                pairList.add(pair);
+            }
+            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
+            response = httpClient.execute(httpPost);
+            int status = response.getStatusLine().getStatusCode();
+            logger.info("http request url : " + url + " status : " + status);
+            if (status >= 200 && status < 300) {
+                HttpEntity entity = response.getEntity();
+                if (entity != null) {
+                    result = EntityUtils.toString(response.getEntity(), "UTF-8");
+                    logger.info("Request result : " + result);
+                }
+            }
+            EntityUtils.consume(response.getEntity());
+            response.close();
+            return result;
+
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+        } finally {
+            httpPost.releaseConnection();
+            if (response != null) {
+                try {
+                    EntityUtils.consume(response.getEntity());
+                    response.close();
+                } catch (IOException e) {
+                    logger.error(e.getMessage(), e);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 发送 POST 请求（HTTP），K-V形式
+     *
+     * @param url    接口URL
+     * @param params 参数map
+     * @return
+     */
+    public String doPost(String url, Map<String, String> params, String token) {
+        String result = null;
+        HttpPost httpPost = new HttpPost(url);
+        CloseableHttpClient httpClient = getConnection();
+        CloseableHttpResponse response = null;
+        try {
+            List<NameValuePair> pairList = new ArrayList<>(params.size());
+            for (Map.Entry<String, String> entry : params.entrySet()) {
+                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());
+                pairList.add(pair);
+            }
+            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
+            httpPost.addHeader("token", token);
+            response = httpClient.execute(httpPost);
+            int status = response.getStatusLine().getStatusCode();
+            logger.info("http request url : " + url + " status : " + status);
+            if (status >= 200 && status < 300) {
+                HttpEntity entity = response.getEntity();
+                if (entity != null) {
+                    result = EntityUtils.toString(response.getEntity(), "UTF-8");
+                    logger.info("Request result : " + result);
+                }
+            }
+            EntityUtils.consume(response.getEntity());
+            response.close();
+            return result;
+
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+        } finally {
+            httpPost.releaseConnection();
+            if (response != null) {
+                try {
+                    EntityUtils.consume(response.getEntity());
+                    response.close();
+                } catch (IOException e) {
+                    logger.error(e.getMessage(), e);
+                }
+            }
+        }
+        return result;
+    }
+
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/util/JsonUtil.java

@@ -0,0 +1,56 @@
+package com.usky.demo.util;
+
+
+import org.apache.commons.lang.StringEscapeUtils;
+
+public class JsonUtil {
+
+    private static String getLevelStr(int level) {
+        StringBuilder levelStr = new StringBuilder();
+        for (int levelI = 0; levelI < level; levelI++) {
+            levelStr.append("\t");
+        }
+        return levelStr.toString();
+    }
+
+    public static String JsonFormart(String s) {
+        int level = 0;
+        //存放格式化的json字符串
+        StringBuilder jsonForMatStr = new StringBuilder();
+        for(int index=0;index<s.length();index++)//将字符串中的字符逐个按行输出
+        {
+            //获取s中的每个字符
+            char c = s.charAt(index);
+//          System.out.println(s.charAt(index));
+
+            //level大于0并且jsonForMatStr中的最后一个字符为\n,jsonForMatStr加入\t
+            if (level > 0 && '\n' == jsonForMatStr.charAt(jsonForMatStr.length() - 1)) {
+                jsonForMatStr.append(getLevelStr(level));
+//                System.out.println("123"+jsonForMatStr);
+            }
+            //遇到"{"和"["要增加空格和换行，遇到"}"和"]"要减少空格，以对应，遇到","要换行
+            switch (c) {
+                case '{':
+                case '[':
+                    jsonForMatStr.append(c).append("\n");
+                    level++;
+                    break;
+                case ',':
+                    jsonForMatStr.append(c).append("\n");
+                    break;
+                case '}':
+                case ']':
+                    jsonForMatStr.append("\n");
+                    level--;
+                    jsonForMatStr.append(getLevelStr(level));
+                    jsonForMatStr.append(c);
+                    break;
+                default:
+                    jsonForMatStr.append(c);
+                    break;
+            }
+        }
+        return StringEscapeUtils.unescapeJava(jsonForMatStr.toString());
+    }
+}
+

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/java/com/usky/demo/util/StringUtil.java

@@ -0,0 +1,845 @@
+package com.usky.demo.util;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.math.NumberUtils;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.text.BreakIterator;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class StringUtil {
+
+    /** 空字符串。 */
+    public static final String   EMPTY_STRING        = "";
+
+    private static final char    QUOTE_ENCODE[]      = """.toCharArray();
+    private static final char    AMP_ENCODE[]        = "&".toCharArray();
+    private static final char    LT_ENCODE[]         = "<".toCharArray();
+    private static final char    GT_ENCODE[]         = ">".toCharArray();
+    private static final int     DUMP_HEX_CHAR_COUNT = 75;
+    private static MessageDigest digest              = null;
+    // private static final int fillchar = 61;
+    private static Random        randGen             = new Random();
+    private static char          numbersAndLetters[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
+    private static final char    zeroArray[]         = "0000000000000000".toCharArray();
+    private static final char[]  base64Chars         = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
+    private static final char[]  upcaseHexChar       = "0123456789ABCDEF".toCharArray();
+    private static final char[]  lowerHexChar        = "0123456789abcdef".toCharArray();
+
+    private static int[]         hexCharCodes        = new int[256];
+
+    private static int[]         base64Codes         = new int[256];
+    static {
+        for (int i = 0; i < 256; i++)
+            hexCharCodes[i] = base64Codes[i] = -1;
+        for (int i = 0; i < base64Chars.length; i++)
+            base64Codes[base64Chars[i]] = (byte) i;
+        for (int i = 0; i < upcaseHexChar.length; i++)
+            hexCharCodes[upcaseHexChar[i]] = (byte) i;
+        for (int i = 0; i < lowerHexChar.length; i++)
+            hexCharCodes[lowerHexChar[i]] = (byte) i;
+    }
+
+    /**
+     * 如果字符串是<code>null</code>，则返回指定默认字符串，否则返回字符串本身。
+     * 
+     * <pre>
+     * StringUtil.defaultIfNull(null, &quot;default&quot;)  = &quot;default&quot;
+     * StringUtil.defaultIfNull(&quot;&quot;, &quot;default&quot;)    = &quot;&quot;
+     * StringUtil.defaultIfNull(&quot;  &quot;, &quot;default&quot;)  = &quot;  &quot;
+     * StringUtil.defaultIfNull(&quot;bat&quot;, &quot;default&quot;) = &quot;bat&quot;
+     * </pre>
+     * 
+     * @param str 要转换的字符串
+     * @param defaultStr 默认字符串
+     * @return 字符串本身或指定的默认字符串
+     */
+    public static String defaultIfNull(String str, String defaultStr) {
+        return (str == null) ? defaultStr : str;
+    }
+
+    public static boolean isDigits(String str) {
+        if ((str == null) || (str.length() == 0)) {
+            return false;
+        }
+        for (int i = 0; i < str.length(); i++) {
+            if (!Character.isDigit(str.charAt(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean isDigits(Object obj) {
+        if (obj == null) return false;
+        String str = obj.toString();
+        return isDigits(str);
+    }
+
+    public static final String escapeHTMLTags(String in) {
+        if (in == null) return null;
+        int i = 0;
+        int last = 0;
+        char input[] = in.toCharArray();
+        int len = input.length;
+        StringBuffer out = new StringBuffer((int) ((double) len * 1.3D));
+        for (; i < len; i++) {
+            char ch = input[i];
+            if (ch > '>') continue;
+            if (ch == '<') {
+                if (i > last) out.append(input, last, i - last);
+                last = i + 1;
+                out.append(LT_ENCODE);
+                continue;
+            }
+            if (ch != '>') continue;
+            if (i > last) out.append(input, last, i - last);
+            last = i + 1;
+            out.append(GT_ENCODE);
+        }
+
+        if (last == 0) return in;
+        if (i > last) out.append(input, last, i - last);
+        return out.toString();
+    }
+
+    public static final synchronized String hash(String data) {
+        if (digest == null) try {
+            digest = MessageDigest.getInstance("MD5");
+        } catch (NoSuchAlgorithmException nsae) {
+            System.err.println("Failed to load the MD5 MessageDigest. We will be unable to function normally.");
+            nsae.printStackTrace();
+        }
+        digest.update(data.getBytes());
+        return encodeHex(digest.digest());
+    }
+
+    public static final String encodeHex(byte bytes[]) {
+        char[] buf = new char[bytes.length * 2];
+        for (int i = 0; i < bytes.length; i++) {
+            int code = bytes[i] & 0xff;
+            buf[2 * i] = upcaseHexChar[code >> 4];
+            buf[2 * i + 1] = upcaseHexChar[code & 0xf];
+        }
+        return new String(buf);
+    }
+
+    public static final String dumpHex(byte bytes[]) {
+        int bytepos, bufpos, linecount = (bytes.length + 15) / 16;
+        char[] buf = new char[linecount * DUMP_HEX_CHAR_COUNT];
+        byte[] bs = new byte[16];
+
+        bytepos = 0;
+        for (int i = 0; i < linecount; i++) {
+            int addr = i * 16;
+            bufpos = i * DUMP_HEX_CHAR_COUNT;
+            buf[bufpos++] = upcaseHexChar[(addr >> 12) & 0xf];
+            buf[bufpos++] = upcaseHexChar[(addr >> 8) & 0xf];
+            buf[bufpos++] = upcaseHexChar[(addr >> 4) & 0xf];
+            buf[bufpos++] = upcaseHexChar[(addr) & 0xf];
+            buf[bufpos++] = ' ';
+            buf[bufpos++] = ' ';
+            for (int j = 0; j < 16; j++, bytepos++) {
+                if (bytepos < bytes.length) {
+                    int code = bytes[bytepos] & 0xff;
+                    bs[j] = bytes[bytepos];
+                    buf[bufpos++] = upcaseHexChar[code >> 4];
+                    buf[bufpos++] = upcaseHexChar[code & 0xf];
+                    if (j == 7) buf[bufpos++] = '-';
+                    else buf[bufpos++] = ' ';
+                } else {
+                    buf[bufpos++] = ' ';
+                    buf[bufpos++] = ' ';
+                    buf[bufpos++] = ' ';
+                    bs[j] = ' ';
+                }
+            }
+            buf[bufpos++] = ' ';
+            buf[bufpos++] = ' ';
+            char[] chs = new String(bs).toCharArray();
+            for (int k = 0; k < chs.length; k++) {
+                char ch = chs[k];
+                if ((ch > '\0') && (ch < ' ')) buf[bufpos++] = '.';
+                else buf[bufpos++] = ch;
+
+            }
+            int endLine = (i + 1) * DUMP_HEX_CHAR_COUNT - 2;
+            for (; bufpos < endLine; bufpos++)
+                buf[bufpos] = ' ';
+            buf[bufpos++] = '\r';
+            buf[bufpos++] = '\n';
+        }
+        return new String(buf);
+    }
+
+    public static final byte[] decodeHex(String hex) {
+        char chars[] = hex.toCharArray();
+        byte bytes[] = new byte[chars.length / 2];
+        int byteCount = 0;
+        for (int i = 0; i < chars.length; i += 2) {
+            byte newByte = 0;
+            newByte |= hexCharCodes[chars[i]];
+            newByte <<= 4;
+            newByte |= hexCharCodes[chars[i + 1]];
+            bytes[byteCount] = newByte;
+            byteCount++;
+        }
+
+        return bytes;
+    }
+
+    public static String encodeBase64(String data) {
+        return encodeBase64(data.getBytes());
+    }
+
+    public static String encodeBase64(byte data[]) {
+        int len = data.length;
+        StringBuffer ret = new StringBuffer((len / 3 + 1) * 4);
+        for (int i = 0; i < len; i++) {
+            int c = data[i] >> 2 & 0x3f;
+            ret.append(base64Chars[c]);
+            c = data[i] << 4 & 0x3f;
+            if (++i < len) c |= data[i] >> 4 & 0xf;
+            ret.append(base64Chars[c]);
+            if (i < len) {
+                c = data[i] << 2 & 0x3f;
+                if (++i < len) c |= data[i] >> 6 & 3;
+                ret.append(base64Chars[c]);
+            } else {
+                i++;
+                ret.append('=');
+            }
+            if (i < len) {
+                c = data[i] & 0x3f;
+                ret.append(base64Chars[c]);
+            } else {
+                ret.append('=');
+            }
+        }
+
+        return ret.toString();
+    }
+
+    public static byte[] decodeBase64(String data) {
+        int len = data.length();
+        byte[] result = new byte[((len * 3) / 4)];
+        int pos = 0;
+        for (int i = 0; i < len; i++) {
+
+            int c = base64Codes[data.charAt(i)];
+            i++;
+            int c1 = base64Codes[data.charAt(i)];
+            c = c << 2 | c1 >> 4 & 3;
+            result[pos++] = (byte) c;
+            if (++i < len) {
+                c = data.charAt(i);
+                if (61 == c) break;
+                c = base64Codes[data.charAt(i)];
+                c1 = c1 << 4 & 0xf0 | c >> 2 & 0xf;
+                result[pos++] = (byte) c1;
+            }
+            if (++i >= len) continue;
+            c1 = data.charAt(i);
+            if (61 == c1) break;
+            c1 = base64Codes[data.charAt(i)];
+            c = c << 6 & 0xc0 | c1;
+            result[pos++] = (byte) c;
+        }
+        if (result.length != pos) {
+            byte[] result2 = new byte[pos];
+            System.arraycopy(result, 0, result2, 0, pos);
+            result = result2;
+        }
+        return result;
+    }
+
+    public static final String[] toLowerCaseWordArray(String text) {
+        if (text == null || text.length() == 0) return new String[0];
+        List<String> wordList = new ArrayList<String>();
+        BreakIterator boundary = BreakIterator.getWordInstance();
+        boundary.setText(text);
+        int start = 0;
+        for (int end = boundary.next(); end != -1; end = boundary.next()) {
+            String tmp = text.substring(start, end).trim();
+            tmp = tmp.replace("+", "");
+            tmp = tmp.replace("/", "");
+            tmp = tmp.replace("\\", "");
+            tmp = tmp.replace("#", "");
+            tmp = tmp.replace("*", "");
+            tmp = tmp.replace(")", "");
+            tmp = tmp.replace("(", "");
+            tmp = tmp.replace("&", "");
+            if (tmp.length() > 0) wordList.add(tmp);
+            start = end;
+        }
+
+        return (String[]) (String[]) wordList.toArray(new String[wordList.size()]);
+    }
+
+    public static final String createTempTable() {
+        return "temp_" + StringUtil.randomString(10);
+    }
+
+    /**
+     * 产生指定长度的字符串
+     * 
+     * @param length
+     * @return
+     */
+    public static final String randomString(int length) {
+        if (length < 1) {
+            return null;
+        }
+
+        char randBuffer[] = new char[length];
+        for (int i = 0; i < randBuffer.length; i++)
+            randBuffer[i] = numbersAndLetters[randGen.nextInt(numbersAndLetters.length)];
+
+        return new String(randBuffer);
+    }
+
+    public static final String randomNumber(int length) {
+        Long value = Math.abs(randGen.nextLong());
+        String strValue = value.toString();
+        if (strValue.length() > length) {
+            strValue = strValue.substring(0, length);
+        }
+
+        return strValue;
+    }
+
+    public static final String chopAtWord(String string, int length) {
+        if (string == null) return string;
+        char charArray[] = string.toCharArray();
+        int sLength = string.length();
+        if (length < sLength) sLength = length;
+        for (int i = 0; i < sLength - 1; i++) {
+            if (charArray[i] == '\r' && charArray[i + 1] == '\n') return string.substring(0, i + 1);
+            if (charArray[i] == '\n') return string.substring(0, i);
+        }
+
+        if (charArray[sLength - 1] == '\n') return string.substring(0, sLength - 1);
+        if (string.length() < length) return string;
+        for (int i = length - 1; i > 0; i--)
+            if (charArray[i] == ' ') return string.substring(0, i).trim();
+
+        return string.substring(0, length);
+    }
+
+    public static final String escapeForXML(String string) {
+        if (string == null) return null;
+        int i = 0;
+        int last = 0;
+        char input[] = string.toCharArray();
+        int len = input.length;
+        StringBuffer out = new StringBuffer((int) ((double) len * 1.3D));
+        for (; i < len; i++) {
+            char ch = input[i];
+            if (ch > '>') continue;
+            if (ch == '<') {
+                if (i > last) out.append(input, last, i - last);
+                last = i + 1;
+                out.append(LT_ENCODE);
+                continue;
+            }
+            if (ch == '&') {
+                if (i > last) out.append(input, last, i - last);
+                last = i + 1;
+                out.append(AMP_ENCODE);
+                continue;
+            }
+            if (ch != '"') continue;
+            if (i > last) out.append(input, last, i - last);
+            last = i + 1;
+            out.append(QUOTE_ENCODE);
+        }
+
+        if (last == 0) return string;
+        if (i > last) out.append(input, last, i - last);
+        return out.toString();
+    }
+
+    public static final String unescapeFromXML(String string) {
+        string = string.replace("&lt;", "<");
+        string = string.replace("&gt;", ">");
+        string = string.replace("&quot;", "\"");
+        return string.replace("&amp;", "&");
+    }
+
+    public static final String zeroPadString(String string, int length) {
+        if (string == null || string.length() > length) {
+            return string;
+        } else {
+            StringBuffer buf = new StringBuffer(length);
+            buf.append(zeroArray, 0, length - string.length()).append(string);
+            return buf.toString();
+        }
+    }
+
+    public static final String zeroAppendString(String string, int length) {
+        if (string == null || string.length() > length) {
+            return string;
+        } else {
+            StringBuffer buf = new StringBuffer(length);
+            buf.append(string).append(zeroArray, 0, length - string.length());
+            return buf.toString();
+        }
+    }
+
+    public static final String charPadString(String string, int length, char append) {
+        if (string == null || string.length() > length) {
+            return string;
+        } else {
+            char[] charArray = new char[length - string.length()];
+            for (int i = 0; i < charArray.length; i++) {
+                charArray[i] = append;
+            }
+            StringBuffer buf = new StringBuffer(length);
+            buf.append(charArray, 0, charArray.length).append(string);
+            return buf.toString();
+        }
+    }
+
+    public static final String charAppendString(String string, int length, char append) {
+        if (string == null || string.length() > length) {
+            return string;
+        } else {
+            char[] charArray = new char[length - string.length()];
+            for (int i = 0; i < charArray.length; i++) {
+                charArray[i] = append;
+            }
+            StringBuffer buf = new StringBuffer(length);
+            buf.append(string).append(charArray, 0, charArray.length);
+            return buf.toString();
+        }
+    }
+
+    public static final String dateToMillis(Date date) {
+        return zeroPadString(Long.toString(date.getTime()), 15);
+    }
+
+    public static final String collectionToString(Collection<Object> c, String split) {
+        StringBuilder ret = new StringBuilder();
+        List<Object> a;
+        if (c == null) return null;
+        if (split == null) return null;
+        a = new ArrayList<Object>(c);
+        try {
+            for (int i = 0; i < a.size(); i++) {
+                String t = (String) a.get(i);
+                if (i == a.size() - 1) {
+                    ret.append(t);
+                } else {
+                    ret.append(t).append(split);
+
+                }
+            }
+
+            return ret.toString();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public static String encodeUrlString(String str) {
+        String strret = null;
+        if (str == null) return str;
+        try {
+            strret = URLEncoder.encode(str, "GBK");
+        } catch (Exception e) {
+            e.printStackTrace(System.err);
+            return null;
+        }
+        return strret;
+    }
+
+    public static String decodeUrlString(String str) {
+        String strret = null;
+        if (str == null) return str;
+        try {
+            strret = URLDecoder.decode(str, "GBK");
+        } catch (Exception e) {
+            e.printStackTrace(System.err);
+            return null;
+        }
+        return strret;
+    }
+
+    public static String join(Object list[], String separator) {
+        int listSize = list.length;
+        int bufSize = listSize == 0 ? 0 : (list[0].toString().length() + separator.length()) * listSize;
+        StringBuffer buf = new StringBuffer(bufSize);
+        for (int i = 0; i < listSize; i++) {
+            if (i > 0) buf.append(separator);
+            buf.append(list[i]);
+        }
+
+        return buf.toString();
+    }
+
+    public static String join(Iterator<?> iterator, String separator) {
+        StringBuffer buf = new StringBuffer();
+        do {
+            if (!iterator.hasNext()) break;
+            buf.append(iterator.next());
+            if (iterator.hasNext()) buf.append(separator);
+        } while (true);
+        return buf.toString();
+    }
+
+    public static boolean isEmpty(String param) {
+        return param == null || "".equals(param) || "".equals(param.trim()) || "null".equals(param) || "\"null\"".equals(param) || "undefined".equals(param) || "[]".equals(param);
+    }
+
+    public static boolean isNotEmpty(String param) {
+        return !isEmpty(param);
+    }
+
+    public static int getDecimalplace(String factor) {
+        int pointPos = factor.indexOf(".");
+        int onePos = factor.indexOf("1");
+        int precision = onePos - pointPos;
+        return precision > 0 ? precision : 0;
+    }
+
+    /**
+     * 对字符串做定长处理，超过长度，截取，长度不够补在前方补齐
+     * 
+     * @param str
+     * @param len
+     * @param appendStr 补齐的字符，
+     * @return
+     */
+    public static String AddjustLength(String str, int len, String appendStr) {
+        if (str == null) {
+            return null;
+        }
+        if (str.length() == len) {
+            return str;
+        } else if (str.length() < len) {
+            StringBuffer buf = new StringBuffer(len);
+            for (int i = 0; i < len - str.length(); i++) {
+                buf.append(appendStr);
+            }
+            buf.append(str);
+            if (buf.length() > len) {
+                return buf.substring(buf.length() - len);
+            } else {
+                return buf.toString();
+            }
+        } else {
+            return str.substring(str.length() - len, str.length());
+        }
+    }
+
+    /**
+     * 比较separator分隔的2个字符串是否相等
+     * 
+     * @param str1
+     * @param str2
+     * @param separator 字符串分隔符
+     * @return
+     */
+    public static boolean isEquals(String str1, String str2, String separator) {
+        if (StringUtils.isEmpty(str1) && StringUtils.isEmpty(str2)) {
+            return false;
+        }
+        String[] str1Array = StringUtils.split(str1, separator);
+        String[] str2Array = StringUtils.split(str2, separator);
+
+        if (str1Array.length != str2Array.length) {
+            return false;
+        }
+
+        List<String> refList = new ArrayList<String>();
+        for (String refStr : str1Array) {
+            refList.add(refStr);
+        }
+
+        for (String desStr : str2Array) {
+            if (!refList.contains(desStr)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * 转换字符串分隔的字符串为Integer数组
+     * 
+     * @param values
+     * @param spare
+     * @return
+     */
+    public static List<Integer> parseIntList(String values, String spare) {
+        List<Integer> list = new ArrayList<Integer>();
+        String[] valueArray = StringUtils.split(values, spare);
+        if (valueArray != null) {
+            for (String value : valueArray) {
+                if (NumberUtils.isDigits(value)) {
+                    list.add(NumberUtils.toInt(value));
+                }
+            }
+        }
+        return list;
+
+    }
+
+    public static double parseDouble(String src) {
+        if (!isEmpty(src)) {
+            return Double.parseDouble(src);
+        }
+        return 0;
+    }
+
+    public static int parseInt(String src) {
+        if (!isEmpty(src)) {
+            return Integer.parseInt(src);
+        }
+        return 0;
+    }
+
+    public static long parseLong(String src) {
+        if (!isEmpty(src)) {
+            return Long.parseLong(src);
+        }
+        return 0;
+    }
+
+    public static String format(String number, int decimalDigits) {
+        if (!StringUtil.isEmpty(number) && NumberUtils.isDigits(number)) {
+            return StringUtil.format(Double.parseDouble(number), decimalDigits);
+        } else {
+            return number;
+        }
+    }
+
+    public static String trim(String src) {
+        return src == null ? "" : src.trim();
+    }
+
+    /**
+     * 数字格式化函数
+     * 
+     * @param number : 格式化前的数字;
+     * @param decimalDigits : 小数位数;
+     * @return: 字符串;
+     */
+    public static String format(double number, int decimalDigits) {
+        if (number == 0d) {
+            number = 0d;
+        }
+
+        boolean flag = false;
+        if (decimalDigits < 0) {
+            // 小数位数不能小于0.
+            return "";
+        }
+
+        String pattern = "##################";
+        if (decimalDigits > 0) {
+            flag = true;
+            pattern += ".";
+            for (int i = 0; i < decimalDigits; i++) {
+                pattern += "0";
+            }
+        }
+
+        DecimalFormat df = new DecimalFormat(pattern);
+        if (number <= -1d) {
+            return df.format(number);
+        } else if (number > -1d && number < 0d) {
+            return "-0" + df.format(number).substring(1);
+        } else if (number >= 0d && number < 1d) {
+            if (flag) {
+                String temp = df.format(number);
+                if (StringUtil.isNotEmpty(temp) && temp.substring(0, 1).equals(".")) {
+                    return "0" + df.format(number);
+                } else {
+                    return temp;
+                }
+            } else {
+                return df.format(number);
+            }
+        } else {
+            return df.format(number);
+        }
+    }
+
+    public static Integer toInteger(Object object) {
+        if (object == null) {
+            return 0;
+        }
+        return Integer.valueOf(object.toString());
+    }
+
+    public static Short toShort(Object object) {
+        if (object == null) {
+            return null;
+        }
+        return Short.valueOf(object.toString());
+    }
+
+    public static String objectToString(Object obj) {
+        if (obj == null) {
+            return null;
+        } else {
+            return obj.toString();
+        }
+    }
+
+    /**
+     * 字串逆排
+     * 
+     * @return
+     */
+    public static String revert(String src) {
+        if (isEmpty(src)) return "";
+        StringBuffer result = new StringBuffer();
+        for (int i = src.length() - 1; i >= 0; i--) {
+            result.append(src.charAt(i));
+        }
+        return result.toString();
+    }
+
+    public static boolean isValidateString(String path) {
+        if (StringUtil.isEmpty(path)) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    public static String encodingUtf8(String src) throws UnsupportedEncodingException {
+        if (isEmpty(src)) return "";
+        return new String(src.getBytes("ISO-8859-1"), "UTF-8");
+    }
+
+    public static String encodingJson(String src) throws UnsupportedEncodingException {
+        if (isEmpty(src)) return "";
+        int pos = src.indexOf("\\u");
+        StringBuffer sb = new StringBuffer();
+        while (pos >= 0 && (pos + 6 <= src.length())) {
+            sb.append(src.substring(0, pos));
+            String temp = src.substring(pos + 2, pos + 6);
+            sb.append((char) Integer.parseInt(temp, 16));// 将\u6d4b\u8bd5
+                                                         // 格式的文字转为
+                                                         // 正常的string编码
+                                                         // “测试”(因为Ext.encode(array)的方法解析出来是jsonarray格式)
+            src = src.substring(pos + 6);
+            pos = src.indexOf("\\u");
+        }
+        sb.append(src);
+        return sb.toString();
+    }
+
+    /**
+     * 正则
+     */
+    public static String replaceBlank(String str) {
+        String dest = "";
+        if (str != null) {
+            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
+            Matcher m = p.matcher(str);
+            dest = m.replaceAll("");
+        }
+        return dest;
+    }
+
+    /**
+     * 不定参数校验空
+     * 
+     * @param args
+     * @return
+     */
+    public static boolean isNull(String... args) {
+        for (String arg : args) {
+            if (StringUtils.isEmpty(arg)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 不定参数校验数字
+     * 
+     * @param args
+     * @return
+     */
+    public static boolean isNotNumber(String... args) {
+        for (String arg : args) {
+            if (!NumberUtils.isDigits(arg)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 不定参数校验数字
+     * 
+     * @param args
+     * @return
+     */
+    public static boolean isNotDigits(String... args) {
+        for (String arg : args) {
+            if (!NumberUtils.isDigits(arg)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * toString增加判空
+     */
+    public static String toString(Object obj) {
+        if(obj == null) {
+            return "";
+        }
+        return obj.toString();
+    }
+
+    /**
+     * @param value:十进制字字符
+     * @param radix：目标进制
+     * @param length：目标长度
+     * @param pad：前补的字符
+     * @return
+     */
+    public static String numStr2PadString(String value, int radix, int length, String pad) {
+        if (value == null) return charPad("", length, pad);
+        // Integer temp = NumberUtils.toInt(value);
+        String result = Integer.toString(NumberUtils.toInt(value), radix);
+        return AddjustLength(result, length, pad);
+    }
+
+    public static String charPad(String value, int length, String pad) {
+        if (value == null || value.length() > length) return value;
+        String padString = "";
+        for (int i = 0; i < (length - value.length()); i++) {
+            padString += pad;
+        }
+        return padString + value;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("operator_secret: " + randomString(17));
+        System.out.println("data_secret: " + randomString(16));
+        System.out.println("data_secret_iv: " + randomString(16));
+        System.out.println("sign_secret: " + randomString(19));
+
+    }
+}

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/resources/application.properties

@@ -0,0 +1,66 @@
+server.port=9891
+spring.application.name=data-agbox-java
+
+# mybatis-plus
+mybatis-plus.mapper-locations=classpath*:mapper/*.xml
+mybatis-plus.configuration.lazy-loading-enabled=true
+mybatis-plus.configuration.map-underscore-to-camel-case=true
+mybatis-plus.global-config.db-config.id-type=auto
+mybatis-plus.global-config.mapperRegistryCache=true
+mybatis-plus.configuration.defaultStatementTimeout=3
+mybatis.refresh.enabled=true
+mybatis.refresh.delay-seconds=10
+mybatis.refresh.sleep-seconds=20
+
+# mybatisplus
+spring.datasource.dynamic.primary=sdp
+spring.datasource.dynamic.datasource.sdp.url=jdbc:mysql://47.111.81.118:3306/sd_party_school?useunicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
+spring.datasource.dynamic.datasource.sdp.username=root
+spring.datasource.dynamic.datasource.sdp.password=Yt2021
+spring.datasource.dynamic.druid.initial-size=5                                                                       
+spring.datasource.dynamic.druid.min-idle=5
+spring.datasource.dynamic.druid.max-active=30
+spring.datasource.dynamic.druid.max-wait=60000
+spring.datasource.dynamic.druid.validation-query=select 1
+spring.datasource.dynamic.druid.test-while-idle=true
+spring.datasource.dynamic.druid.test-on-borrow=true
+spring.datasource.dynamic.druid.test-on-return=false
+spring.datasource.dynamic.druid.pool-prepared-statements=true
+spring.datasource.dynamic.druid.max-pool-prepared-statement-per-connection-size=20
+spring.datasource.dynamic.druid.time-between-eviction-runs-millis=60000
+spring.datasource.dynamic.druid.min-evictable-idle-time-millis=300000
+spring.datasource.dynamic.druid.filters=wall,stat,log4j2
+# druid \u76D1\u63A7 WebStatFilter\u914D\u7F6E
+spring.datasource.druid.web-stat-filter.enabled=true
+spring.datasource.druid.web-stat-filter.url-pattern=/*
+spring.datasource.druid.web-stat-filter.exclusions=*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*
+spring.datasource.druid.web-stat-filter.profile-enable=true
+# druid \u89C6\u56FE StatViewServlet\u914D\u7F6E
+spring.datasource.druid.stat-view-servlet.enabled=true
+spring.datasource.druid.stat-view-servlet.url-pattern=/druid/*
+spring.datasource.druid.stat-view-servlet.reset-enable=true
+spring.datasource.druid.stat-view-servlet.login-username=admin
+spring.datasource.druid.stat-view-servlet.login-password=@dmin1234
+# datasource log
+spring.datasource.druid.filter.slf4j.enabled=true
+spring.datasource.druid.filter.slf4j.statement-create-after-log-enabled=false
+spring.datasource.druid.filter.slf4j.statement-close-after-log-enabled=false
+spring.datasource.druid.filter.slf4j.result-set-open-after-log-enabled=false
+spring.datasource.druid.filter.slf4j.result-set-close-after-log-enabled=false
+
+#mqttt
+mqtt.completionTimeout=5000
+mqtt.keep-alive-interval=60
+mqtt.username=usky
+mqtt.password=usky
+mqtt.sub-topics=sd/fire/ytDP0007/infoAndAlarm,sd/fire/ytDP0006/infoAndAlarm,sd/fire/ytDP0001/infoAndAlarm,sd/fire/ytCamCore/infoAndAlarm,sd/fire/ytDP0002/infoAndAlarm,sd/fire/ytDP0008/infoAndAlarm,/edge/baInfo/C90FF1A17AA04E99A06C9A012CD0DD04/rtg
+mqtt.url=tcp://47.98.201.73:1883
+# jackson
+spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
+spring.jackson.time-zone=GMT+8
+spring.jackson.default-property-inclusion=always
+#spring.jackson.serialization.indent_output=true
+spring.jackson.serialization.fail-on-empty-beans=false
+spring.jackson.deserialization.fail-on-unknown-properties=false
+spring.jackson.parser.allow-unquoted-control-chars=true
+spring.jackson.parser.allow-single-quotes=true

data-agbox-java-demo/data-agbox-java-demo-biz/src/main/resources/bootstrap.yml

@@ -1,91 +1,3 @@
 # Tomcat
-server:
-  port: 9887
 
-mybatis:
-  refresh:
-    delay-seconds: 10
-    enabled: true
-    sleep-seconds: 20
-mybatis-plus:
-  configuration:
-    defaultStatementTimeout: 3
-    lazy-loading-enabled: true
-    map-underscore-to-camel-case: true
-  global-config:
-    db-config:
-      id-type: auto
-    mapperRegistryCache: true
-  mapper-locations: classpath*:mapper/**/*.xml
-spring:
-  application:
-    name: data-agbox-java
-  cache:
-    ehcache:
-      config: classpath:ehcache.xml
-      enabled: false
-    redis:
-      enabled: true
-  datasource:
-    druid:
-      stat-view-servlet:
-        enabled: true
-        login-password: '@dmin1234'
-        login-username: admin
-        reset-enable: true
-        url-pattern: /druid/*
-    dynamic:
-      datasource:
-        master:
-          password: password
-          url: jdbc:mysql://172.16.120.165:3306/usky-cloud?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8&allowMultiQueries=true
-          username: root
-      druid:
-        initial-size: 5
-        min-idle: 5
-        maxActive: 20
-        maxWait: 60000
-        timeBetweenEvictionRunsMillis: 60000
-        minEvictableIdleTimeMillis: 300000
-        validationQuery: SELECT 1 FROM DUAL
-        testWhileIdle: true
-        testOnBorrow: false
-        testOnReturn: false
-        poolPreparedStatements: true
-        maxPoolPreparedStatementPerConnectionSize: 20
-        filters: stat,slf4j
-        connectionProperties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
-      primary: master
-  jackson:
-    date-format: yyyy-MM-dd HH:mm:ss
-    default-property-inclusion: always
-    deserialization:
-      fail-on-unknown-properties: false
-    parser:
-      allow-single-quotes: true
-      allow-unquoted-control-chars: true
-    serialization:
-      fail-on-empty-beans: false
-    time-zone: GMT+8
-  redis:
-    host: 172.16.120.165
-    password: 123456
-    port: 6379
-    timeout: 10000
-  tenant:
-    enable: false
-  servlet:
-    multipart:
-      max-file-size: 10MB
-      max-request-size: 15MB
 
-temp:
-  basedir: C:/Users/pc/Desktop/
-mqtt:
-  completionTimeout: 5000
-  enabled: true
-  keep-alive-interval: 60
-  password: public
-  sub-topics: data-collector,511-XFFJ/+/+/control
-  url: tcp://172.16.120.151:1883
-  username: admin

pom.xml

@@ -33,27 +33,23 @@
 
   </modules>
 
-  <repositories>
-    <repository>
-      <id>aliyun</id>
-      <name>aliyun Repository</name>
-      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
-      <snapshots>
-        <enabled>false</enabled>
-      </snapshots>
-    </repository>
-  </repositories>
-
-
-
   <dependencies>
     <!-- bootstrap 启动器 -->
     <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-bootstrap</artifactId>
     </dependency>
+    <!-- JSON 解析器和生成器 -->
+    <dependency>
+      <groupId>com.alibaba</groupId>
+      <artifactId>fastjson</artifactId>
+      <version>${fastjson.version}</version>
+    </dependency>
+    <!-- SpringBoot 核心组件 -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
   </dependencies>
-      
-
 
 </project>