三诺数据上传及同步至I健康

svr/svr-iot-sunruo/pom.xml

@@ -0,0 +1,125 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.yihu.jw</groupId>
        <artifactId>wlyy-parent-pom</artifactId>
        <version>2.0.0</version>
        <relativePath>../../wlyy-parent-pom/pom.xml</relativePath>
    </parent>
    <groupId>com.yihu.iot</groupId>
    <artifactId>svr-iot-sr</artifactId>
    <version>${parent.version}</version>
    <packaging>war</packaging>
    <dependencies>
        <!-- 支持Tomcat启动 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <!-- 支持Tomcat启动 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.15-beta1</version>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-entity</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-entity-es</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-request-mapping</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-exception</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-rest-model</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-rest-model-es</artifactId>
        </dependency>
        <dependency>
            <groupId>com.yihu.jw</groupId>
            <artifactId>common-util</artifactId>
        </dependency>
        <!-- jkzl starter -->
        <dependency>
            <groupId>com.yihu</groupId>
            <artifactId>swagger-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.yihu</groupId>
            <artifactId>mysql-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.yihu</groupId>
            <artifactId>elasticsearch-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>svr-iot</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin </artifactId>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

svr/svr-iot-sunruo/readme.MD

@@ -0,0 +1,20 @@
Internet of things  物联网平台
filters 字符串拼接规则
         * like：使用"?"来表示，如：name?'%医'
         * in：使用"="来表示并用","逗号对值进行分隔，如：status=2,3,4,5
         * not in：使用"<>"来表示并用","逗号对值进行分隔，如：status=2,3,4,5
         * =：使用"="来表示，如：status=2
         * >=：使用大于号和大于等于语法，如：createDate>2012
         * <=：使用小于号和小于等于语法，如：createDate<=2015
         * 分组：在条件后面加上空格，并设置分组号，如：createDate>2012 g1，具有相同组名的条件将使用or连接 GB/T 2261.2-2003
         * 多条件组合：使用";"来分隔
         * <p/>
         * 生成 where 条件。
sort
     * +code 以code字段进行升序排序
     * -code 以code字段进行降序排序
     * 生成排序字段。

svr/svr-iot-sunruo/src/main/java/com/yihu/IOTApplication.java

@@ -0,0 +1,24 @@
package com.yihu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
/**
 * Created by chenweida on 2017/11/27.
 */
