清理scheduler目录

readme.MD

@@ -15,6 +15,7 @@ powerdesign:https://192.168.1.103:888/svn/outwindow/基础开发部/doc/i健康2
## 改造点说明
- dao、model下的jpa目录去除，我们只使用jpa的方式
- dao, model下的jpa目录去除，我们只使用jpa的方式
- util目录做了部分统一，未完全整理
- service和controller目录下新增special目录，表示特例（special case），将一些特殊的查询，如单病种等，
- scheduler清理任务及新增special目录

src/main/java/com/yihu/quota/scheduler/DiabetesCheckScheduler.java

@@ -1,436 +0,0 @@
package com.yihu.quota.scheduler;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.ehr.elasticsearch.ElasticSearchUtil;
import com.yihu.ehr.hbase.HBaseDao;
import com.yihu.ehr.profile.core.ResourceCore;
import com.yihu.ehr.solr.SolrUtil;
import com.yihu.ehr.util.datetime.DateUtil;
import com.yihu.quota.util.BasesicUtil;
import com.yihu.quota.vo.CheckInfoModel;
import com.yihu.quota.vo.DictModel;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.util.*;
/**
 * 糖尿病单病种  监测检验 数据统计
 */
@Component
public class DiabetesCheckScheduler {
    private static final Logger log = LoggerFactory.getLogger(DiabetesCheckScheduler.class);
    @Autowired
    private SolrUtil solrUtil;
    @Autowired
    private ElasticSearchUtil elasticSearchUtil;
    @Autowired
    private HBaseDao hbaseDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private ObjectMapper objectMapper;
    /**
     * 首先要有一个初始化过程
     * 每天2点 执行一次
     *
     * @throws Exception
     */
//	@Scheduled(cron = "0 30 17 * * ?")
    public void validatorIdentityScheduler() {
        try {
            String q2 = "EHR_000394:*糖耐量*2H血糖* OR EHR_000394:*糖耐量*空腹血糖* OR EHR_000394:*空腹葡萄糖* OR EHR_000394:*葡萄糖耐量试验*";//子项目中文名称
            String fq = ""; // 过滤条件
            String keyEventDate = "event_date";
            String keyArea = "EHR_001225";
            String keyAreaName = "EHR_001225_VALUE";
            String keyPatientName = "patient_name";
            String keyDemographicId = "demographic_id";//身份证
            String keyCardId = "card_id	";
            String keySex = "EHR_000019";//性别
            String keySexValue = "EHR_000019_VALUE";
            String keyAge = "EHR_000007";//出生日期 年龄
            String keyAddress = "EHR_001211"; //地址
            String keyDiseaseSymptom = "EHR_000112";//并发症  诊断名称(门诊)
            String keyDiseaseSymptom2 = "EHR_000295";//并发症  诊断名称（住院）
            String keysugarToleranceName = "EHR_000392";//  检验-项目结果 - 报告子项的LOINC编码  14995-5 糖耐量值  14771-0 空腹血糖
            String keysugarToleranceVal = "EHR_000387";//检验-项目结果 -  结果值  糖耐量值
            String keyChineseName = "EHR_000394";//子项目中文名称
            String keyWestMedicine = "EHR_000100";  //西药
            String keyChineseMedicine = "EHR_000131";//中药
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            BasesicUtil basesicUtil = new BasesicUtil();
            String initializeDate = "2018-04-26";// job初始化时间
            String executeInitDate = "2016-06-01";
            Date now = new Date();
            String nowDate = DateUtil.formatDate(now, DateUtil.DEFAULT_DATE_YMD_FORMAT);
            boolean flag = true;
            String startDate = "2015-01-01";
            String endDate = "2015-02-01";
            while (flag) {
                //  当前时间大于初始化时间，就所有数据初始化，每个月递增查询，当前时间小于于初始时间每天抽取
                if (basesicUtil.compareDate(initializeDate, nowDate) == -1) {
                    Date exeStartDate = DateUtil.parseDate(initializeDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(exeStartDate);
                    int day1 = calendar.get(Calendar.DAY_OF_YEAR);
                    Calendar endCalendar = Calendar.getInstance();
                    endCalendar.setTime(now);
                    int day2 = endCalendar.get(Calendar.DAY_OF_YEAR);
                    int num = day2 - day1;
                    //总院那边是一天采集24天的数据，所以初始化完后，每天采集15天的数据
                    Date executeStartDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * (num - 1));
                    Date executeEndDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * num);
                    startDate = DateUtil.formatDate(executeStartDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    endDate = DateUtil.formatDate(executeEndDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T23:59:59Z]";
                    flag = false;
                } else {
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T00:00:00Z]";
                    Date sDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    startDate = DateUtil.formatDate(sDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Date eDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    endDate = DateUtil.formatDate(eDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    if (basesicUtil.compareDate("2016-06-01", startDate) != 1) {//结束时间
                        fq = "event_date:[" + startDate + "T00:00:00Z TO 2016-06-01T00:00:00Z]";
                        flag = false;
                    }
                    System.out.println("startDate=" + startDate);
                }
                //找出糖尿病的就诊档案
                System.out.println("tangnai 开始查询 检验检测tangnai solr, fq = " + fq);
                List<String> subRrowKeyList = new ArrayList<>(); //细表rowkey
                subRrowKeyList = selectSubRowKey(ResourceCore.SubTable, q2, fq, 10000);
                System.out.println("tangnai 检验检测查询结果条数 tangnai count ：" + subRrowKeyList.size());
                if (subRrowKeyList != null && subRrowKeyList.size() > 0) {
                    //糖尿病数据 Start
                    for (String subRowkey : subRrowKeyList) {//循环糖尿病 找到主表就诊人信息
                        try {
                            //查询此次就诊记录的相关数据 保存到检测记录中
                            String name = "";
                            String demographicId = "";
                            String cardId = "";
                            Integer sex = 0;
                            String sexName = "";
                            String diseaseType = "";
                            String diseaseTypeName = "";
                            String birthday = "";
                            int birthYear = 0;
                            Date eventDate = null;
                            Map<String, Object> subMap = hbaseDao.getResultMap(ResourceCore.SubTable, subRowkey);
                            if (subMap != null) {
                                String diseaseName = "";
                                if (subMap.get(keyDiseaseSymptom) != null) {
                                    diseaseName = subMap.get(keyDiseaseSymptom).toString();
                                } else if (subMap.get(keyDiseaseSymptom2) != null) {
                                    diseaseName = subMap.get(keyDiseaseSymptom2).toString();
                                }
                                if (StringUtils.isNotEmpty(diseaseName)) {
                                    if (diseaseName.contains("1型")) {
                                        diseaseType = "1";
                                        diseaseTypeName = "I型糖尿病";
                                    } else if (diseaseName.contains("2型")) {
                                        diseaseType = "2";
                                        diseaseTypeName = "II型糖尿病";
                                    } else if (diseaseName.contains("妊娠")) {
                                        diseaseType = "3";
                                        diseaseTypeName = "妊娠糖尿病";
                                    } else {
                                        diseaseType = "4";
                                        diseaseTypeName = "其他糖尿病";
                                    }
                                }
                            }
                            String mainRowkey = subRowkey.substring(0, subRowkey.indexOf("$"));
                            Map<String, Object> map = hbaseDao.getResultMap(ResourceCore.MasterTable, mainRowkey);
                            if (map != null) {
                                if (map.get(keyEventDate) != null) {
                                    try {
                                        eventDate = DateUtil.formatCharDate(map.get(keyEventDate).toString(), DateUtil.DATE_WORLD_FORMAT);
                                        eventDate = DateUtils.addHours(eventDate, 8);
                                    } catch (Exception e) {
                                        throw new Exception("就诊时间数据有误！" + map.get(keyEventDate));
                                    }
                                }
                                if (map.get(keyAge) != null) {
                                    if (map.get(keyAge).toString().length() > 10) {
                                        try {
                                            birthday = map.get(keyAge).toString().substring(0, 10);
                                            birthYear = Integer.valueOf(map.get(keyAge).toString().substring(0, 4));
                                        } catch (Exception e) {
                                            throw new Exception("出生日期数据有误！" + map.get(keyAge));
                                        }
                                    }
                                }
                                if (map.get(keyDemographicId) != null) {
                                    demographicId = map.get(keyDemographicId).toString();
                                }
                                if (map.get(keyCardId) != null) {
                                    cardId = map.get(keyCardId).toString();
                                }
                                if (map.get(keySex) != null) {
                                    if (map.get(keySex).toString().contains("男")) {
                                        sex = 1;
                                        sexName = "男";
                                    } else if (map.get(keySex).toString().contains("女")) {
                                        sex = 2;
                                        sexName = "女";
                                    } else {
                                        try {
                                            sex = Integer.valueOf(map.get(keySex).toString());
                                            if (sex == 1) {
                                                sexName = "男";
                                            } else if (sex == 2) {
                                                sexName = "女";
                                            } else {
                                                if (map.get(keySexValue) != null) {
                                                    sexName = map.get(keySexValue).toString();
                                                } else {
                                                    sexName = "未知";
                                                }
                                            }
                                        } catch (Exception e) {
                                            throw new Exception("性别数据异常");
                                        }
                                    }
                                } else {
                                    sex = 0;
                                    sexName = "未知";
                                }
                                if (map.get(keyPatientName) != null) {
                                    name = map.get(keyPatientName).toString();
                                }
                            }
                            CheckInfoModel baseCheckInfo = new CheckInfoModel();
                            baseCheckInfo.setName(name);
                            baseCheckInfo.setDemographicId(demographicId);
                            baseCheckInfo.setCardId(cardId);
                            baseCheckInfo.setSex(sex);
                            baseCheckInfo.setSexName(sexName);
                            baseCheckInfo.setBirthday(birthday);
                            baseCheckInfo.setBirthYear(birthYear);
                            baseCheckInfo.setDiseaseType(diseaseType);
                            baseCheckInfo.setDiseaseTypeName(diseaseTypeName);
                            baseCheckInfo.setEventDate(eventDate);
                            Map<String, Object> submap = hbaseDao.getResultMap(ResourceCore.SubTable, subRowkey);
                            if (submap != null) {
                                //检查信息 姓名,身份证，就诊卡号,并发症，空腹血糖值，葡萄糖耐量值，用药名称，检查信息code （CH001 并发症,CH002 空腹血糖,CH003 葡萄糖耐量,CH004 用药名称）
                                boolean fast = false;
                                if (submap.get(keyChineseName) != null) {
                                    // "糖耐量(空腹血糖)" "葡萄糖耐量试验"
                                    String val = submap.get(keyChineseName).toString();
                                    fast = (val.contains("糖耐量") && val.contains("空腹血糖")) || val.equals("葡萄糖耐量试验") || val.equals("空腹葡萄糖");
                                }
                                if (fast && submap.get(keysugarToleranceVal) != null) {
                                    try {
                                        //7.8mmol/l 以下 2：7.8-11.1mmol/l  3:11.1 以上
                                        String fastname = "";
                                        String fastcode = "";
                                        double val = Double.valueOf(submap.get(keysugarToleranceVal).toString());
                                        if (val >= 4.4 && val < 6.1) {
                                            fastname = "4.4~6.1mmol/L";
                                            fastcode = "1";
                                        }
                                        if (val >= 6.1 && val < 7.0) {
                                            fastname = "6.1~7mmol/L";
                                            fastcode = "2";
                                        }
                                        if (val > 7.0) {
                                            fastname = "7.0mmol/L以上";
                                            fastcode = "3";
                                        }
                                        baseCheckInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                        baseCheckInfo.setFastingBloodGlucoseName(fastname);
                                        baseCheckInfo.setFastingBloodGlucoseCode(fastcode);
                                        baseCheckInfo.setCheckCode("CH002");
                                        //保存到ES库
                                        saveCheckInfo(baseCheckInfo);
                                    } catch (Exception e) {
                                        throw new Exception("空腹血糖值有误");
                                    }
                                }
                                boolean tolerance = false;
                                if (submap.get(keyChineseName) != null) {
                                    String val = submap.get(keyChineseName).toString();
                                    //	"糖耐量(2H血糖)";
                                    tolerance = val.contains("糖耐量") && val.contains("2H血糖");
                                }
                                //葡萄糖（口服75 g葡萄糖后2 h)
                                if (tolerance && submap.get(keysugarToleranceVal) != null) {
                                    try {
                                        //7.8mmol/l 以下 2：7.8-11.1mmol/l  3:11.1 以上
                                        String sugarTolename = "";
                                        String sugarToleCode = "";
                                        double val = Double.valueOf(submap.get(keysugarToleranceVal).toString());
                                        if (val < 7.8) {
                                            sugarTolename = "7.8 mmol/L以下";
                                            sugarToleCode = "1";
                                        }
                                        if (val >= 7.8 && val < 11.1) {
                                            sugarTolename = "7.8~11.1 mmol/L";
                                            sugarToleCode = "2";
                                        }
                                        if (val > 11.1) {
                                            sugarTolename = "11.1 mmol/L以上";
                                            sugarToleCode = "3";
                                        }
                                        baseCheckInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                        baseCheckInfo.setSugarToleranceName(sugarTolename);
                                        baseCheckInfo.setSugarToleranceCode(sugarToleCode);
                                        baseCheckInfo.setCheckCode("CH003");
                                        //保存到ES库
                                        saveCheckInfo(baseCheckInfo);
                                    } catch (Exception e) {
                                        throw new Exception("空腹血糖值有误");
                                    }
                                }
                            }
                        } catch (Exception e) {
                            throw new Exception("数据解析保存异常" + e.getMessage());
                        }
                    }
                    //糖尿病数据 检查数据 end
                }
            }
        } catch (Exception e) {
            e.getMessage();
        }
    }
    public void saveCheckInfo(CheckInfoModel checkInfo) throws Exception {
        try {
            String index = "singleDiseaseCheck";
            String type = "check_info";
            Map<String, Object> source = new HashMap<>();
            String jsonCheck = objectMapper.writeValueAsString(checkInfo);
            source = objectMapper.readValue(jsonCheck, Map.class);
            if (checkInfo.getCheckCode().equals("CH001") && checkInfo.getDemographicId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "demographicId", checkInfo.getDemographicId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else if (checkInfo.getCheckCode().equals("CH001") && checkInfo.getCardId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "cardId", checkInfo.getCardId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else {
                elasticSearchUtil.index(index, type, source);
            }
        } catch (Exception e) {
            new Exception("ElasticSearch 数据保存异常");
        }
    }
    public CheckInfoModel setCheckInfoModel(CheckInfoModel baseCheckInfo) {
        CheckInfoModel checkInfo = new CheckInfoModel();
        checkInfo.setSexName(baseCheckInfo.getSexName());
        checkInfo.setSex(baseCheckInfo.getSex());
        checkInfo.setDemographicId(baseCheckInfo.getDemographicId());
        checkInfo.setCardId(baseCheckInfo.getCardId());
        checkInfo.setName(baseCheckInfo.getName());
        checkInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
        return checkInfo;
    }
    //获取维度的字典项
    private Map<String, String> getdimensionDicMap(String dictSql) {
        BasesicUtil baseUtil = new BasesicUtil();
        Map<String, String> dimensionDicMap = new HashMap<>();
        List<DictModel> dictDatas = jdbcTemplate.query(dictSql, new BeanPropertyRowMapper(DictModel.class));
        for (DictModel dictModel : dictDatas) {
            String name = baseUtil.getFieldValueByName("name", dictModel);
            String val = baseUtil.getFieldValueByName("code", dictModel).toLowerCase();
            dimensionDicMap.put(val, name);
        }
        return dimensionDicMap;
    }
    //获取查询结果中的rowKey
    private List<String> selectSubRowKey(String core, String q, String fq, long count) throws Exception {
        List<String> data = new ArrayList<>();
        /***** Solr查询 ********/
        SolrDocumentList solrList = solrUtil.query(core, q, fq, null, 0, count);
        if (solrList != null && solrList.getNumFound() > 0) {
            for (SolrDocument doc : solrList) {
                String rowkey = String.valueOf(doc.getFieldValue("rowkey"));
                data.add(rowkey);
            }
        }
        return data;
    }
    //查询habase里面数据
    private List<Map<String, Object>> selectHbaseData(String table, List<String> list) throws Exception {
        List<Map<String, Object>> data = new ArrayList<>();
        /***** Hbase查询 ********/
        Result[] resultList = hbaseDao.getResultList(table, list, "", ""); //hbase结果集
        if (resultList != null && resultList.length > 0) {
            for (Result result : resultList) {
                Map<String, Object> obj = resultToMap(result, "");
                if (obj != null) {
                    data.add(obj);
                }
            }
        }
        return data;
    }
    //查询habase里面数据 单条
    private Map<String, Object> selectSingleHbaseData(String table, String rowKey) throws Exception {
        return hbaseDao.getResultMap(table, rowKey);
    }
    /**
     * Result 转 JSON
     *
     * @return
     */
    private Map<String, Object> resultToMap(Result result, String fl) {
        String rowkey = Bytes.toString(result.getRow());
        if (rowkey != null && rowkey.length() > 0) {
            Map<String, Object> obj = new HashMap<>();
            obj.put("rowkey", rowkey);
            for (Cell cell : result.rawCells()) {
                String fieldName = Bytes.toString(CellUtil.cloneQualifier(cell));
                String fieldValue = Bytes.toString(CellUtil.cloneValue(cell));
                if (fl != null && !fl.equals("") && !fl.equals("*")) {
                    String[] fileds = fl.split(",");
                    for (String filed : fileds) {
                        if (filed.equals(fieldName)) {
                            obj.put(fieldName, fieldValue);
                            continue;
                        }
                    }
                } else {
                    obj.put(fieldName, fieldValue);
                }
            }
            return obj;
        } else {
            return null;
        }
    }
}

src/main/java/com/yihu/quota/scheduler/DiabetesMedicineScheduler.java

@@ -1,405 +0,0 @@
package com.yihu.quota.scheduler;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.ehr.elasticsearch.ElasticSearchUtil;
import com.yihu.ehr.hbase.HBaseDao;
import com.yihu.ehr.profile.core.ResourceCore;
import com.yihu.ehr.solr.SolrUtil;
import com.yihu.ehr.util.datetime.DateUtil;
import com.yihu.quota.util.BasesicUtil;
import com.yihu.quota.vo.CheckInfoModel;
import com.yihu.quota.vo.DictModel;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.util.*;
/**
 * 糖尿病单病种  药 数据统计
 */
@Component
public class DiabetesMedicineScheduler {
    private static final Logger log = LoggerFactory.getLogger(DiabetesMedicineScheduler.class);
    @Autowired
    private SolrUtil solrUtil;
    @Autowired
    private ElasticSearchUtil elasticSearchUtil;
    @Autowired
    private HBaseDao hbaseDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private ObjectMapper objectMapper;
    /**
     * 首先要有一个初始化过程
     * 每天2点 执行一次
     *
     * @throws Exception
     */
//	@Scheduled(cron = "0 30 18 * * ?")
    public void validatorIdentityScheduler() {
        try {
//			String q =  null; // 查询条件 health_problem:HP0047  HP0047 为糖尿病
            String q2 = "EHR_000295:*糖尿病* OR EHR_000112:*糖尿病*"; //门诊和住院 诊断名称
            String fq = ""; // 过滤条件
            String keyEventDate = "event_date";
            String keyArea = "EHR_001225";
            String keyAreaName = "EHR_001225_VALUE";
            String keyPatientName = "patient_name";
            String keyDemographicId = "demographic_id";//身份证
            String keyCardId = "card_id	";
            String keySex = "EHR_000019";//性别
            String keySexValue = "EHR_000019_VALUE";
            String keyAge = "EHR_000007";//出生日期 年龄
            String keyAddress = "EHR_001211"; //地址
            String keyDiseaseSymptom = "EHR_000112";//并发症  诊断名称(门诊)
            String keyDiseaseSymptom2 = "EHR_000295";//并发症  诊断名称（住院）
            String keysugarToleranceName = "EHR_000392";//  检验-项目结果 - 报告子项的LOINC编码  14995-5 糖耐量值  14771-0 空腹血糖
            String keysugarToleranceVal = "EHR_000387";//检验-项目结果 -  结果值  糖耐量值
            String keyChineseName = "EHR_000394";//子项目中文名称
//			String keyEnglishName = "EHR_000393";//子项目英文名称
            String keyWestMedicine = "EHR_000100";  //西药
            String keyChineseMedicine = "EHR_000131";//中药
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            BasesicUtil basesicUtil = new BasesicUtil();
            String initializeDate = "2018-04-26";// job初始化时间
            String executeInitDate = "2016-06-01";
            Date now = new Date();
            String nowDate = DateUtil.formatDate(now, DateUtil.DEFAULT_DATE_YMD_FORMAT);
            boolean flag = true;
            String startDate = "2015-01-01";
            String endDate = "2015-02-01";
            while (flag) {
                //  当前时间大于初始化时间，就所有数据初始化，每个月递增查询，当前时间小于于初始时间每天抽取
                if (basesicUtil.compareDate(initializeDate, nowDate) == -1) {
                    Date exeStartDate = DateUtil.parseDate(initializeDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(exeStartDate);
                    int day1 = calendar.get(Calendar.DAY_OF_YEAR);
                    Calendar endCalendar = Calendar.getInstance();
                    endCalendar.setTime(now);
                    int day2 = endCalendar.get(Calendar.DAY_OF_YEAR);
                    int num = day2 - day1;
                    //总院那边是一天采集24天的数据，所以初始化完后，每天采集15天的数据
                    Date executeStartDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * (num - 1));
                    Date executeEndDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * num);
                    startDate = DateUtil.formatDate(executeStartDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    endDate = DateUtil.formatDate(executeEndDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T23:59:59Z]";
                    flag = false;
                } else {
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T00:00:00Z]";
                    Date sDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    startDate = DateUtil.formatDate(sDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Date eDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    endDate = DateUtil.formatDate(eDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    if (basesicUtil.compareDate("2016-06-01", startDate) != 1) {//结束时间
                        fq = "event_date:[" + startDate + "T00:00:00Z TO 2016-06-01T00:00:00Z]";
                        flag = false;
                    }
                    System.out.println("medicine startDate=" + startDate);
                }
                //找出糖尿病的就诊档案
                List<String> subRrowKeyList = new ArrayList<>(); //细表rowkey
                subRrowKeyList = selectSubRowKey(ResourceCore.SubTable, q2, fq, 10000);
                System.out.println("medicine 药物开始查询medicine solr, fq = " + fq);
                System.out.println("medicine subRrowKeyList, size = " + subRrowKeyList.size());
                if (subRrowKeyList != null && subRrowKeyList.size() > 0) {
                    //糖尿病数据 Start
                    for (String subRowkey : subRrowKeyList) {//循环糖尿病 找到主表就诊人信息
                        try {
                            String mainRowkey = subRowkey.substring(0, subRowkey.indexOf("$"));
                            //查询此次就诊记录的相关数据 保存到检测记录中
                            String name = "";
                            String demographicId = "";
                            String cardId = "";
                            Integer sex = 0;
                            String sexName = "";
                            String symptomName = "";
                            String diseaseType = "";
                            String diseaseTypeName = "";
                            String birthday = "";
                            int birthYear = 0;
                            Date eventDate = null;
                            Map<String, Object> subMap = hbaseDao.getResultMap(ResourceCore.SubTable, subRowkey);
                            if (subMap != null) {
                                String diseaseName = "";
                                if (subMap.get(keyDiseaseSymptom) != null) {
                                    diseaseName = subMap.get(keyDiseaseSymptom).toString();
                                } else if (subMap.get(keyDiseaseSymptom2) != null) {
                                    diseaseName = subMap.get(keyDiseaseSymptom2).toString();
                                }
                                if (StringUtils.isNotEmpty(diseaseName)) {
                                    if (diseaseName.contains("并发症")) {
                                        symptomName = diseaseName;
                                    }
                                    if (diseaseName.contains("1型")) {
                                        diseaseType = "1";
                                        diseaseTypeName = "I型糖尿病";
                                    } else if (diseaseName.contains("2型")) {
                                        diseaseType = "2";
                                        diseaseTypeName = "II型糖尿病";
                                    } else if (diseaseName.contains("妊娠")) {
                                        diseaseType = "3";
                                        diseaseTypeName = "妊娠糖尿病";
                                    } else {
                                        diseaseType = "4";
                                        diseaseTypeName = "其他糖尿病";
                                    }
                                }
                            }
                            Map<String, Object> map = hbaseDao.getResultMap(ResourceCore.MasterTable, mainRowkey);
                            if (map != null) {
                                if (map.get(keyEventDate) != null) {
                                    try {
                                        eventDate = DateUtil.formatCharDate(map.get(keyEventDate).toString(), DateUtil.DATE_WORLD_FORMAT);
                                        eventDate = DateUtils.addHours(eventDate, 8);
                                    } catch (Exception e) {
                                        throw new Exception("就诊时间数据有误！" + map.get(keyEventDate));
                                    }
                                }
                                if (map.get(keyAge) != null) {
                                    if (map.get(keyAge).toString().length() > 10) {
                                        try {
                                            birthday = map.get(keyAge).toString().substring(0, 10);
                                            birthYear = Integer.valueOf(map.get(keyAge).toString().substring(0, 4));
                                        } catch (Exception e) {
                                            throw new Exception("出生日期数据有误！" + map.get(keyAge));
                                        }
                                    }
                                }
                                if (map.get(keyDemographicId) != null) {
                                    demographicId = map.get(keyDemographicId).toString();
                                }
                                if (map.get(keyCardId) != null) {
                                    cardId = map.get(keyCardId).toString();
                                }
                                if (map.get(keySex) != null) {
                                    if (map.get(keySex).toString().contains("男")) {
                                        sex = 1;
                                        sexName = "男";
                                    } else if (map.get(keySex).toString().contains("女")) {
                                        sex = 2;
                                        sexName = "女";
                                    } else {
                                        try {
                                            sex = Integer.valueOf(map.get(keySex).toString());
                                            if (sex == 1) {
                                                sexName = "男";
                                            } else if (sex == 2) {
                                                sexName = "女";
                                            } else {
                                                if (map.get(keySexValue) != null) {
                                                    sexName = map.get(keySexValue).toString();
                                                } else {
                                                    sexName = "未知";
                                                }
                                            }
                                        } catch (Exception e) {
                                            throw new Exception("性别数据异常");
                                        }
                                    }
                                } else {
                                    sex = 0;
                                    sexName = "未知";
                                }
                                if (map.get(keyPatientName) != null) {
                                    name = map.get(keyPatientName).toString();
                                }
                            }
                            fq = "profile_id:" + mainRowkey + "* AND EHR_000131:*";
                            //查询主表对应的细表的数据 循环解析
                            List<String> subRrowKeyList2 = selectSubRowKey(ResourceCore.SubTable, null, fq, 10000);
                            System.out.println("meidcine 药物 查询结果条数：" + subRrowKeyList2.size());
                            //细表解析保存 start
                            if (subRrowKeyList2 != null && subRrowKeyList2.size() > 0) {
                                List<Map<String, Object>> subhbaseDataList = selectHbaseData(ResourceCore.SubTable, subRrowKeyList2);
                                if (subhbaseDataList != null && subhbaseDataList.size() > 0) {
                                    for (Map<String, Object> submap : subhbaseDataList) {
                                        CheckInfoModel baseCheckInfo = new CheckInfoModel();
                                        baseCheckInfo.setName(name);
                                        baseCheckInfo.setDemographicId(demographicId);
                                        baseCheckInfo.setCardId(cardId);
                                        baseCheckInfo.setSex(sex);
                                        baseCheckInfo.setSexName(sexName);
                                        baseCheckInfo.setBirthday(birthday);
                                        baseCheckInfo.setBirthYear(birthYear);
                                        baseCheckInfo.setDiseaseType(diseaseType);
                                        baseCheckInfo.setDiseaseTypeName(diseaseTypeName);
                                        baseCheckInfo.setSymptomName(symptomName);
                                        baseCheckInfo.setEventDate(eventDate);
                                        if (submap.get(keyWestMedicine) != null) {
                                            baseCheckInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                            baseCheckInfo.setCheckCode("CH004");
                                            baseCheckInfo.setMedicineName(submap.get(keyWestMedicine).toString());
                                            //保存到ES库
                                            saveCheckInfo(baseCheckInfo);
                                        }
                                        if (submap.get(keyChineseMedicine) != null) {
                                            baseCheckInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                            baseCheckInfo.setCheckCode("CH004");
                                            baseCheckInfo.setMedicineName(submap.get(keyChineseMedicine).toString());
                                            //保存到ES库
                                            saveCheckInfo(baseCheckInfo);
                                        }
                                    }
                                }
                            }
                            //细表解析保存 end
                        } catch (Exception e) {
                            throw new Exception("数据解析保存异常" + e.getMessage());
                        }
                    }
                    //糖尿病数据 end
                }
            }
        } catch (Exception e) {
            e.getMessage();
        }
    }
    public void saveCheckInfo(CheckInfoModel checkInfo) throws Exception {
        try {
            String index = "singleDiseaseCheck";
            String type = "check_info";
            Map<String, Object> source = new HashMap<>();
            String jsonCheck = objectMapper.writeValueAsString(checkInfo);
            source = objectMapper.readValue(jsonCheck, Map.class);
            if (checkInfo.getCheckCode().equals("CH001") && checkInfo.getDemographicId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "demographicId", checkInfo.getDemographicId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else if (checkInfo.getCheckCode().equals("CH001") && checkInfo.getCardId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "cardId", checkInfo.getCardId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else {
                elasticSearchUtil.index(index, type, source);
            }
        } catch (Exception e) {
            new Exception("ElasticSearch 数据保存异常");
        }
    }
    public CheckInfoModel setCheckInfoModel(CheckInfoModel baseCheckInfo) {
        CheckInfoModel checkInfo = new CheckInfoModel();
        checkInfo.setSexName(baseCheckInfo.getSexName());
        checkInfo.setSex(baseCheckInfo.getSex());
        checkInfo.setDemographicId(baseCheckInfo.getDemographicId());
        checkInfo.setCardId(baseCheckInfo.getCardId());
        checkInfo.setName(baseCheckInfo.getName());
        checkInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
        checkInfo.setEventDate(baseCheckInfo.getEventDate());
        checkInfo.setDiseaseTypeName(baseCheckInfo.getDiseaseTypeName());
        checkInfo.setDiseaseType(baseCheckInfo.getDiseaseType());
        checkInfo.setBirthday(baseCheckInfo.getBirthday());
        checkInfo.setBirthYear(baseCheckInfo.getBirthYear());
        return checkInfo;
    }
    //获取维度的字典项
    private Map<String, String> getdimensionDicMap(String dictSql) {
        BasesicUtil baseUtil = new BasesicUtil();
        Map<String, String> dimensionDicMap = new HashMap<>();
        List<DictModel> dictDatas = jdbcTemplate.query(dictSql, new BeanPropertyRowMapper(DictModel.class));
        for (DictModel dictModel : dictDatas) {
            String name = baseUtil.getFieldValueByName("name", dictModel);
            String val = baseUtil.getFieldValueByName("code", dictModel).toLowerCase();
            dimensionDicMap.put(val, name);
        }
        return dimensionDicMap;
    }
    //获取查询结果中的rowKey
    private List<String> selectSubRowKey(String core, String q, String fq, long count) throws Exception {
        List<String> data = new ArrayList<>();
        /***** Solr查询 ********/
        SolrDocumentList solrList = solrUtil.query(core, q, fq, null, 1, count);
        if (solrList != null && solrList.getNumFound() > 0) {
            for (SolrDocument doc : solrList) {
                String rowkey = String.valueOf(doc.getFieldValue("rowkey"));
                data.add(rowkey);
            }
        }
        return data;
    }
    //查询habase里面数据
    private List<Map<String, Object>> selectHbaseData(String table, List<String> list) throws Exception {
        List<Map<String, Object>> data = new ArrayList<>();
        /***** Hbase查询 ********/
        Result[] resultList = hbaseDao.getResultList(table, list, "", ""); //hbase结果集
        if (resultList != null && resultList.length > 0) {
            for (Result result : resultList) {
                Map<String, Object> obj = resultToMap(result, "");
                if (obj != null) {
                    data.add(obj);
                }
            }
        }
        return data;
    }
    //查询habase里面数据 单条
    private Map<String, Object> selectSingleHbaseData(String table, String rowKey) throws Exception {
        return hbaseDao.getResultMap(table, rowKey);
    }
    /**
     * Result 转 JSON
     *
     * @return
     */
    private Map<String, Object> resultToMap(Result result, String fl) {
        String rowkey = Bytes.toString(result.getRow());
        if (rowkey != null && rowkey.length() > 0) {
            Map<String, Object> obj = new HashMap<>();
            obj.put("rowkey", rowkey);
            for (Cell cell : result.rawCells()) {
                String fieldName = Bytes.toString(CellUtil.cloneQualifier(cell));
                String fieldValue = Bytes.toString(CellUtil.cloneValue(cell));
                if (fl != null && !fl.equals("") && !fl.equals("*")) {
                    String[] fileds = fl.split(",");
                    for (String filed : fileds) {
                        if (filed.equals(fieldName)) {
                            obj.put(fieldName, fieldValue);
                            continue;
                        }
                    }
                } else {
                    obj.put(fieldName, fieldValue);
                }
            }
            return obj;
        } else {
            return null;
        }
    }
}

src/main/java/com/yihu/quota/scheduler/DiabetesScheduler.java

@@ -1,397 +0,0 @@
package com.yihu.quota.scheduler;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.ehr.elasticsearch.ElasticSearchUtil;
import com.yihu.ehr.hbase.HBaseDao;
import com.yihu.ehr.profile.core.ResourceCore;
import com.yihu.ehr.solr.SolrUtil;
import com.yihu.ehr.util.datetime.DateUtil;
import com.yihu.quota.etl.extract.ExtractUtil;
import com.yihu.quota.util.BasesicUtil;
import com.yihu.quota.util.LatitudeUtils;
import com.yihu.quota.vo.CheckInfoModel;
import com.yihu.quota.vo.DictModel;
import com.yihu.quota.vo.PersonalInfoModel;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.util.*;
/**
 * 糖尿病单病种 分析 数据统计
 */
@Component
public class DiabetesScheduler {
    private static final Logger log = LoggerFactory.getLogger(DiabetesScheduler.class);
    @Autowired
    private SolrUtil solrUtil;
    @Autowired
    private ExtractUtil extractUtil;
    @Autowired
    private ElasticSearchUtil elasticSearchUtil;
    @Autowired
    private HBaseDao hbaseDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private ObjectMapper objectMapper;
    /**
     * 首先要有一个初始化过程
     * 每天2点 执行一次
     *
     * @throws Exception
     */
//	@Scheduled(cron = "0 40 17 * * ?")
    public void validatorIdentityScheduler() {
        try {
//			String q =  null; // 查询条件 health_problem:HP0047  HP0047 为糖尿病
            String q2 = "EHR_000295:*糖尿病* OR EHR_000112:*糖尿病*";
//			String keyDiseaseNameH = "EHR_000295";//诊断名字（住院） *糖尿病*
//			String keyDiseaseNameZ = "EHR_000112";//诊断名字（门诊）*糖尿病*
            String fq = ""; // 过滤条件
            String keyEventDate = "event_date";
            String keyArea = "EHR_001225";  //行政区划代码
            String keyAreaName = "EHR_001225_VALUE";
            String keyPatientName = "patient_name";
            String keyDemographicId = "demographic_id";//身份证
            String keyCardId = "card_id	";
//			String keyHealthProblem = "health_problem";
            String keySex = "EHR_000019";//性别
            String keySexValue = "EHR_000019_VALUE";
            String keyAge = "EHR_000007";//出生日期 年龄
            String keyAddress = "EHR_001211"; //地址
//			String keyDiseaseType = "EHR_003810";//EHR_003810 诊断代码
            String keyDiseaseSymptom = "EHR_000112";//并发症  诊断名称(门诊)
            String keyDiseaseSymptom2 = "EHR_000295";//并发症  诊断名称（住院）
            String keysugarToleranceName = "EHR_000392";//  检验-项目结果 - 报告子项的LOINC编码  14995-5 糖耐量值  14771-0 空腹血糖
            String keysugarToleranceVal = "EHR_000387";//检验-项目结果 -  结果值  糖耐量值
            String keyChineseName = "EHR_000394";//子项目中文名称
//			String keyEnglishName = "EHR_000393";//子项目英文名称
            String keyWestMedicine = "EHR_000100";  //西药
            String keyChineseMedicine = "EHR_000131";//中药
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            BasesicUtil basesicUtil = new BasesicUtil();
            String initializeDate = "2018-04-26";// job初始化时间
            String executeInitDate = "2016-06-01";
            Date now = new Date();
            String nowDate = DateUtil.formatDate(now, DateUtil.DEFAULT_DATE_YMD_FORMAT);
            boolean flag = true;
            String startDate = "2015-01-01";
            String endDate = "2015-02-01";
            List<String> rowKeyList = new ArrayList<>();
            while (flag) {
                rowKeyList.clear();
                //  当前时间大于初始化时间，就所有数据初始化，每个月递增查询，当前时间小于于初始时间每天抽取
                if (basesicUtil.compareDate(initializeDate, nowDate) == -1) {
//					Date yesterdayDate = DateUtils.addDays(now,-1);
//					String yesterday = DateUtil.formatDate(yesterdayDate,DateUtil.DEFAULT_DATE_YMD_FORMAT);
//					fq = "event_date:[" + yesterday + "T00:00:00Z TO  " + yesterday + "T23:59:59Z]";
//					flag = false;
                    Date exeStartDate = DateUtil.parseDate(initializeDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(exeStartDate);
                    int day1 = calendar.get(Calendar.DAY_OF_YEAR);
                    Calendar endCalendar = Calendar.getInstance();
                    endCalendar.setTime(now);
                    int day2 = endCalendar.get(Calendar.DAY_OF_YEAR);
                    int num = day2 - day1;
                    //总院那边是一天采集24天的数据，所以初始化完后，每天采集15天的数据
                    Date executeStartDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * (num - 1));
                    Date executeEndDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * num);
                    startDate = DateUtil.formatDate(executeStartDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    endDate = DateUtil.formatDate(executeEndDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T23:59:59Z]";
                    flag = false;
                } else {
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T00:00:00Z]";
                    Date sDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    startDate = DateUtil.formatDate(sDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Date eDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    endDate = DateUtil.formatDate(eDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    if (basesicUtil.compareDate("2016-06-01", startDate) != 1) {//结束时间
                        fq = "event_date:[" + startDate + "T00:00:00Z TO 2016-06-01T00:00:00Z]";
                        flag = false;
                    }
                    System.out.println("startDate=" + startDate);
                }
                //找出糖尿病的就诊档案
                List<String> subRrowKeyList = new ArrayList<>(); //细表rowkey
                subRrowKeyList = selectSubRowKey(ResourceCore.SubTable, q2, fq, 10000);
                System.out.println(" persional 个人开始查询 persional solr, fq = " + fq);
                System.out.println("persional 查询结果条数 persional count ：" + subRrowKeyList.size());
                if (subRrowKeyList != null && subRrowKeyList.size() > 0) {
                    //糖尿病数据 Start
                    for (String subRowkey : subRrowKeyList) {//循环糖尿病 找到主表就诊人信息
                        try {
                            String mainRowkey = subRowkey.substring(0, subRowkey.indexOf("$"));
                            //查询此次就诊记录的相关数据 保存到检测记录中
                            String name = "";
                            String demographicId = "";
                            String cardId = "";
                            Integer sex = 0;
                            String sexName = "";
                            if (!rowKeyList.contains(mainRowkey)) {
                                rowKeyList.add(mainRowkey);
                                PersonalInfoModel personalInfo = new PersonalInfoModel();
                                personalInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                Map<String, Object> subMap = hbaseDao.getResultMap(ResourceCore.SubTable, subRowkey);
                                if (subMap != null) {
                                    String diseaseName = "";
                                    if (subMap.get(keyDiseaseSymptom) != null) {
                                        diseaseName = subMap.get(keyDiseaseSymptom).toString();
                                    } else if (subMap.get(keyDiseaseSymptom2) != null) {
                                        diseaseName = subMap.get(keyDiseaseSymptom2).toString();
                                    }
                                    if (StringUtils.isNotEmpty(diseaseName)) {
                                        if (diseaseName.contains("1型")) {
                                            personalInfo.setDiseaseType("1");
                                            personalInfo.setDiseaseTypeName("I型糖尿病");
                                        } else if (diseaseName.contains("2型")) {
                                            personalInfo.setDiseaseType("2");
                                            personalInfo.setDiseaseTypeName("II型糖尿病");
                                        } else if (diseaseName.contains("妊娠")) {
                                            personalInfo.setDiseaseType("3");
                                            personalInfo.setDiseaseTypeName("妊娠糖尿病");
                                        } else {
                                            personalInfo.setDiseaseType("4");
                                            personalInfo.setDiseaseTypeName("其他糖尿病");
                                        }
                                    }
                                }
                                Map<String, Object> map = hbaseDao.getResultMap(ResourceCore.MasterTable, mainRowkey);
                                if (map != null) {
                                    //个人信息 > 姓名，身份证，就诊卡号，性别，出生日期，出生年份，区县，常住地址，常住地址经纬度，疾病名称，疾病code
                                    if (map.get(keyEventDate) != null) {
                                        String mapContent = objectMapper.writeValueAsString(map);
                                        personalInfo.setRowKey(mainRowkey + "【" + mapContent + "】");
                                        try {
                                            Date eventDate = DateUtil.formatCharDate(map.get(keyEventDate).toString(), DateUtil.DATE_WORLD_FORMAT);
                                            personalInfo.setEventDate(DateUtils.addHours(eventDate, 8));
                                        } catch (Exception e) {
                                            throw new Exception("就诊时间数据有误！" + map.get(keyEventDate));
                                        }
                                    }
                                    if (map.get(keyArea) != null) {
                                        personalInfo.setTown(map.get(keyArea).toString());
                                    }
                                    if (map.get(keyAreaName) != null) {
                                        personalInfo.setTownName(map.get(keyAreaName).toString());
                                    }
                                    if (map.get(keyPatientName) != null) {
                                        personalInfo.setName(map.get(keyPatientName).toString());
                                    }
                                    if (map.get(keyDemographicId) != null) {
                                        personalInfo.setDemographicId(map.get(keyDemographicId).toString());
                                    }
                                    if (map.get(keyCardId) != null) {
                                        personalInfo.setCardId(map.get(keyCardId).toString());
                                    }
                                    if (map.get(keySex) != null) {
                                        if (map.get(keySex).toString().contains("男")) {
                                            sex = 1;
                                            sexName = "男";
                                        } else if (map.get(keySex).toString().contains("女")) {
                                            sex = 2;
                                            sexName = "女";
                                        } else {
                                            try {
                                                sex = Integer.valueOf(map.get(keySex).toString());
                                                if (sex == 1) {
                                                    sexName = "男";
                                                } else if (sex == 2) {
                                                    sexName = "女";
                                                } else {
                                                    if (map.get(keySexValue) != null) {
                                                        sexName = map.get(keySexValue).toString();
                                                    } else {
                                                        sexName = "未知";
                                                    }
                                                }
                                            } catch (Exception e) {
                                                throw new Exception("性别数据异常");
                                            }
                                        }
                                    } else {
                                        sex = 0;
                                        sexName = "未知";
                                    }
                                    personalInfo.setSex(sex);
                                    personalInfo.setSexName(sexName);
                                    if (map.get(keyAge) != null) {
                                        if (map.get(keyAge).toString().length() > 10) {
                                            try {
                                                personalInfo.setBirthday(map.get(keyAge).toString().substring(0, 10));
                                                int year = Integer.valueOf(map.get(keyAge).toString().substring(0, 4));
                                                personalInfo.setBirthYear(year);
                                            } catch (Exception e) {
                                                throw new Exception("出生日期数据有误！" + map.get(keyAge));
                                            }
                                        }
                                    }
                                    if (map.get(keyAddress) != null) {
                                        String address = map.get(keyAddress).toString();
                                        personalInfo.setAddress(address);
                                        try {
                                            Map<String, String> json = LatitudeUtils.getGeocoderLatitude(address);
                                            personalInfo.setAddressLngLat(json.get("lng") + ";" + json.get("lat"));
                                        } catch (Exception e) {
                                            System.out.println("没有外网无法解析常住地址！");
                                        }
                                    }
                                    personalInfo.setDisease("HP0047");
                                    personalInfo.setDiseaseName("糖尿病");
                                    //个人信息记录end
                                    savePersonal(personalInfo);
                                }
                            }
                        } catch (Exception e) {
                            throw new Exception("数据解析保存异常" + e.getMessage());
                        }
                    }
                    //糖尿病数据 end
                }
            }
        } catch (Exception e) {
            e.getMessage();
        }
    }
    public void savePersonal(PersonalInfoModel personalInfo) throws Exception {
        try {
            String index = "singleDiseasePersonal";
            String type = "personal_info";
            Map<String, Object> source = new HashMap<>();
            String jsonPer = objectMapper.writeValueAsString(personalInfo);
            source = objectMapper.readValue(jsonPer, Map.class);
            if (personalInfo.getDemographicId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "demographicId", personalInfo.getDemographicId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else if (personalInfo.getCardId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "cardId", personalInfo.getCardId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else {
                elasticSearchUtil.index(index, type, source);
            }
        } catch (Exception e) {
            new Exception("ElasticSearch 数据保存异常");
        }
    }
    public CheckInfoModel setCheckInfoModel(CheckInfoModel baseCheckInfo) {
        CheckInfoModel checkInfo = new CheckInfoModel();
        checkInfo.setSexName(baseCheckInfo.getSexName());
        checkInfo.setSex(baseCheckInfo.getSex());
        checkInfo.setDemographicId(baseCheckInfo.getDemographicId());
        checkInfo.setCardId(baseCheckInfo.getCardId());
        checkInfo.setName(baseCheckInfo.getName());
        checkInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
        return checkInfo;
    }
    //获取维度的字典项
    private Map<String, String> getdimensionDicMap(String dictSql) {
        BasesicUtil baseUtil = new BasesicUtil();
        Map<String, String> dimensionDicMap = new HashMap<>();
        List<DictModel> dictDatas = jdbcTemplate.query(dictSql, new BeanPropertyRowMapper(DictModel.class));
        for (DictModel dictModel : dictDatas) {
            String name = baseUtil.getFieldValueByName("name", dictModel);
            String val = baseUtil.getFieldValueByName("code", dictModel).toLowerCase();
            dimensionDicMap.put(val, name);
        }
        return dimensionDicMap;
    }
    //获取查询结果中的rowKey
    private List<String> selectSubRowKey(String core, String q, String fq, long count) throws Exception {
        List<String> data = new ArrayList<>();
        /***** Solr查询 ********/
        SolrDocumentList solrList = solrUtil.query(core, q, fq, null, 1, count);
        if (solrList != null && solrList.getNumFound() > 0) {
            for (SolrDocument doc : solrList) {
                String rowkey = String.valueOf(doc.getFieldValue("rowkey"));
                data.add(rowkey);
            }
        }
        return data;
    }
    //查询habase里面数据
    private List<Map<String, Object>> selectHbaseData(String table, List<String> list) throws Exception {
        List<Map<String, Object>> data = new ArrayList<>();
        /***** Hbase查询 ********/
        Result[] resultList = hbaseDao.getResultList(table, list, "", ""); //hbase结果集
        if (resultList != null && resultList.length > 0) {
            for (Result result : resultList) {
                Map<String, Object> obj = resultToMap(result, "");
                if (obj != null) {
                    data.add(obj);
                }
            }
        }
        return data;
    }
    //查询habase里面数据 单条
    private Map<String, Object> selectSingleHbaseData(String table, String rowKey) throws Exception {
        return hbaseDao.getResultMap(table, rowKey);
    }
    /**
     * Result 转 JSON
     *
     * @return
     */
    private Map<String, Object> resultToMap(Result result, String fl) {
        String rowkey = Bytes.toString(result.getRow());
        if (rowkey != null && rowkey.length() > 0) {
            Map<String, Object> obj = new HashMap<>();
            obj.put("rowkey", rowkey);
            for (Cell cell : result.rawCells()) {
                String fieldName = Bytes.toString(CellUtil.cloneQualifier(cell));
                String fieldValue = Bytes.toString(CellUtil.cloneValue(cell));
                if (fl != null && !fl.equals("") && !fl.equals("*")) {
                    String[] fileds = fl.split(",");
                    for (String filed : fileds) {
                        if (filed.equals(fieldName)) {
                            obj.put(fieldName, fieldValue);
                            continue;
                        }
                    }
                } else {
                    obj.put(fieldName, fieldValue);
                }
            }
            return obj;
        } else {
            return null;
        }
    }
}

src/main/java/com/yihu/quota/scheduler/DiabetesSymptomScheduler.java

@@ -1,406 +0,0 @@
package com.yihu.quota.scheduler;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.ehr.elasticsearch.ElasticSearchUtil;
import com.yihu.ehr.hbase.HBaseDao;
import com.yihu.ehr.profile.core.ResourceCore;
import com.yihu.ehr.solr.SolrUtil;
import com.yihu.ehr.util.datetime.DateUtil;
import com.yihu.quota.util.BasesicUtil;
import com.yihu.quota.vo.CheckInfoModel;
import com.yihu.quota.vo.DictModel;
import com.yihu.quota.vo.PersonalInfoModel;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.util.*;
/**
 * 糖尿病单病种  并发症分析 数据统计
 */
@Component
public class DiabetesSymptomScheduler {
    private static final Logger log = LoggerFactory.getLogger(DiabetesSymptomScheduler.class);
    @Autowired
    private SolrUtil solrUtil;
    @Autowired
    private ElasticSearchUtil elasticSearchUtil;
    @Autowired
    private HBaseDao hbaseDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private ObjectMapper objectMapper;
    /**
     * 首先要有一个初始化过程
     * 每天2点 执行一次
     *
     * @throws Exception
     */
//	@Scheduled(cron = "0 35 17 * * ?")
    public void validatorIdentityScheduler() {
        try {
            String q2 = "EHR_000112:*糖尿病*并发症* OR EHR_000295:*糖尿病*并发症*"; //门诊和住院 诊断名称
            String fq = ""; // 过滤条件
            String keyEventDate = "event_date";
            String keyArea = "EHR_001225";
            String keyAreaName = "EHR_001225_VALUE";
            String keyPatientName = "patient_name";
            String keyDemographicId = "demographic_id";//身份证
            String keyCardId = "card_id	";
            String keySex = "EHR_000019";//性别
            String keySexValue = "EHR_000019_VALUE";
            String keyAge = "EHR_000007";//出生日期 年龄
            String keyAddress = "EHR_001211"; //地址
            String keyDiseaseSymptom = "EHR_000112";//并发症  诊断名称(门诊)
            String keyDiseaseSymptom2 = "EHR_000295";//并发症  诊断名称（住院）
            String keysugarToleranceName = "EHR_000392";//  检验-项目结果 - 报告子项的LOINC编码  14995-5 糖耐量值  14771-0 空腹血糖
            String keysugarToleranceVal = "EHR_000387";//检验-项目结果 -  结果值  糖耐量值
            String keyChineseName = "EHR_000394";//子项目中文名称
            String keyWestMedicine = "EHR_000100";  //西药
            String keyChineseMedicine = "EHR_000131";//中药
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            BasesicUtil basesicUtil = new BasesicUtil();
            String initializeDate = "2018-04-26";// job初始化时间
            String executeInitDate = "2016-06-01";
            Date now = new Date();
            String nowDate = DateUtil.formatDate(now, DateUtil.DEFAULT_DATE_YMD_FORMAT);
            boolean flag = true;
            String startDate = "2015-01-01";
            String endDate = "2015-02-01";
            while (flag) {
                //  当前时间大于初始化时间，就所有数据初始化，每个月递增查询，当前时间小于于初始时间每天抽取
                if (basesicUtil.compareDate(initializeDate, nowDate) == -1) {
                    Date exeStartDate = DateUtil.parseDate(initializeDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(exeStartDate);
                    int day1 = calendar.get(Calendar.DAY_OF_YEAR);
                    Calendar endCalendar = Calendar.getInstance();
                    endCalendar.setTime(now);
                    int day2 = endCalendar.get(Calendar.DAY_OF_YEAR);
                    int num = day2 - day1;
                    //总院那边是一天采集24天的数据，所以初始化完后，每天采集15天的数据
                    Date executeStartDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * (num - 1));
                    Date executeEndDate = DateUtils.addDays(DateUtil.parseDate(executeInitDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 10 * num);
                    startDate = DateUtil.formatDate(executeStartDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    endDate = DateUtil.formatDate(executeEndDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T23:59:59Z]";
                    flag = false;
                } else {
                    fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T00:00:00Z]";
                    Date sDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    startDate = DateUtil.formatDate(sDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    Date eDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                    endDate = DateUtil.formatDate(eDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                    if (basesicUtil.compareDate("2016-06-01", endDate) != 1) {//结束时间
                        fq = "event_date:[" + startDate + "T00:00:00Z TO 2016-06-01T00:00:00Z]";
                        flag = false;
                    }
                }
                //找出糖尿病的就诊档案
                //event_date:[2015-06-01T00:00:00Z TO  2015-07-01T00:00:00Z]
                System.out.println(" 开始查询 并发症bingfazheng solr, fq = " + fq);
                List<String> subRrowKeyList = new ArrayList<>(); //细表rowkey
                subRrowKeyList = selectSubRowKey(ResourceCore.SubTable, q2, fq, 10000);
                System.out.println(" 并发症查询结果条数 bingfazheng count ：" + subRrowKeyList.size());
                if (subRrowKeyList != null && subRrowKeyList.size() > 0) {
                    //糖尿病数据 Start
                    for (String subRowkey : subRrowKeyList) {//循环糖尿病 找到主表就诊人信息
                        try {
                            //查询此次就诊记录的相关数据 保存到检测记录中
                            String name = "";
                            String demographicId = "";
                            String cardId = "";
                            Integer sex = 0;
                            String sexName = "";
                            String diseaseType = "";
                            String diseaseTypeName = "";
                            String birthday = "";
                            int birthYear = 0;
                            Date eventDate = null;
                            Map<String, Object> subMap = hbaseDao.getResultMap(ResourceCore.SubTable, subRowkey);
                            if (subMap != null) {
                                String diseaseName = "";
                                if (subMap.get(keyDiseaseSymptom) != null) {
                                    diseaseName = subMap.get(keyDiseaseSymptom).toString();
                                } else if (subMap.get(keyDiseaseSymptom2) != null) {
                                    diseaseName = subMap.get(keyDiseaseSymptom2).toString();
                                }
                                if (StringUtils.isNotEmpty(diseaseName)) {
                                    if (diseaseName.contains("1型")) {
                                        diseaseType = "1";
                                        diseaseTypeName = "I型糖尿病";
                                    } else if (diseaseName.contains("2型")) {
                                        diseaseType = "2";
                                        diseaseTypeName = "II型糖尿病";
                                    } else if (diseaseName.contains("妊娠")) {
                                        diseaseType = "3";
                                        diseaseTypeName = "妊娠糖尿病";
                                    } else {
                                        diseaseType = "4";
                                        diseaseTypeName = "其他糖尿病";
                                    }
                                }
                            }
                            String mainRowkey = subRowkey.substring(0, subRowkey.indexOf("$"));
                            Map<String, Object> map = hbaseDao.getResultMap(ResourceCore.MasterTable, mainRowkey);
                            if (map != null) {
                                if (map.get(keyEventDate) != null) {
                                    try {
                                        eventDate = DateUtil.formatCharDate(map.get(keyEventDate).toString(), DateUtil.DATE_WORLD_FORMAT);
                                        eventDate = DateUtils.addHours(eventDate, 8);
                                    } catch (Exception e) {
                                        throw new Exception("就诊时间数据有误！" + map.get(keyEventDate));
                                    }
                                }
                                if (map.get(keyAge) != null) {
                                    if (map.get(keyAge).toString().length() > 10) {
                                        try {
                                            birthday = map.get(keyAge).toString().substring(0, 10);
                                            birthYear = Integer.valueOf(map.get(keyAge).toString().substring(0, 4));
                                        } catch (Exception e) {
                                            throw new Exception("出生日期数据有误！" + map.get(keyAge));
                                        }
                                    }
                                }
                                if (map.get(keyDemographicId) != null) {
                                    demographicId = map.get(keyDemographicId).toString();
                                }
                                if (map.get(keyCardId) != null) {
                                    cardId = map.get(keyCardId).toString();
                                }
                                if (map.get(keySex) != null) {
                                    if (map.get(keySex).toString().contains("男")) {
                                        sex = 1;
                                        sexName = "男";
                                    } else if (map.get(keySex).toString().contains("女")) {
                                        sex = 2;
                                        sexName = "女";
                                    } else {
                                        try {
                                            sex = Integer.valueOf(map.get(keySex).toString());
                                            if (sex == 1) {
                                                sexName = "男";
                                            } else if (sex == 2) {
                                                sexName = "女";
                                            } else {
                                                if (map.get(keySexValue) != null) {
                                                    sexName = map.get(keySexValue).toString();
                                                } else {
                                                    sexName = "未知";
                                                }
                                            }
                                        } catch (Exception e) {
                                            throw new Exception("性别数据异常");
                                        }
                                    }
                                } else {
                                    sex = 0;
                                    sexName = "未知";
                                }
                                if (map.get(keyPatientName) != null) {
                                    name = map.get(keyPatientName).toString();
                                }
                            }
                            CheckInfoModel baseCheckInfo = new CheckInfoModel();
                            baseCheckInfo.setName(name);
                            baseCheckInfo.setDemographicId(demographicId);
                            baseCheckInfo.setCardId(cardId);
                            baseCheckInfo.setSex(sex);
                            baseCheckInfo.setSexName(sexName);
                            baseCheckInfo.setBirthday(birthday);
                            baseCheckInfo.setBirthYear(birthYear);
                            baseCheckInfo.setDiseaseType(diseaseType);
                            baseCheckInfo.setDiseaseTypeName(diseaseTypeName);
                            baseCheckInfo.setEventDate(eventDate);
                            Map<String, Object> submap = hbaseDao.getResultMap(ResourceCore.SubTable, subRowkey);
                            if (submap != null) {
                                //检查信息 姓名,身份证，就诊卡号,并发症，空腹血糖值，葡萄糖耐量值，用药名称，检查信息code （CH001 并发症,CH002 空腹血糖,CH003 葡萄糖耐量,CH004 用药名称）
                                if (submap.get(keyDiseaseSymptom) != null && submap.get(keyDiseaseSymptom).toString().contains("并发症")) {
                                    baseCheckInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                    baseCheckInfo.setCheckCode("CH001");
                                    baseCheckInfo.setSymptomName(submap.get(keyDiseaseSymptom).toString());
                                    saveCheckInfo(baseCheckInfo);
                                }
                                if (submap.get(keyDiseaseSymptom2) != null && submap.get(keyDiseaseSymptom2).toString().contains("并发症")) {
                                    baseCheckInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                    baseCheckInfo.setCheckCode("CH001");
                                    baseCheckInfo.setSymptomName(submap.get(keyDiseaseSymptom2).toString());
                                    saveCheckInfo(baseCheckInfo);
                                }
                            }
                        } catch (Exception e) {
                            throw new Exception("数据解析保存异常" + e.getMessage());
                        }
                    }
                    //糖尿病数据并发症 end
                }
            }
        } catch (Exception e) {
            e.getMessage();
        }
    }
    public void savePersonal(PersonalInfoModel personalInfo) throws Exception {
        try {
            String index = "singleDiseasePersonal";
            String type = "personal_info";
            Map<String, Object> source = new HashMap<>();
            String jsonPer = objectMapper.writeValueAsString(personalInfo);
            source = objectMapper.readValue(jsonPer, Map.class);
            if (personalInfo.getDemographicId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "demographicId", personalInfo.getDemographicId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else if (personalInfo.getCardId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "cardId", personalInfo.getCardId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else {
                elasticSearchUtil.index(index, type, source);
            }
        } catch (Exception e) {
            new Exception("ElasticSearch 数据保存异常");
        }
    }
    public void saveCheckInfo(CheckInfoModel checkInfo) {
        try {
            String index = "singleDiseaseCheck";
            String type = "check_info";
            Map<String, Object> source = new HashMap<>();
            String jsonCheck = objectMapper.writeValueAsString(checkInfo);
            source = objectMapper.readValue(jsonCheck, Map.class);
            if (checkInfo.getCheckCode().equals("CH001") && StringUtils.isNotEmpty(checkInfo.getDemographicId())) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "demographicId", checkInfo.getDemographicId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else if (checkInfo.getCheckCode().equals("CH001") && StringUtils.isNotEmpty(checkInfo.getCardId())) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "cardId", checkInfo.getCardId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else {
                elasticSearchUtil.index(index, type, source);
            }
        } catch (Exception e) {
            e.getMessage();
        }
    }
    public CheckInfoModel setCheckInfoModel(CheckInfoModel baseCheckInfo) {
        CheckInfoModel checkInfo = new CheckInfoModel();
        checkInfo.setSexName(baseCheckInfo.getSexName());
        checkInfo.setSex(baseCheckInfo.getSex());
        checkInfo.setDemographicId(baseCheckInfo.getDemographicId());
        checkInfo.setCardId(baseCheckInfo.getCardId());
        checkInfo.setName(baseCheckInfo.getName());
        checkInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
        return checkInfo;
    }
    //获取维度的字典项
    private Map<String, String> getdimensionDicMap(String dictSql) {
        BasesicUtil baseUtil = new BasesicUtil();
        Map<String, String> dimensionDicMap = new HashMap<>();
        List<DictModel> dictDatas = jdbcTemplate.query(dictSql, new BeanPropertyRowMapper(DictModel.class));
        for (DictModel dictModel : dictDatas) {
            String name = baseUtil.getFieldValueByName("name", dictModel);
            String val = baseUtil.getFieldValueByName("code", dictModel).toLowerCase();
            dimensionDicMap.put(val, name);
        }
        return dimensionDicMap;
    }
    //获取查询结果中的rowKey
    private List<String> selectSubRowKey(String core, String q, String fq, long count) throws Exception {
        List<String> data = new ArrayList<>();
        /***** Solr查询 ********/
        SolrDocumentList solrList = solrUtil.query(core, q, fq, null, 1, count);
        if (solrList != null && solrList.getNumFound() > 0) {
            for (SolrDocument doc : solrList) {
                String rowkey = String.valueOf(doc.getFieldValue("rowkey"));
                data.add(rowkey);
            }
        }
        return data;
    }
    //查询habase里面数据
    private List<Map<String, Object>> selectHbaseData(String table, List<String> list) throws Exception {
        List<Map<String, Object>> data = new ArrayList<>();
        /***** Hbase查询 ********/
        Result[] resultList = hbaseDao.getResultList(table, list, "", ""); //hbase结果集
        if (resultList != null && resultList.length > 0) {
            for (Result result : resultList) {
                Map<String, Object> obj = resultToMap(result, "");
                if (obj != null) {
                    data.add(obj);
                }
            }
        }
        return data;
    }
    //查询habase里面数据 单条
    private Map<String, Object> selectSingleHbaseData(String table, String rowKey) throws Exception {
        return hbaseDao.getResultMap(table, rowKey);
    }
    /**
     * Result 转 JSON
     *
     * @return
     */
    private Map<String, Object> resultToMap(Result result, String fl) {
        String rowkey = Bytes.toString(result.getRow());
        if (rowkey != null && rowkey.length() > 0) {
            Map<String, Object> obj = new HashMap<>();
            obj.put("rowkey", rowkey);
            for (Cell cell : result.rawCells()) {
                String fieldName = Bytes.toString(CellUtil.cloneQualifier(cell));
                String fieldValue = Bytes.toString(CellUtil.cloneValue(cell));
                if (fl != null && !fl.equals("") && !fl.equals("*")) {
                    String[] fileds = fl.split(",");
                    for (String filed : fileds) {
                        if (filed.equals(fieldName)) {
                            obj.put(fieldName, fieldValue);
                            continue;
                        }
                    }
                } else {
                    obj.put(fieldName, fieldValue);
                }
            }
            return obj;
        } else {
            return null;
        }
    }
}

src/main/java/com/yihu/quota/scheduler/DiabetesTestScheduler.java

@@ -1,389 +0,0 @@
package com.yihu.quota.scheduler;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.ehr.elasticsearch.ElasticSearchUtil;
import com.yihu.ehr.hbase.HBaseDao;
import com.yihu.ehr.profile.core.ResourceCore;
import com.yihu.ehr.solr.SolrUtil;
import com.yihu.ehr.util.datetime.DateUtil;
import com.yihu.quota.etl.extract.ExtractUtil;
import com.yihu.quota.util.BasesicUtil;
import com.yihu.quota.util.LatitudeUtils;
import com.yihu.quota.vo.CheckInfoModel;
import com.yihu.quota.vo.DictModel;
import com.yihu.quota.vo.PersonalInfoModel;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.util.*;
/**
 * 糖尿病单病种 分析 数据统计
 */
@Component
public class DiabetesTestScheduler {
    private static final Logger log = LoggerFactory.getLogger(DiabetesTestScheduler.class);
    @Autowired
    private SolrUtil solrUtil;
    @Autowired
    private ExtractUtil extractUtil;
    @Autowired
    private ElasticSearchUtil elasticSearchUtil;
    @Autowired
    private HBaseDao hbaseDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private ObjectMapper objectMapper;
    //	@Scheduled(cron = "0 10 16 * * ?")
    public void validatorIdentity() {
        try {
//			String q =  null; // 查询条件 health_problem:HP0047  HP0047 为糖尿病
            String q2 = "EHR_000295:*糖尿病* OR EHR_000112:*糖尿病*";
//			String keyDiseaseNameH = "EHR_000295";//诊断名字（住院） *糖尿病*
//			String keyDiseaseNameZ = "EHR_000112";//诊断名字（门诊）*糖尿病*
            String fq = ""; // 过滤条件
            String keyEventDate = "event_date";
            String keyArea = "EHR_001225";  //行政区划代码
            String keyAreaName = "EHR_001225_VALUE";
            String keyPatientName = "patient_name";
            String keyDemographicId = "demographic_id";//身份证
            String keyCardId = "card_id	";
//			String keyHealthProblem = "health_problem";
            String keySex = "EHR_000019";//性别
            String keySexValue = "EHR_000019_VALUE";
            String keyAge = "EHR_000007";//出生日期 年龄
            String keyAddress = "EHR_001211"; //地址
//			String keyDiseaseType = "EHR_003810";//EHR_003810 诊断代码
            String keyDiseaseSymptom = "EHR_000112";//并发症  诊断名称(门诊)
            String keyDiseaseSymptom2 = "EHR_000295";//并发症  诊断名称（住院）
            String keysugarToleranceName = "EHR_000392";//  检验-项目结果 - 报告子项的LOINC编码  14995-5 糖耐量值  14771-0 空腹血糖
            String keysugarToleranceVal = "EHR_000387";//检验-项目结果 -  结果值  糖耐量值
            String keyChineseName = "EHR_000394";//子项目中文名称
//			String keyEnglishName = "EHR_000393";//子项目英文名称
            String keyWestMedicine = "EHR_000100";  //西药
            String keyChineseMedicine = "EHR_000131";//中药
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            BasesicUtil basesicUtil = new BasesicUtil();
            String initializeDate = "2018-04-10";// job初始化时间
            String executeInitDate = "2015-06-01";
            Date now = new Date();
            String nowDate = DateUtil.formatDate(now, DateUtil.DEFAULT_DATE_YMD_FORMAT);
            boolean flag = true;
            String startDate = "2015-01-01";
            String endDate = "2015-02-01";
            List<String> rowKeyList = new ArrayList<>();
            while (flag) {
                fq = "event_date:[" + startDate + "T00:00:00Z TO  " + endDate + "T00:00:00Z]";
                Date sDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                startDate = DateUtil.formatDate(sDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                Date eDate = DateUtils.addDays(DateUtil.parseDate(startDate, DateUtil.DEFAULT_DATE_YMD_FORMAT), 15);
                endDate = DateUtil.formatDate(eDate, DateUtil.DEFAULT_DATE_YMD_FORMAT);
                if (basesicUtil.compareDate("2017-05-01", startDate) != 1) {//结束时间
                    flag = false;
                }
                System.out.println("startDate=" + startDate);
                log.error("startDate=" + startDate);
                rowKeyList.clear();
                //找出糖尿病的就诊档案
                List<String> subRrowKeyList = new ArrayList<>(); //细表rowkey
                subRrowKeyList = selectSubRowKey(ResourceCore.SubTable, q2, fq, 10000);
                System.out.println(" persional 个人开始查询 persional solr, fq = " + fq);
                System.out.println(" persional 查询结果条数 persional count ：" + subRrowKeyList.size());
                log.error("persional 查询结果条数 persional count ：" + subRrowKeyList.size());
                int i = 0;
                if (subRrowKeyList != null && subRrowKeyList.size() > 0) {
                    //糖尿病数据 Start
                    for (String subRowkey : subRrowKeyList) {//循环糖尿病 找到主表就诊人信息
                        try {
                            i++;
                            log.error("第= " + i + " 个");
                            String mainRowkey = subRowkey.substring(0, subRowkey.indexOf("$"));
                            //查询此次就诊记录的相关数据 保存到检测记录中
                            String name = "";
                            String demographicId = "";
                            String cardId = "";
                            Integer sex = 0;
                            String sexName = "";
                            if (!rowKeyList.contains(mainRowkey)) {
                                rowKeyList.add(mainRowkey);
                                PersonalInfoModel personalInfo = new PersonalInfoModel();
                                personalInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
                                Map<String, Object> subMap = hbaseDao.getResultMap(ResourceCore.SubTable, subRowkey);
                                if (subMap != null) {
                                    String diseaseName = "";
                                    if (subMap.get(keyDiseaseSymptom) != null) {
                                        diseaseName = subMap.get(keyDiseaseSymptom).toString();
                                    } else if (subMap.get(keyDiseaseSymptom2) != null) {
                                        diseaseName = subMap.get(keyDiseaseSymptom2).toString();
                                    }
                                    if (StringUtils.isNotEmpty(diseaseName)) {
                                        if (diseaseName.contains("1型")) {
                                            personalInfo.setDiseaseType("1");
                                            personalInfo.setDiseaseTypeName("I型糖尿病");
                                        } else if (diseaseName.contains("2型")) {
                                            personalInfo.setDiseaseType("2");
                                            personalInfo.setDiseaseTypeName("II型糖尿病");
                                        } else if (diseaseName.contains("妊娠")) {
                                            personalInfo.setDiseaseType("3");
                                            personalInfo.setDiseaseTypeName("妊娠糖尿病");
                                        } else {
                                            personalInfo.setDiseaseType("4");
                                            personalInfo.setDiseaseTypeName("其他糖尿病");
                                        }
                                    }
                                }
                                log.error("sub = " + i + " 个");
                                Map<String, Object> map = hbaseDao.getResultMap(ResourceCore.MasterTable, mainRowkey);
                                if (map != null) {
                                    //个人信息 > 姓名，身份证，就诊卡号，性别，出生日期，出生年份，区县，常住地址，常住地址经纬度，疾病名称，疾病code
                                    String mapContent = objectMapper.writeValueAsString(map);
                                    personalInfo.setRowKey(mainRowkey + "【" + mapContent + "】");
                                    log.error("MasterTable = " + i + " 个" + mapContent);
                                    if (map.get(keyEventDate) != null) {
                                        try {
                                            Date eventDate = DateUtil.formatCharDate(map.get(keyEventDate).toString(), DateUtil.DATE_WORLD_FORMAT);
                                            personalInfo.setEventDate(DateUtils.addHours(eventDate, 8));
                                        } catch (Exception e) {
                                            throw new Exception("就诊时间数据有误！" + map.get(keyEventDate));
                                        }
                                    } else {
                                        personalInfo.setEventDate(null);
                                    }
                                    if (map.get(keyArea) != null) {
                                        personalInfo.setTown(map.get(keyArea).toString());
                                    } else {
                                        personalInfo.setTown("twon无数据");
                                    }
                                    log.error("town = " + i + " 个");
                                    if (map.get(keyAreaName) != null) {
                                        personalInfo.setTownName(map.get(keyAreaName).toString());
                                    } else {
                                        personalInfo.setTownName("twonName无数据");
                                    }
                                    if (map.get(keyPatientName) != null) {
                                        personalInfo.setName(map.get(keyPatientName).toString());
                                    } else {
                                        personalInfo.setName("name无数据");
                                    }
                                    if (map.get(keyDemographicId) != null) {
                                        personalInfo.setDemographicId(map.get(keyDemographicId).toString());
                                    } else {
                                        personalInfo.setDemographicId("demographicId无数据");
                                    }
                                    if (map.get(keyCardId) != null) {
                                        personalInfo.setCardId(map.get(keyCardId).toString());
                                    } else {
                                        personalInfo.setCardId("cardId无数据");
                                    }
                                    log.error("sex = " + i + " 个");
                                    if (map.get(keySex) != null) {
                                        if (map.get(keySex).toString().contains("男")) {
                                            sex = 1;
                                            sexName = "男";
                                        } else if (map.get(keySex).toString().contains("女")) {
                                            sex = 2;
                                            sexName = "女";
                                        } else {
                                            sex = Integer.valueOf(map.get(keySex).toString());
                                            if (sex == 1) {
                                                sexName = "男";
                                            } else if (sex == 2) {
                                                sexName = "女";
                                            } else {
                                                if (map.get(keySexValue) != null) {
                                                    sexName = map.get(keySexValue).toString();
                                                } else {
                                                    sexName = "未知";
                                                }
                                            }
                                        }
                                    } else {
                                        sex = 0;
                                        sexName = "未知";
                                    }
                                    personalInfo.setSex(sex);
                                    personalInfo.setSexName(sexName);
                                    log.error("age = " + i + " 个");
                                    if (map.get(keyAge) != null) {
                                        if (map.get(keyAge).toString().length() > 10) {
                                            try {
                                                personalInfo.setBirthday(map.get(keyAge).toString().substring(0, 10));
                                                int year = Integer.valueOf(map.get(keyAge).toString().substring(0, 4));
                                                personalInfo.setBirthYear(year);
                                            } catch (Exception e) {
                                                throw new Exception("出生日期数据有误！" + map.get(keyAge));
                                            }
                                        }
                                    } else {
                                        //可以根据身份证获取 TODO
                                        personalInfo.setBirthday("birthDay无数据");
                                    }
                                    if (map.get(keyAddress) != null) {
                                        String address = map.get(keyAddress).toString();
                                        personalInfo.setAddress(address);
                                        try {
                                            Map<String, String> json = LatitudeUtils.getGeocoderLatitude(address);
                                            personalInfo.setAddressLngLat(json.get("lng") + ";" + json.get("lat"));
                                        } catch (Exception e) {
                                            System.out.println("没有外网无法解析常住地址！");
                                            throw new Exception("没有外网无法解析常住地址！");
                                        }
                                    } else {
                                        personalInfo.setAddress("address无数据");
                                    }
                                    personalInfo.setDisease("HP0047");
                                    personalInfo.setDiseaseName("糖尿病");
                                    //个人信息记录end
                                    savePersonal(personalInfo);
                                }
                            }
                        } catch (Exception e) {
                            throw new Exception("数据解析保存异常" + e.getMessage());
                        }
                    }
                    //糖尿病数据 end
                }
            }
        } catch (Exception e) {
            e.getMessage();
        }
    }
    public void savePersonal(PersonalInfoModel personalInfo) {
        try {
            String index = "singleDiseasePersonal";
            String type = "personal_info";
            Map<String, Object> source = new HashMap<>();
            String jsonPer = objectMapper.writeValueAsString(personalInfo);
            source = objectMapper.readValue(jsonPer, Map.class);
            log.error("开始保存数据" + jsonPer);
            if (personalInfo.getDemographicId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "demographicId", personalInfo.getDemographicId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else if (personalInfo.getCardId() != null) {
                List<Map<String, Object>> relist = elasticSearchUtil.findByField(index, type, "cardId", personalInfo.getCardId());
                if (!(relist != null && relist.size() > 0)) {
                    elasticSearchUtil.index(index, type, source);
                }
            } else {
                elasticSearchUtil.index(index, type, source);
            }
        } catch (Exception e) {
            e.getMessage();
        }
    }
    public CheckInfoModel setCheckInfoModel(CheckInfoModel baseCheckInfo) {
        CheckInfoModel checkInfo = new CheckInfoModel();
        checkInfo.setSexName(baseCheckInfo.getSexName());
        checkInfo.setSex(baseCheckInfo.getSex());
        checkInfo.setDemographicId(baseCheckInfo.getDemographicId());
        checkInfo.setCardId(baseCheckInfo.getCardId());
        checkInfo.setName(baseCheckInfo.getName());
        checkInfo.setCreateTime(DateUtils.addHours(new Date(), 8));
        return checkInfo;
    }
    //获取维度的字典项
    private Map<String, String> getdimensionDicMap(String dictSql) {
        BasesicUtil baseUtil = new BasesicUtil();
        Map<String, String> dimensionDicMap = new HashMap<>();
        List<DictModel> dictDatas = jdbcTemplate.query(dictSql, new BeanPropertyRowMapper(DictModel.class));
        for (DictModel dictModel : dictDatas) {
            String name = baseUtil.getFieldValueByName("name", dictModel);
            String val = baseUtil.getFieldValueByName("code", dictModel).toLowerCase();
            dimensionDicMap.put(val, name);
        }
        return dimensionDicMap;
    }
    //获取查询结果中的rowKey
    private List<String> selectSubRowKey(String core, String q, String fq, long count) throws Exception {
        List<String> data = new ArrayList<>();
        /***** Solr查询 ********/
        SolrDocumentList solrList = solrUtil.query(core, q, fq, null, 1, count);
        if (solrList != null && solrList.getNumFound() > 0) {
            for (SolrDocument doc : solrList) {
                String rowkey = String.valueOf(doc.getFieldValue("rowkey"));
                data.add(rowkey);
            }
        }
        return data;
    }
    //查询habase里面数据
    private List<Map<String, Object>> selectHbaseData(String table, List<String> list) throws Exception {
        List<Map<String, Object>> data = new ArrayList<>();
        /***** Hbase查询 ********/
        Result[] resultList = hbaseDao.getResultList(table, list, "", ""); //hbase结果集
        if (resultList != null && resultList.length > 0) {
            for (Result result : resultList) {
                Map<String, Object> obj = resultToMap(result, "");
                if (obj != null) {
                    data.add(obj);
                }
            }
        }
        return data;
    }
    //查询habase里面数据 单条
    private Map<String, Object> selectSingleHbaseData(String table, String rowKey) throws Exception {
        return hbaseDao.getResultMap(table, rowKey);
    }
    /**
     * Result 转 JSON
     *
     * @return
     */
    private Map<String, Object> resultToMap(Result result, String fl) {
        String rowkey = Bytes.toString(result.getRow());
        if (rowkey != null && rowkey.length() > 0) {
            Map<String, Object> obj = new HashMap<>();
            obj.put("rowkey", rowkey);
            for (Cell cell : result.rawCells()) {
                String fieldName = Bytes.toString(CellUtil.cloneQualifier(cell));
                String fieldValue = Bytes.toString(CellUtil.cloneValue(cell));
                if (fl != null && !fl.equals("") && !fl.equals("*")) {
                    String[] fileds = fl.split(",");
                    for (String filed : fileds) {
                        if (filed.equals(fieldName)) {
                            obj.put(fieldName, fieldValue);
                            continue;
                        }
                    }
                } else {
                    obj.put(fieldName, fieldValue);
                }
            }
            return obj;
        } else {
            return null;
        }
    }
}

src/main/java/com/yihu/quota/scheduler/OutPatientCostScheduler.java

@@ -1,4 +1,4 @@
package com.yihu.quota.scheduler;
package com.yihu.quota.scheduler.special;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;

src/main/java/com/yihu/quota/scheduler/TransferTreatmentScheduler.java

@@ -1,4 +1,4 @@
package com.yihu.quota.scheduler;
package com.yihu.quota.scheduler.special;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;