@EnableJpaAuditing
@SpringBootApplication
public class IOTApplication extends SpringBootServletInitializer  {
    public static void main(String[] args) {
        SpringApplication.run(IOTApplication.class, args);
    }
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(IOTApplication.class);
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/controller/IotAnalyzerController.java

@@ -0,0 +1,131 @@
package com.yihu.iot.datainput.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.iot.datainput.service.DataInputService;
import com.yihu.iot.datainput.util.ConstantUtils;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.util.date.DateUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
/**
 * @author cws on 2018/1/16.
 */
@RestController
@RequestMapping("svr-iot-sr/analyze" )
@Api(tags = "设备数据解析入库", description = "三诺设备的采集数据上传，并同步到I健康。")
public class IotAnalyzerController extends EnvelopRestEndpoint {
    @Autowired
    private DataInputService dataInputService;
    @Autowired
    ObjectMapper objectMapper;
    /**
     * 基于奕拓小屋上传的体征数据，进行解析入库
     * @param jsonData
     * @return
     */
    @PostMapping(value = "/sanruo" ,consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ApiOperation(value = "三诺体征数据解析入库", notes = "三诺体征数据解析入库")
    public String updateSanruoDate(
            @ApiParam(name = "json_data", value = "Json数据", required = true)
            @RequestBody String jsonData) throws Exception{
        Envelop envelop = new Envelop();
        String str = "";
        String strResult = "";
        String accessToken  = "sanruo";
        try {
            //JSON数据解析
            Map dataDetail = objectMapper.readValue(jsonData, HashMap.class);
            JSONArray jsonArray = new JSONArray();
            JSONObject params = new JSONObject();
            // 体征数据 - 明细
            LinkedHashMap msgdataMap = (LinkedHashMap)dataDetail.get("msgdata");
            JSONObject data = new JSONObject();
            data.put("deviceType","2");
            data.put("code",msgdataMap.get("code") == null? "":msgdataMap.get("code").toString());
            data.put("deviceSn",msgdataMap.get("devicesn") == null? "":msgdataMap.get("devicesn").toString());
            data.put("userCode",msgdataMap.get("usercode") == null? "":msgdataMap.get("usercode").toString());
            data.put("openId",msgdataMap.get("openid") == null? "":msgdataMap.get("openid").toString());
            data.put("data",msgdataMap.get("result") == null? "":msgdataMap.get("result").toString());
            data.put("unit",msgdataMap.get("unit") == null? "":msgdataMap.get("unit").toString());
            data.put("sendTime",msgdataMap.get("testtime") == null? "":msgdataMap.get("testtime").toString());
            //血糖测试时间段标志位(0餐前 1餐后 2随机)
            data.put("foodStatus",msgdataMap.get("foodstatus") == null? "":msgdataMap.get("foodstatus").toString());
            jsonArray.add(data);
            params.put("data", jsonArray);
            params.put("accessToken","sanruo");
            params.put("measure_time",msgdataMap.get("testtime") == null? "":msgdataMap.get("testtime").toString());
            params.put("sn",msgdataMap.get("devicesn") == null? "":msgdataMap.get("devicesn").toString());
            str = dataInputService.inputBodySignsData(params.toString(),accessToken);
            JSONObject result = JSONObject.parseObject(str);
            if (StringUtils.endsWithIgnoreCase(ConstantUtils.FAIL,result.getString("response"))) {
                Map res = new HashMap();
                res.put("success", "false");
                res.put("message", result.getString("msg"));
                strResult = objectMapper.writeValueAsString(res);
            }else {
                Map res = new HashMap();
                res.put("success", "true");
                res.put("message", "体征信息上传成功。");
                JSONArray ridRes = new JSONArray();
                ridRes = (JSONArray) result.get("rid");
                String rid = ridRes.get(0).toString();
                res.put("rid", rid);
                //体征信息上传成功后，同步到厦门I健康
                JSONObject dataSyn = new JSONObject();
                dataSyn.put("id",rid);
                dataSyn.put("deviceType",2);
                dataSyn.put("deviceSn",msgdataMap.get("devicesn") == null? "":msgdataMap.get("devicesn").toString());
                dataSyn.put("manufacturerCode","threeNod");
                dataSyn.put("manufacturerName","三诺设备");
                dataSyn.put("data",msgdataMap.get("result") == null? "":msgdataMap.get("result").toString());
                dataSyn.put("unit",msgdataMap.get("unit") == null? "":msgdataMap.get("unit").toString());
                dataSyn.put("sendTime",msgdataMap.get("testtime") == null? "":msgdataMap.get("testtime").toString());
                dataSyn.put("uploadTime", DateUtils.formatDate(new Date(), DateUtil.yyyy_MM_dd_HH_mm_ss));
                dataSyn.put("button","1");
                dataSyn.put("state",0);
                boolean synFlag = dataInputService.synXMIjk(dataSyn);
                if(synFlag){
                    res.put("message", "体征信息上传成功,同步到厦门I健康成功。");
                }else {
                    res.put("message", "体征信息上传成功,同步到厦门I健康失败。");
                }
                strResult = objectMapper.writeValueAsString(res);
            }
            return strResult;
        } catch (Exception e) {
            e.printStackTrace();
            return "三诺体征信息上传失败！";
        }
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/dao/DataProcessLogDao.java

@@ -0,0 +1,9 @@
package com.yihu.iot.datainput.dao;
import com.yihu.jw.entity.iot.datainput.DataProcessLogDO;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
public interface DataProcessLogDao extends PagingAndSortingRepository<DataProcessLogDO, String>, JpaSpecificationExecutor<DataProcessLogDO> {
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/enums/DataDeviceTypeEnum.java

@@ -0,0 +1,58 @@
package com.yihu.iot.datainput.enums;
import org.apache.commons.lang.StringUtils;
/**
 * 设备类型枚举类，有些设备测量血压，有些设备测量血糖等
 */
public enum DataDeviceTypeEnum {
    SYSTOLIC("1","SYSTOLIC"),
    BLOOD_SUGAR("2","BLOOD_SUGAR");
    private String type;
    private String name;
    private DataDeviceTypeEnum(String type,String name){
        this.type = type;
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    /**
     * 根据传入的设备类型返回对应的测量名称
     * @param type
     * @return
     */
    public static String getNameByType(String type){
        String name = "";
        DataDeviceTypeEnum[] arrays = DataDeviceTypeEnum.values();
        for(int i = 0;i < arrays.length;i++){
            if(StringUtils.equals(type,arrays[i].getType())){
                name = arrays[i].getName();
                return name;
            }
        }
        return name;
    }
    @Override
    public String toString() {
        return this.type.toString();
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/enums/DataOperationTypeEnum.java

@@ -0,0 +1,32 @@
package com.yihu.iot.datainput.enums;
public enum DataOperationTypeEnum {
    convert("数据标准转换"),
    bindUser("设备注册绑定"),
    upload0("不含居民信息的数据上传"),
    upload1("含居民信息的数据上传"),
    search("数据查询");
    private String name;
    private DataOperationTypeEnum(String name){
        this.name = name;
    }
    public String getName() {
        return name.toString();
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return this.name.toString();
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/enums/DataTypeEnum.java

@@ -0,0 +1,31 @@
package com.yihu.iot.datainput.enums;
import java.util.HashSet;
import java.util.Set;
public enum DataTypeEnum {
    body_sign_params("体征数据"),
    body_sports_params("运动数据");
    private String desc;
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    private DataTypeEnum(String desc){
        this.desc = desc;
    }
    public static Set<String> getNames(){
        Set<String> set = new HashSet<>();
        for(DataTypeEnum dataTypeEnum:DataTypeEnum.values()){
            set.add(dataTypeEnum.name().toString());
        }
        return set;
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/service/DataInputService.java

@@ -0,0 +1,165 @@
package com.yihu.iot.datainput.service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.elasticsearch.ElasticSearchHelper;
import com.yihu.iot.datainput.enums.DataOperationTypeEnum;
import com.yihu.iot.datainput.util.ConstantUtils;
import com.yihu.iot.datainput.util.HttpClientUtil;
import com.yihu.iot.datainput.util.RowKeyUtils;
import com.yihu.jw.util.date.DateUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.utils.DateUtils;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.*;
/**
 * 三诺设备数据上传协议
 */
@Component
public class DataInputService {
    private Logger logger = LoggerFactory.getLogger(DataInputService.class);
    @Autowired
    private DataProcessLogService dataProcessLogService;
    @Autowired
    private ElasticSearchHelper elasticSearchHelper;
    @Autowired
    private HttpClientUtil httpClientUtil;
    @Value("${spring.wlyy.url}")
    private String wlyyUrl;
    @Autowired
    ObjectMapper objectMapper;
    /**
     * 上传数据
     * @param json
     * @return
     */
    public String inputBodySignsData(String json, String accessToken) throws IOException {
        JSONObject result = new JSONObject();
        result.put("upload_time",DateUtils.formatDate(new Date(), DateUtil.yyyy_MM_dd_HH_mm_ss));
        if(StringUtils.isEmpty(json)){
            result.put("response",ConstantUtils.FAIL);
            result.put("msg","parameter json is null");
            return result.toString();
        }
        String fileName = "";
        String fileAbsPath = "";
        String rowkey = "";
        String dataSource = accessToken;
        String extCode = "";;
        //解析JSON数据
        JSONObject jsonObject = JSONObject.parseObject(json);
        JSONArray jsonArray = jsonObject.getJSONArray("data");
        if(null == jsonArray || jsonArray.size() == 0){
            result.put("response",ConstantUtils.FAIL);
            result.put("msg","parameter 'data' of json no exist");
            return result.toString();
        }
        List<String> rowkeyList = new ArrayList<>();
        List<Map<String,Map<String,String>>> familyList = new ArrayList<>();
        //循环数据，一组数据存一行，生成一个rowkey，并将该rowkey存到es中
        for(Object obj:jsonArray){
            JSONObject data = (JSONObject)obj;
            data.put("del","1"); //添加删除标记
            try {
                String measuretime = jsonObject.getString("measure_time");
                if(null == measuretime){
                    measuretime = DateUtils.formatDate(new Date(), DateUtil.yyyy_MM_dd_HH_mm_ss);
                }
                //生成一份json数据的rowkey
                rowkey = RowKeyUtils.makeRowKey(accessToken,dataSource, extCode, DateUtil.dateTimeParse(measuretime).getTime());
                data.put("rid",rowkey);//hbase的rowkey
                rowkeyList.add(rowkey);
            } catch (Exception e) {
                logger.error("make rowkey error");
                result.put("msg","make rowkey error");
                result.put("response",ConstantUtils.FAIL);
                return result.toString();
            }
            //组装B列
            Map<String, Map<String, String>> family = new HashMap<>();
            Map<String, String> columnsB = new HashMap<>();
            for(String key:data.keySet()){
                if(StringUtils.equalsIgnoreCase("rid",key)){ //存到hbase里的数据不需要rid
                    continue;
                }
                columnsB.put(key,data.getString(key));
            }
            family.put(ConstantUtils.familyB,columnsB);
            familyList.add(family);
        }
        List<String> saveList = new ArrayList<>();
        saveList.add(jsonObject.toJSONString());
        //将数据存入es
        boolean success = false;
        try {
            success = elasticSearchHelper.save(ConstantUtils.esIndex, ConstantUtils.esType, saveList);
        }catch (Exception e){
            logger.error("upload signBodyData to elasticsearch failed," + e.getMessage());
            result.put("msg","upload signBodyData to elasticsearch failed," + e.getMessage());
        }
        if(success){
            dataProcessLogService.saveLog(fileName, fileAbsPath, dataSource, "", DateUtils.formatDate(new Date(), DateUtil.yyyy_MM_dd_HH_mm_ss), "1", "4", "com.yihu.iot.datainput.service.DataInputService.uploadData", DataOperationTypeEnum.upload1.getName(), 0);
            JSONArray rids = new JSONArray();
            rids.addAll(rowkeyList);
            result.put("rid",rids);
            result.put("response",ConstantUtils.SUCCESS);
        }else{
            result.put("response",ConstantUtils.FAIL);
        }
        return result.toJSONString();
    }
    /**
     * 同步三诺的数据到I健康
     * @param json
     * @return
     * @throws IOException
     */
    public boolean synXMIjk(JSONObject json)throws Exception {
        Map params = new HashMap();
        params.put("typeId", 44);
        params.put("data",json.toString());
        String url = wlyyUrl + "/device/upload";
        try {
            String response = httpClientUtil.httpPost(url, params);
            if (response != null) {
                Map dataDetail = objectMapper.readValue(response, HashMap.class);
                if ("true".equals(dataDetail.get("successFlg").toString())){
                    return true;
                }
            }
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/service/DataProcessLogService.java

@@ -0,0 +1,39 @@
package com.yihu.iot.datainput.service;
import com.yihu.iot.datainput.dao.DataProcessLogDao;
import com.yihu.jw.entity.iot.datainput.DataProcessLogDO;
import com.yihu.mysql.query.BaseJpaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class DataProcessLogService extends BaseJpaService<DataProcessLogDO,DataProcessLogDao> {
    @Autowired
    private DataProcessLogDao dataProcessLogDao;
    /**
     * 保存数据上传日志
     */
    public void saveDataLog(List<DataProcessLogDO> list){
        this.dataProcessLogDao.save(list);
    }
    public void saveLog(String fileName,String fileAbsPath,String dataSource,String receiveTime,String uploadTime,String processType,String status,String processInterface,String desc,int failCount){
        DataProcessLogDO dataProcessLog = new DataProcessLogDO();
        dataProcessLog.setFileName(fileName);
        dataProcessLog.setFileAbsoultePath(fileAbsPath);
        dataProcessLog.setDataSource(dataSource);
        dataProcessLog.setReceiveTime(receiveTime);
        dataProcessLog.setUploadTime(uploadTime);
        dataProcessLog.setProcessType(processType);
        dataProcessLog.setProcessStatus(status);
//        dataProcessLog.setProcessInterface(processInterface);
        dataProcessLog.setProcessDes(desc);
        /*dataProcessLog.setFileCount(failCount);*/
        dataProcessLogDao.save(dataProcessLog);
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/util/ConstantUtils.java

@@ -0,0 +1,18 @@
package com.yihu.iot.datainput.util;
public class ConstantUtils {
    //体征数据es索引
    public static String esIndex = "body_health_data_sr";
    //体征数据es类型
    public static String esType = "signs_data_sr";
    //体征数据hbase表名
    public static String tableName = "body_health_data_sr";
    public static String familyA = "column_signs_header_sr";
    public static String familyB = "column_signs_data_sr";
    //数据返回结果标识
    public static final String SUCCESS = "success";
    public static final String FAIL = "fail";
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/util/HttpClientUtil.java

@@ -0,0 +1,201 @@
package com.yihu.iot.datainput.util;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
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.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.alibaba.fastjson.JSONObject;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
@Component
public class HttpClientUtil {
    /**
     * 发送post请求
     *
     * @param url     请求地址
     * @param params  请求参数
     * @param chatSet 编码格式
     * @return
     */
    public  String post(String url, List<NameValuePair> params, String chatSet) {
        // 创建默认的httpClient实例.
        CloseableHttpClient httpclient = HttpClients.createDefault();
        // 创建httppost
        HttpPost httppost = new HttpPost(url);
        UrlEncodedFormEntity uefEntity;
        try {
            uefEntity = new UrlEncodedFormEntity(params, chatSet);
            httppost.setEntity(uefEntity);
            CloseableHttpResponse response = httpclient.execute(httppost);
            try {
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    return EntityUtils.toString(entity, chatSet);
                }
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e1) {
            e1.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接,释放资源
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 发送get请求
     *
     * @param url     请求地址
     * @param chatSet 编码格式
     * @return
     */
    public  String get(String url, String chatSet) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        try {
            // 创建httpget.
            HttpGet httpget = new HttpGet(url);
            // 执行get请求.
            CloseableHttpResponse response = httpclient.execute(httpget);
            try {
                // 获取响应实体
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    return EntityUtils.toString(entity, chatSet);
                }
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接,释放资源
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * http调用方法，(健康之路开放平台)
     *
     * @param url
     * @param params
     * @return
     * @throws Exception
     */
    public  String httpPost(String url, Map<String, String> params) throws Exception {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        try {
            HttpPost httpPost = new HttpPost(url);
            if (params != null && params.size() > 0) {
                List<NameValuePair> valuePairs = new ArrayList<NameValuePair>(params.size());
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    NameValuePair nameValuePair = new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue()));
                    valuePairs.add(nameValuePair);
                }
                UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(valuePairs, "UTF-8");
                httpPost.setEntity(formEntity);
            }
            CloseableHttpResponse resp = httpclient.execute(httpPost);
            try {
                HttpEntity entity = resp.getEntity();
                String respContent = EntityUtils.toString(entity, "UTF-8").trim();
                return respContent;
            } finally {
                resp.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            httpclient.close();
        }
    }
    /**
     * 获取加密后参数集合(健康之路开放平台)
     *
     * @param params
     * @return
     */
    public  Map<String, String> getSecretParams(Map<String, String> params, String appId, String secret) {
        String timestamp = Long.toString(System.currentTimeMillis());
        params.put("timestamp", timestamp);
        StringBuilder stringBuilder = new StringBuilder();
        // 对参数名进行字典排序  
        String[] keyArray = params.keySet().toArray(new String[0]);
        Arrays.sort(keyArray);
        // 拼接有序的参数名-值串  
        stringBuilder.append(appId);
        for (String key : keyArray) {
            stringBuilder.append(key).append(params.get(key));
        }
        String codes = stringBuilder.append(secret).toString();
        String sign = org.apache.commons.codec.digest.DigestUtils.shaHex(codes).toUpperCase();
        // 添加签名,并发送请求  
        params.put("appId", appId);
        params.put("sign", sign);
        return params;
    }
    public  String postBody(String url, JSONObject params) {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
        headers.setContentType(type);
        headers.add("Accept", MediaType.APPLICATION_JSON.toString());
        org.springframework.http.HttpEntity<String> formEntity = new org.springframework.http.HttpEntity<String>(params.toString(), headers);
        String ret = restTemplate.postForObject(url, formEntity, String.class);
        return ret;
    }
    public  void putBody(String url, JSONObject params) {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
        headers.setContentType(type);
        headers.add("Accept", MediaType.APPLICATION_JSON.toString());
        org.springframework.http.HttpEntity<String> formEntity = new org.springframework.http.HttpEntity<String>(params.toString(), headers);
        restTemplate.put(url, formEntity, String.class);
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/datainput/util/RowKeyUtils.java

@@ -0,0 +1,98 @@
package com.yihu.iot.datainput.util;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.Base64Utils;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.security.Key;
import java.security.spec.AlgorithmParameterSpec;
public class RowKeyUtils {
    private static EncryptUtil encryptUtil = EncryptUtil.getInstance();
    public static String  makeRowKey(String accessToken,String deviceSn,String extCode,long measureTime) throws Exception {
        StringBuilder sb = new StringBuilder();
        sb.append(accessToken+",");
        sb.append(deviceSn+",");
        sb.append(extCode+",");
        sb.append(measureTime);
        return Base64Utils.encodeToString(sb.toString().getBytes()).toString();
    }
    /**
     * 将rowkey里的信息还原回去
     */
    public static String getMessageFromRowKey(String rowkey) throws Exception {
        return encryptUtil.decode(rowkey);
    }
    static class EncryptUtil {
        private final byte[] DESIV = new byte[] { 0x12, 0x34, 0x56, 120, (byte) 0x90, (byte) 0xab, (byte) 0xcd, (byte) 0xef };// 向量
        private AlgorithmParameterSpec iv = null;// 加密算法的参数接口
        private Key key = null;
        private static String charset = "utf-8";
        private static String deskey = "9ba45bfd500642328ec03ad8ef1b6e75";// 自定义密钥
        private static EncryptUtil encryptUtils = null;
        public static synchronized EncryptUtil getInstance()  {
            try {
                if(null == encryptUtils){
                    encryptUtils = new EncryptUtil(deskey,charset);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
            return encryptUtils;
        }
        /**
         * 初始化
         * @param deSkey    密钥
         * @throws Exception
         */
        private EncryptUtil(String deSkey, String charset) throws Exception {
            if (StringUtils.isNotBlank(charset)) {
                this.charset = charset;
            }
            DESKeySpec keySpec = new DESKeySpec(deSkey.getBytes(this.charset));// 设置密钥参数
            iv = new IvParameterSpec(DESIV);// 设置向量
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");// 获得密钥工厂
            key = keyFactory.generateSecret(keySpec);// 得到密钥对象
        }
        /**
         * 加密
         */
        public String encode(String data) throws Exception {
            Cipher enCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");// 得到加密对象Cipher
            enCipher.init(Cipher.ENCRYPT_MODE, key, iv);// 设置工作模式为加密模式，给出密钥和向量
            byte[] pasByte = enCipher.doFinal(data.getBytes("utf-8"));
            BASE64Encoder base64Encoder = new BASE64Encoder();
            return base64Encoder.encode(pasByte);
        }
        /**
         * 解密
         */
        public String decode(String data) throws Exception {
            Cipher deCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
            deCipher.init(Cipher.DECRYPT_MODE, key, iv);
            BASE64Decoder base64Decoder = new BASE64Decoder();
            byte[] pasByte = deCipher.doFinal(base64Decoder.decodeBuffer(data));
            return new String(pasByte, "UTF-8");
        }
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/service/common/ElasticSearchQueryGenerator.java

@@ -0,0 +1,227 @@
package com.yihu.iot.service.common;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.datainput.Data;
import com.yihu.jw.datainput.StepInfoDO;
import org.apache.commons.lang.StringUtils;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.PostConstruct;
import java.beans.PropertyDescriptor;
import java.util.*;
@Component
public class ElasticSearchQueryGenerator {
    private static Map<String,Set<String>> fieldsMap = new HashMap<>();
    @PostConstruct
    public static void init(){
        Set<String> fieldsSet = new HashSet<>();
        PropertyDescriptor[] properties = BeanUtils.getPropertyDescriptors(Data.class);
        for(PropertyDescriptor field:properties){
            fieldsSet.add(field.getName());
        }
        fieldsMap.put("data",fieldsSet);
        Set<String> fieldsSet2 = new HashSet<>();
        PropertyDescriptor[] properties2 = BeanUtils.getPropertyDescriptors(StepInfoDO.class);
        for(PropertyDescriptor field:properties2){
            fieldsSet2.add(field.getName());
        }
        fieldsMap.put("stepInfoList",fieldsSet2);
    }
    /**
     * 构造es查询参数
     * @param jsonData
     *
    {
    "filter":[{"andOr":"and|or","condition":">|=|<|>=|<=|?","field":"<filed>","value":"<value>"},<{...}>],
    - 参数说明：andOr跟数据库的中的AND和OR相似；condition指条件匹配程度，?相当于数据库中的like；filed指检索的字段；value为检索的值
    "page":1,  - 参数格式：页码，默认1，int类型 不需要分页，传""
    "size":10, - 参数格式：条数，默认10，int类型 不需要分页，传""
    "sort":[
    {"key":{"order":"asc|desc"}}, - 参数格式：排序， key要排序的字段，order固定，取值asc或desc，不需要排序，传""
    {"key":{"order":"asc|desc"}}
    ]
    }
     * @return
     */
    public SearchSourceBuilder getQueryBuilder(String nestedPath, String jsonData) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //什么都不传的情况下，构造查询所有的语句
        if(StringUtils.isEmpty(jsonData)){
            MatchAllQueryBuilder allQueryBuilder = QueryBuilders.matchAllQuery();
            return searchSourceBuilder.query(allQueryBuilder);
        }
        JSONObject json = JSONObject.parseObject(jsonData);
        List<Map<String, Object>> filter = (List)json.getJSONArray("filter");
        int page = json.getIntValue("page") == 0 ? 1:json.getIntValue("page"); //从第一页开始
        int size = json.getIntValue("size") == 0 ? 1:json.getIntValue("size"); //默认值为1，最少获取一条记录
        JSONArray sort = json.getJSONArray("sort");
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder = getBoolQueryBuilder(nestedPath,jsonData,false);//非嵌套的数据查询不需要nested
        searchSourceBuilder.from((page -1)*size);
        searchSourceBuilder.size(size);
        //排序
        if(!CollectionUtils.isEmpty(sort)){
            for(Object obj:sort){
                JSONObject object = JSONObject.parseObject(obj.toString());
                FieldSortBuilder fieldSortBuilder = null;
                for(String key:object.keySet()){
                    if(!CollectionUtils.isEmpty(fieldsMap.get(nestedPath)) && fieldsMap.get(nestedPath).contains(key)){
                        fieldSortBuilder = new FieldSortBuilder("data." + key);
                    }else{
                        fieldSortBuilder = new FieldSortBuilder(key);
                    }
                    JSONObject sortValue = object.getJSONObject(key);
                    if(StringUtils.equalsIgnoreCase(SortOrder.ASC.toString(),sortValue.getString("order"))){
                        fieldSortBuilder.order(SortOrder.ASC);
                    }else if(StringUtils.equalsIgnoreCase(SortOrder.DESC.toString(),sortValue.getString("order"))){
                        fieldSortBuilder.order(SortOrder.DESC);
                    }
                    fieldSortBuilder.setNestedPath("data");
                    searchSourceBuilder.sort(fieldSortBuilder);
                }
            }
        }
        if(StringUtils.isNotEmpty(nestedPath)){
            NestedQueryBuilder nestedQueryBuilder = getNestedBuilder(nestedPath,jsonData);//嵌套的数据查询
            QueryFilterBuilder filterBuilder = QueryBuilders.queryFilter(nestedQueryBuilder);
            QueryBuilder filteredQueryBuilder = QueryBuilders.filteredQuery(boolQueryBuilder,filterBuilder);
            searchSourceBuilder.query(filteredQueryBuilder);
        }else{
            searchSourceBuilder.query(boolQueryBuilder);
        }
        return searchSourceBuilder;
    }
    /**
     * 嵌套的查询query
     * @param nestedPath
     * @param queryCondition
     * @return
     */
    private NestedQueryBuilder getNestedBuilder(String nestedPath,String queryCondition){
        if(StringUtils.isEmpty(nestedPath)){
            return null;
        }
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder = getBoolQueryBuilder(nestedPath,queryCondition,true);
        NestedQueryBuilder nestedQueryBuilder = QueryBuilders.nestedQuery(nestedPath,boolQueryBuilder);
        return nestedQueryBuilder;
    }
    /**
     * 构造bool查询（里面有匹配，过滤，范围等）
     * @param nestedPath
     * @param queryCondition
     * @return
     */
    private BoolQueryBuilder getBoolQueryBuilder(String nestedPath,String queryCondition,Boolean isNested){
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        JSONObject jsonCondition = JSONObject.parseObject(queryCondition);
        List<Map<String, Object>> filter = (List)jsonCondition.getJSONArray("filter");
        for(Map<String, Object> param : filter) {
            String andOr = String.valueOf(param.get("andOr"));
            String condition = String.valueOf(param.get("condition"));
            String field = String.valueOf(param.get("field"));
            Object value = param.get("value");
            //如果传过来的字段为空则表示查询全部
            if(StringUtils.isEmpty(field)){
                MatchAllQueryBuilder matchQueryBuilder = QueryBuilders.matchAllQuery();
                boolQueryBuilder.must(matchQueryBuilder);
                return boolQueryBuilder;
            }
            if(!isNested){
                if(!CollectionUtils.isEmpty(fieldsMap.get(nestedPath)) && fieldsMap.get(nestedPath).contains(field)){
                    continue;
                }
            }else{
                if(!CollectionUtils.isEmpty(fieldsMap.get(nestedPath)) && !fieldsMap.get(nestedPath).contains(field)){
                    continue;
                }
                field = nestedPath + "." + field;
            }
            if("null".equals(condition)){
                MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery(field, value);
                if("null".equals(andOr)) {
                    boolQueryBuilder.must(matchQueryBuilder);
                }
            }else if(condition.equals("=")) {
                MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery(field, value);
                if("and".equals(andOr)) {
                    boolQueryBuilder.must(matchQueryBuilder);
                }else if("or".equals(andOr)) {
                    boolQueryBuilder.should(matchQueryBuilder);
                }
            }else if (condition.equals("?")) {
                QueryStringQueryBuilder queryStringQueryBuilder = QueryBuilders.queryStringQuery(field + ":" + value);
                if("and".equals(andOr)) {
                    boolQueryBuilder.must(queryStringQueryBuilder);
                }else if("or".equals(andOr)) {
                    boolQueryBuilder.should(queryStringQueryBuilder);
                }
            }else {
                RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(field);
                if(field.endsWith("Date")) {
                    rangeQueryBuilder.format("yyyy-MM-dd HH:mm:ss");
                }
                if(condition.equals(">")) {
                    rangeQueryBuilder.gt(value);
                }else if(condition.equals(">=")) {
                    rangeQueryBuilder.gte(value);
                }else if(condition.equals("<=")) {
                    rangeQueryBuilder.lte(value);
                }else if(condition.equals("<")) {
                    rangeQueryBuilder.lt(value);
                }
                if("and".equals(andOr)) {
                    boolQueryBuilder.must(rangeQueryBuilder);
                }else if("or".equals(andOr)) {
                    boolQueryBuilder.should(rangeQueryBuilder);
                }
            }
        }
        return boolQueryBuilder;
    }
    /**
     * 构造查询所有的语句
     * @return
     */
    public SearchSourceBuilder getQueryAllBuilder(){
        return getQueryBuilder("","");
    }
    public static void main(String args[]) {
//        elasticSearchQueryGenerator.init();
       /* String str = "{\n" +
                "\t\"filter\": [{\n" +
                "\t\t\"andOr\": \"and\",\n" +
                "\t\t\"condition\": \"=\",\n" +
                "\t\t\"field\": \"\",\n" +
                "\t\t\"value\": \"\"\n" +
                "\t}]\n" +
                "}";
        getQueryBuilder("",str);*/
    }
}

svr/svr-iot-sunruo/src/main/java/com/yihu/iot/service/common/MyJdbcTemplate.java

@@ -0,0 +1,57 @@
package com.yihu.iot.service.common;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.stereotype.Component;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
 * @author yeshijie on 2018/1/16.
 */
@Component
public class MyJdbcTemplate{
    @Autowired
    private JdbcTemplate jdbcTemplate;
    /**
     * jdbc查询返回json
     * @param sql
     * @param args
     * @return
     * @throws DataAccessException
     */
    public List<JSONObject> queryJson(String sql, Object[] args) throws DataAccessException {
        return jdbcTemplate.query(sql, args, new ResultSetExtractor<List<JSONObject>>() {
            @Override
            public List<JSONObject> extractData(ResultSet resultSet) throws SQLException, DataAccessException {
                ResultSetMetaData rsd = resultSet.getMetaData();
                int clength = rsd.getColumnCount();
                List<JSONObject> li = new ArrayList<JSONObject>();
                String columnName;
                try {
                    while (resultSet.next()) {
                        JSONObject jo = new JSONObject();
                        for (int i = 0; i < clength; i++) {
                            columnName = rsd.getColumnLabel(i + 1);
                            jo.put(columnName, resultSet.getObject(i + 1));
                        }
                        li.add(jo);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return li;
            }
        });
    }
}

svr/svr-iot-sunruo/src/main/resources/application.yml

@@ -0,0 +1,180 @@
##如果有配置服务的话，远程服务器和本地服务器配置不一致的情况下，优先远程的为主  git上 svr-base ->  git application ->本地 appliction ->本地 bootstarp
server:
  port: 10060
spring:
  application:
    name:  svr-iot-sr  #注册到发现服务的id 如果id一样 eurika会自动做负载
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    max-active: 50
    max-idle: 50 #最大空闲连接
    min-idle: 10 #最小空闲连接
    validation-query-timeout: 20
    log-validation-errors: true
    validation-interval: 60000 #避免过度验证，保证验证不超过这个频率——以毫秒为单位。如果一个连接应该被验证，但上次验证未达到指定间隔，将不再次验证。
    validation-query: SELECT 1 #SQL 查询， 用来验证从连接池取出的连接， 在将连接返回给调用者之前。 如果指定， 则查询必须是一个SQL SELECT 并且必须返回至少一行记录
    test-on-borrow: true #指明是否在从池中取出连接前进行检验， 如果检验失败， 则从池中去除连接并尝试取出另一个。注意： 设置为true 后如果要生效，validationQuery 参数必须设置为非空字符串
    test-on-return: true #指明是否在归还到池中前进行检验 注意： 设置为true 后如果要生效validationQuery 参数必须设置为非空字符串
    idle-timeout: 30000
    connection-test-query: SELECT 1
    num-tests-per-eviction-run: 50 #在每次空闲连接回收器线程(如果有)运行时检查的连接数量，最好和maxActive
    test-while-idle: true #指明连接是否被空闲连接回收器(如果有)进行检验，如果检测失败，则连接将被从池中去除
    min-evictable-idle-time-millis: 3600000 #连接池中连接，在时间段内一直空闲，被逐出连接池的时间(1000*60*60)，以毫秒为单位
    time-between-eviction-runs-millis: 300000 #在空闲连接回收器线程运行期间休眠的时间值,以毫秒为单位，一般比minEvictableIdleTimeMillis小
  data:
    elasticsearch: #ElasticsearchProperties
      cluster-name: jkzl #默认即为elasticsearch  集群名
      local: false #是否本地连接
      properties: # Additional properties used to configure the client.
        enable: true
  # JEST (Elasticsearch HTTP client) (JestProperties)
  elasticsearch:
    jest:
#      uris: http://172.19.103.68:9200
      connection-timeout: 60000 # Connection timeout in milliseconds.
      multi-threaded: true # Enable connection requests from multiple execution threads.
#      username: # Login user.
#      password: # Login password.
#      proxy.port:  # Proxy port the HTTP client should use.
#      proxy.host:  # Proxy host the HTTP client should use.
#hibernate 配置
hibernate:
  dialect: org.hibernate.dialect.MySQL5Dialect
  show_sql: true
  ejb:
    naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy
fast-dfs:
  connect-timeout: 2 #链接超时时间
  network-timeout: 30
  charset: ISO8859-1 #编码
  http:
    tracker-http-port: 80
    anti-steal-token: no
    secret-key: FastDFS1234567890
  pool: #连接池大小
    init-size: 5
    max-size: 20
    wait-time: 500
---
spring:
  profiles: xmprod
  datasource:
    url: jdbc:mysql://59.61.92.90:9207/xmiot?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false
    username: wlyy
    password: jkzlehr@123
  elasticsearch:
    cluster-name: jkzl #默认即为elasticsearch  集群名
    cluster-nodes: 59.61.92.90:9209,59.61.92.90:9211 #配置es节点信息，逗号分隔，如果没有指定，则启动ClientNode
    jest:
      uris: http://59.61.92.90:9208,http://59.61.92.90:9210
  wlyy:
    url: http://www.xmtyw.cn/wlyy/
#fast-dfs:
  #tracker-server: 10.95.22.139:22122 #服务器地址
#fastDFS:
  #fastdfs_file_url: http://www.xmtyw.cn/
---
spring:
  profiles: jwdev
  datasource:
    url: jdbc:mysql://172.19.103.77:3306/xmiot?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
    username: root
    password: 123456
  elasticsearch:
    cluster-name: jkzl #默认即为elasticsearch  集群名
    cluster-nodes: 172.19.103.45:9300,172.19.103.68:9300 #配置es节点信息，逗号分隔，如果没有指定，则启动ClientNode
    jest:
      uris: http://172.19.103.45:9200,http://172.19.103.68:9200
  wlyy:
    url: http://www.xmtyw.cn/wlyy/
fast-dfs:
  tracker-server: 172.19.103.54:22122 #服务器地址
fastDFS:
  fastdfs_file_url: http://172.19.103.54:80/
---
spring:
  profiles: dev
  datasource:
    url: jdbc:mysql://172.26.0.204:3306/xmiot?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
    username: ssgg
    password: ssgg@jkzl2019
  elasticsearch:
    cluster-name: jkzl #默认即为elasticsearch  集群名
    cluster-nodes: 172.26.0.203:9300 #配置es节点信息，逗号分隔，如果没有指定，则启动ClientNode
    jest:
      uris: http://172.26.0.202:9200
  wlyy:
    url: http://www.xmtyw.cn
fast-dfs:
  tracker-server: 172.26.0.200:22122 #服务器地址
fastDFS:
  fastdfs_file_url: http://172.26.0.200:22122/
---
spring:
  profiles: jwtest
  datasource:
    url: jdbc:mysql://172.19.103.77:3306/xmiot?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
    username: root
    password: 123456
  elasticsearch:
    cluster-name: jkzl #默认即为elasticsearch  集群名
    cluster-nodes: 172.19.103.45:9300,172.19.103.68:9300 #配置es节点信息，逗号分隔，如果没有指定，则启动ClientNode
    jest:
      uris: http://172.19.103.45:9200,http://172.19.103.68:9200
  wlyy:
    url: http://www.xmtyw.cn/wlyy/
fast-dfs:
  tracker-server: 172.19.103.54:22122 #服务器地址
fastDFS:
  fastdfs_file_url: http://172.19.103.54:80/
---
spring:
  profiles: jwprod
  datasource:
    #url: jdbc:mysql://59.61.92.90:9207/xmiot?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
    url: jdbc:mysql://59.61.92.90:9207/xmiot?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false
    username: wlyy
    password: jkzlehr@123
  elasticsearch:
    cluster-name: jkzl #默认即为elasticsearch  集群名
    cluster-nodes: 59.61.92.90:9209,59.61.92.90:9211 #配置es节点信息，逗号分隔，如果没有指定，则启动ClientNode
    jest:
      uris: http://59.61.92.90:9208,http://59.61.92.90:9210
  wlyy:
    url: http://www.xmtyw.cn/wlyy/
#fast-dfs:
  #tracker-server: 10.95.22.139:22122 #服务器地址
#fastDFS:
  #fastdfs_file_url: http://www.xmtyw.cn/
---
spring:
  profiles: prod
  datasource:
    url: jdbc:mysql://59.61.92.90:9207/xmiot?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false
    username: wlyy
    password: jkzlehr@123
  elasticsearch:
    cluster-name: jkzl #默认即为elasticsearch  集群名
    cluster-nodes: 59.61.92.90:9209,59.61.92.90:9211 #配置es节点信息，逗号分隔，如果没有指定，则启动ClientNode
    jest:
      uris: http://59.61.92.90:9208,http://59.61.92.90:9210
  wlyy:
    url: http://www.xmtyw.cn/wlyy/
#fast-dfs:
  #tracker-server: 10.95.22.139:22122 #服务器地址
#fastDFS:
  #fastdfs_file_url: http://www.xmtyw.cn/

svr/svr-iot-sunruo/src/main/resources/banner.txt

@@ -0,0 +1,5 @@
  ____   __     __  ____            ___    ___    _____           ____    ____
 / ___|  \ \   / / |  _ \          |_ _|  / _ \  |_   _|         / ___|  |  _ \
 \___ \   \ \ / /  | |_) |  _____   | |  | | | |   | |    _____  \___ \  | |_) |
  ___) |   \ V /   |  _ <  |_____|  | |  | |_| |   | |   |_____|  ___) | |  _ <
 |____/     \_/    |_| \_\         |___|  \___/    |_|           |____/  |_| \_\

svr/svr-iot-sunruo/src/main/resources/bootstrap.yml

@@ -0,0 +1,32 @@
spring:
  application:
    name: svr-iot-sr
#  cloud:
                                               #    config:
                                               #      failFast: false
                                               #      username: jw
                                               #      password: jkzl
                                               #
                                               #---
                                               #spring:
                                               #  profiles: jwdev
                                               #  cloud:
                                               #    config:
                                               #      uri: ${wlyy.spring.config.uri:http://172.17.110.212:1221}
                                               #      label: ${wlyy.spring.config.label:jwdev}
                                               #
                                               #---
                                               #spring:
                                               #  profiles: dev
                                               #  cloud:
                                               #    config:
                                               #      uri: ${wlyy.spring.config.uri:http://localhost:1221}
                                               #      label: ${wlyy.spring.config.label:dev}
                                               #
                                               #---
                                               #spring:
                                               #  profiles: jwtest
                                               #  cloud:
                                               #    config:
                                               #      uri: ${wlyy.spring.config.uri:http://172.17.110.212:1221}
                                               #      label: ${wlyy.spring.config.label:jwdev}

svr/svr-iot-sunruo/src/main/resources/core-site.xml

@@ -0,0 +1,163 @@
  <configuration>
    
    <property>
      <name>fs.defaultFS</name>
      <value>hdfs://dev</value>
    </property>
    
    <property>
      <name>fs.trash.interval</name>
      <value>360</value>
    </property>
    
    <property>
      <name>ha.failover-controller.active-standby-elector.zk.op.retries</name>
      <value>120</value>
    </property>
    
    <property>
      <name>ha.zookeeper.quorum</name>
      <value>node1.hde.h3c.com:2181,node2.hde.h3c.com:2181,node3.hde.h3c.com:2181</value>
    </property>
    
    <property>
      <name>hadoop.http.authentication.simple.anonymous.allowed</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hbase.groups</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hbase.hosts</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hcat.groups</name>
      <value>users</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hcat.hosts</name>
      <value>node2.hde.h3c.com</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hdfs.groups</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hdfs.hosts</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hive.groups</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hive.hosts</name>
      <value>node2.hde.h3c.com</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.HTTP.groups</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.HTTP.hosts</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hue.groups</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.hue.hosts</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.oozie.groups</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.proxyuser.oozie.hosts</name>
      <value>*</value>
    </property>
    
    <property>
      <name>hadoop.security.auth_to_local</name>
      <value>DEFAULT</value>
    </property>
    
    <property>
      <name>hadoop.security.authentication</name>
      <value>simple</value>
    </property>
    
    <property>
      <name>hadoop.security.authorization</name>
      <value>false</value>
    </property>
    
    <property>
      <name>hadoop.security.key.provider.path</name>
      <value></value>
    </property>
    
    <property>
      <name>io.compression.codecs</name>
      <value>org.apache.hadoop.io.compress.GzipCodec,org.apache.hadoop.io.compress.DefaultCodec,org.apache.hadoop.io.compress.SnappyCodec</value>
    </property>
    
    <property>
      <name>io.file.buffer.size</name>
      <value>131072</value>
    </property>
    
    <property>
      <name>io.serializations</name>
      <value>org.apache.hadoop.io.serializer.WritableSerialization</value>
    </property>
    
    <property>
      <name>ipc.client.connect.max.retries</name>
      <value>1</value><!--50-->
    </property>
    
    <property>
      <name>ipc.client.connection.maxidletime</name>
      <value>1000</value><!--30000-->
    </property>
    
    <property>
      <name>ipc.client.idlethreshold</name>
      <value>8000</value>
    </property>
    
    <property>
      <name>ipc.server.tcpnodelay</name>
      <value>true</value>
    </property>
    
    <property>
      <name>mapreduce.jobtracker.webinterface.trusted</name>
      <value>false</value>
    </property>
    
    <property>
      <name>net.topology.script.file.name</name>
      <value>/etc/hadoop/conf/topology_script.py</value>
    </property>
    
  </configuration>

svr/svr-iot-sunruo/src/main/resources/hbase-site.xml

@@ -0,0 +1,243 @@
  <configuration>
    
    <property>
      <name>dfs.domain.socket.path</name>
      <value>/var/lib/hadoop-hdfs/dn_socket</value>
    </property>
    
    <property>
      <name>hbase.bulkload.staging.dir</name>
      <value>/apps/hbase/staging</value>
    </property>
    
    <property>
      <name>hbase.client.keyvalue.maxsize</name>
      <value>1048576</value>
    </property>
    
    <property>
      <name>hbase.client.retries.number</name>
      <value>1</value><!--35-->
    </property>
    
    <property>
      <name>hbase.client.scanner.caching</name>
      <value>100</value>
    </property>
    
    <property>
      <name>hbase.cluster.distributed</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hbase.coprocessor.master.classes</name>
      <value>org.apache.hadoop.hbase.security.access.AccessController</value>
    </property>
    
    <property>
      <name>hbase.coprocessor.region.classes</name>
      <value>org.apache.hadoop.hbase.security.access.AccessController,org.apache.hadoop.hbase.security.access.SecureBulkLoadEndpoint</value>
    </property>
    
    <property>
      <name>hbase.coprocessor.regionserver.classes</name>
      <value>org.apache.hadoop.hbase.security.access.AccessController</value>
    </property>
    
    <property>
      <name>hbase.defaults.for.version.skip</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hbase.hregion.majorcompaction</name>
      <value>604800000</value>
    </property>
    
    <property>
      <name>hbase.hregion.majorcompaction.jitter</name>
      <value>0.50</value>
    </property>
    
    <property>
      <name>hbase.hregion.max.filesize</name>
      <value>10737418240</value>
    </property>
    
    <property>
      <name>hbase.hregion.memstore.block.multiplier</name>
      <value>4</value>
    </property>
    
    <property>
      <name>hbase.hregion.memstore.flush.size</name>
      <value>134217728</value>
    </property>
    
    <property>
      <name>hbase.hregion.memstore.mslab.enabled</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hbase.hstore.blockingStoreFiles</name>
      <value>10</value>
    </property>
    
    <property>
      <name>hbase.hstore.compaction.max</name>
      <value>10</value>
    </property>
    
    <property>
      <name>hbase.hstore.compactionThreshold</name>
      <value>3</value>
    </property>
    
    <property>
      <name>hbase.local.dir</name>
      <value>${hbase.tmp.dir}/local</value>
    </property>
    
    <property>
      <name>hbase.master.info.bindAddress</name>
      <value>0.0.0.0</value>
    </property>
    
    <property>
      <name>hbase.master.info.port</name>
      <value>16010</value>
    </property>
    
    <property>
      <name>hbase.master.port</name>
      <value>16000</value>
    </property>
    
    <property>
      <name>hbase.regionserver.global.memstore.size</name>
      <value>0.4</value>
    </property>
    
    <property>
      <name>hbase.regionserver.handler.count</name>
      <value>30</value>
    </property>
    
    <property>
      <name>hbase.regionserver.info.port</name>
      <value>16030</value>
    </property>
    
    <property>
      <name>hbase.regionserver.port</name>
      <value>16020</value>
    </property>
    
    <property>
      <name>hbase.regionserver.thrift.http</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hbase.regionserver.wal.codec</name>
      <value>org.apache.hadoop.hbase.regionserver.wal.WALCellCodec</value>
    </property>
    
    <property>
      <name>hbase.replication</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hbase.rootdir</name>
      <value>hdfs://dev/apps/hbase/data</value>
    </property>
    
    <property>
      <name>hbase.rpc.protection</name>
      <value>authentication</value>
    </property>
    
    <property>
      <name>hbase.rpc.timeout</name>
      <value>90000</value>
    </property>
    
    <property>
      <name>hbase.security.authentication</name>
      <value>simple</value>
    </property>
    
    <property>
      <name>hbase.security.authorization</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hbase.superuser</name>
      <value>hbase</value>
    </property>
    
    <property>
      <name>hbase.thrift.support.proxyuser</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hbase.tmp.dir</name>
      <value>/hadoop/hbase</value>
    </property>
    
    <property>
      <name>hbase.zookeeper.property.clientPort</name>
      <value>2181</value>
    </property>
    
    <property>
      <name>hbase.zookeeper.quorum</name>
      <value>node1.hde.h3c.com,node2.hde.h3c.com,node3.hde.h3c.com</value>
    </property>
    
    <property>
      <name>hbase.zookeeper.useMulti</name>
      <value>true</value>
    </property>
    
    <property>
      <name>hfile.block.cache.size</name>
      <value>0.40</value>
    </property>
    
    <property>
      <name>phoenix.query.timeoutMs</name>
      <value>60000</value>
    </property>
    
    <property>
      <name>replication.replicationsource.implementation</name>
      <value>com.ngdata.sep.impl.SepReplicationSource</value>
    </property>
    
    <property>
      <name>replication.source.nb.capacity</name>
      <value>1000</value>
    </property>
    
    <property>
      <name>replication.source.ratio</name>
      <value>1</value>
    </property>
    
    <property>
      <name>zookeeper.session.timeout</name>
      <value>90000</value>
    </property>
    
    <property>
      <name>zookeeper.znode.parent</name>
      <value>/hbase-unsecure</value>
    </property>
    
  </configuration>