更新单体统计接口,增加统计层

whycxzp

2021-08-27 9f1dab940da5cef62e90333ec978d2fe48635273

更新单体统计接口,增加统计层

 src/main/java/com/whyc/Application.java

@@ -4,6 +4,7 @@
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@@ -14,8 +15,9 @@
 **/
@SpringBootApplication
@EnableWebMvc
@ServletComponentScan(basePackages = {"com.whyc.filter","com.whyc.servlet"})
@ServletComponentScan(basePackages = {"com.whyc.filter","com.whyc.servlet","com.whyc.listener"})
@EnableCaching
@EnableScheduling
public class Application extends WebMvcConfigurerAdapter implements WebMvcConfigurer {
//public class Application extends SpringBootServletInitializer {


 src/main/java/com/whyc/constant/SqlConstant.java

New file
@@ -0,0 +1,41 @@
package com.whyc.constant;

public class SqlConstant {
    public static String TB_MON_VOL =
            "CREATE TABLE `db_analysis`.`tb_mon_vol` (\n" +
            "  `id` INT NOT NULL AUTO_INCREMENT,\n" +
            "  `batt_group_id` INT NULL,\n" +
            "  `min` FLOAT NULL,\n" +
            "  `max` FLOAT NULL,\n" +
            "  `avg` FLOAT NULL,\n" +
            "  `create_time` DATETIME NULL,\n" +
            "  PRIMARY KEY (`id`));";
    public static String TB_MON_RES =
            "CREATE TABLE `db_analysis`.`tb_mon_res` (\n" +
            "  `id` INT NOT NULL AUTO_INCREMENT,\n" +
            "  `batt_group_id` INT NULL,\n" +
            "  `min` FLOAT NULL,\n" +
            "  `max` FLOAT NULL,\n" +
            "  `avg` FLOAT NULL,\n" +
            "  `create_time` DATETIME NULL,\n" +
            "  PRIMARY KEY (`id`));";
    public static String TB_MON_TEMP =
            "CREATE TABLE `db_analysis`.`tb_mon_tmp` (\n" +
            "  `id` INT NOT NULL AUTO_INCREMENT,\n" +
            "  `batt_group_id` INT NULL,\n" +
            "  `min` FLOAT NULL,\n" +
            "  `max` FLOAT NULL,\n" +
            "  `avg` FLOAT NULL,\n" +
            "  `create_time` DATETIME NULL,\n" +
            "  PRIMARY KEY (`id`));";
    public static String TB_MON_CAP =
            "CREATE TABLE `db_analysis`.`tb_mon_cap` (\n" +
            "  `id` INT NOT NULL AUTO_INCREMENT,\n" +
            "  `batt_group_id` INT NULL,\n" +
            "  `min` FLOAT NULL,\n" +
            "  `max` FLOAT NULL,\n" +
            "  `avg` FLOAT NULL,\n" +
            "  `create_time` DATETIME NULL,\n" +
            "  PRIMARY KEY (`id`));";

}

 src/main/java/com/whyc/controller/BatteryDataController.java

@@ -53,7 +53,7 @@
    }

    /**
     * TODO:单体容量统计,统计格式待定
     * TODO:单体容量统计,统计格式待定,如何统计待确定
     */
    @GetMapping("monCap")
    @ApiOperation(value = "单体容量统计")

 src/main/java/com/whyc/dto/AnalysisMonCapDTO.java

New file
@@ -0,0 +1,114 @@
package com.whyc.dto;

/**
 * 用于分析单体容量的最值的数据传输实体
 */
public class AnalysisMonCapDTO {
    private Integer battGroupId;
    private String battGroupName;
    private String stationName;
    /**标准单体容量*/
    private Double monCapStd;
    /**标准单体电压*/
    private Double monVolStd;
    /**测试电流*/
    private Float testCurr;
    /**测试容量*/
    private Float testCap;
    /**单体电压*/
    private Float monVol;
    /**测试记录数*/
    private Integer testRecordCount;
    /**单体编号*/
    private Integer monNum;
    /**最大单体电压*/
    private Float maxMonVol;

    public Double getMonCapStd() {
        return monCapStd;
    }

    public void setMonCapStd(Double monCapStd) {
        this.monCapStd = monCapStd;
    }

    public Double getMonVolStd() {
        return monVolStd;
    }

    public void setMonVolStd(Double monVolStd) {
        this.monVolStd = monVolStd;
    }

    public Float getTestCurr() {
        return testCurr;
    }

    public void setTestCurr(Float testCurr) {
        this.testCurr = testCurr;
    }

    public Float getTestCap() {
        return testCap;
    }

    public void setTestCap(Float testCap) {
        this.testCap = testCap;
    }

    public Float getMonVol() {
        return monVol;
    }

    public void setMonVol(Float monVol) {
        this.monVol = monVol;
    }

    public Integer getTestRecordCount() {
        return testRecordCount;
    }

    public void setTestRecordCount(Integer testRecordCount) {
        this.testRecordCount = testRecordCount;
    }

    public Integer getMonNum() {
        return monNum;
    }

    public void setMonNum(Integer monNum) {
        this.monNum = monNum;
    }

    public Float getMaxMonVol() {
        return maxMonVol;
    }

    public void setMaxMonVol(Float maxMonVol) {
        this.maxMonVol = maxMonVol;
    }

    public Integer getBattGroupId() {
        return battGroupId;
    }

    public void setBattGroupId(Integer battGroupId) {
        this.battGroupId = battGroupId;
    }

    public String getBattGroupName() {
        return battGroupName;
    }

    public void setBattGroupName(String battGroupName) {
        this.battGroupName = battGroupName;
    }

    public String getStationName() {
        return stationName;
    }

    public void setStationName(String stationName) {
        this.stationName = stationName;
    }
}

 src/main/java/com/whyc/dto/AnalysisMonFieldDTO.java

New file
@@ -0,0 +1,201 @@
package com.whyc.dto;

import com.fasterxml.jackson.annotation.JsonFormat;

import java.util.Date;

/**包含 tb_mon_vol/temp/res*/
public class AnalysisMonFieldDTO {

    private Integer id;
    private Integer stationId;
    private Integer battGroupId;
    private String battGroupName;
    private String stationName;
    private Float min;
    private Float max;
    private Float avg;
    private Float minMonVol;
    private Float maxMonVol;
    private Float avgMonVol;
    private Float minMonTmp;
    private Float maxMonTmp;
    private Float avgMonTmp;
    private Float minMonRes;
    private Float maxMonRes;
    private Float avgMonRes;
    private Double minMonCap;
    private Double maxMonCap;
    private Double avgMonCap;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "Asia/Shanghai")
    private Date createTime;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getStationId() {
        return stationId;
    }

    public void setStationId(Integer stationId) {
        this.stationId = stationId;
    }

    public Integer getBattGroupId() {
        return battGroupId;
    }

    public void setBattGroupId(Integer battGroupId) {
        this.battGroupId = battGroupId;
    }

    public Float getMin() {
        return min;
    }

    public void setMin(Float min) {
        this.min = min;
    }

    public Float getMax() {
        return max;
    }

    public void setMax(Float max) {
        this.max = max;
    }

    public Float getAvg() {
        return avg;
    }

    public void setAvg(Float avg) {
        this.avg = avg;
    }

    public Float getMinMonVol() {
        return minMonVol;
    }

    public void setMinMonVol(Float minMonVol) {
        this.minMonVol = minMonVol;
    }

    public Float getMaxMonVol() {
        return maxMonVol;
    }

    public void setMaxMonVol(Float maxMonVol) {
        this.maxMonVol = maxMonVol;
    }

    public Float getAvgMonVol() {
        return avgMonVol;
    }

    public void setAvgMonVol(Float avgMonVol) {
        this.avgMonVol = avgMonVol;
    }

    public Float getMinMonTmp() {
        return minMonTmp;
    }

    public void setMinMonTmp(Float minMonTmp) {
        this.minMonTmp = minMonTmp;
    }

    public Float getMaxMonTmp() {
        return maxMonTmp;
    }

    public void setMaxMonTmp(Float maxMonTmp) {
        this.maxMonTmp = maxMonTmp;
    }

    public Float getAvgMonTmp() {
        return avgMonTmp;
    }

    public void setAvgMonTmp(Float avgMonTmp) {
        this.avgMonTmp = avgMonTmp;
    }

    public Float getMinMonRes() {
        return minMonRes;
    }

    public void setMinMonRes(Float minMonRes) {
        this.minMonRes = minMonRes;
    }

    public Float getMaxMonRes() {
        return maxMonRes;
    }

    public void setMaxMonRes(Float maxMonRes) {
        this.maxMonRes = maxMonRes;
    }

    public Float getAvgMonRes() {
        return avgMonRes;
    }

    public void setAvgMonRes(Float avgMonRes) {
        this.avgMonRes = avgMonRes;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getBattGroupName() {
        return battGroupName;
    }

    public void setBattGroupName(String battGroupName) {
        this.battGroupName = battGroupName;
    }

    public String getStationName() {
        return stationName;
    }

    public void setStationName(String stationName) {
        this.stationName = stationName;
    }

    public Double getMinMonCap() {
        return minMonCap;
    }

    public void setMinMonCap(Double minMonCap) {
        this.minMonCap = minMonCap;
    }

    public Double getMaxMonCap() {
        return maxMonCap;
    }

    public void setMaxMonCap(Double maxMonCap) {
        this.maxMonCap = maxMonCap;
    }

    public Double getAvgMonCap() {
        return avgMonCap;
    }

    public void setAvgMonCap(Double avgMonCap) {
        this.avgMonCap = avgMonCap;
    }
}

 src/main/java/com/whyc/listener/ApplicationListener.java

New file
@@ -0,0 +1,40 @@
package com.whyc.listener;

import com.whyc.constant.SqlConstant;
import com.whyc.mapper.DBMapper;

import javax.annotation.Resource;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class ApplicationListener implements ServletContextListener {

    @Resource
    private DBMapper dbMapper;

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        //检查及初始化电池数据统计表
        boolean dbExist = dbMapper.DBExist("db_analysis") != null;
        //初始化的时候,首批的分析表和分析库创建是一起的
        if(!dbExist){
            dbMapper.createDB("db_analysis");
            //单体电压
            dbMapper.createTable(SqlConstant.TB_MON_VOL);
            //单体电阻
            dbMapper.createTable(SqlConstant.TB_MON_RES);
            //单体温度
            dbMapper.createTable(SqlConstant.TB_MON_TEMP);
            //单体实际容量
            dbMapper.createTable(SqlConstant.TB_MON_CAP);
        }

    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {

    }
}

 src/main/java/com/whyc/mapper/AnalysisMonFieldMapper.java

New file
@@ -0,0 +1,13 @@
package com.whyc.mapper;

import com.whyc.dto.AnalysisMonFieldDTO;

import java.util.List;

public interface AnalysisMonFieldMapper {

    Integer insertBatch(String tableName, List<AnalysisMonFieldDTO> analysisMonFieldList, String fieldStr);

    List<AnalysisMonFieldDTO> getMonField(String tableName, Integer userId);

}

 src/main/java/com/whyc/mapper/BatteryResDataMapper.java

@@ -1,12 +1,13 @@
package com.whyc.mapper;

import com.whyc.dto.AnalysisMonFieldDTO;
import com.whyc.dto.BatteryInfo;
import com.whyc.dto.DataAnalysisFloatDTO;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BatteryResDataMapper {
    List<BatteryInfo> getResStationAndBatteryGroupIds(Integer userId);

    DataAnalysisFloatDTO getResStatisticsByBattGroupIds(Integer[] batteryGroupIds);
    List<AnalysisMonFieldDTO> getResStatisticsByTableNames(@Param("tableNames") List<String> tableNames);
}

 src/main/java/com/whyc/mapper/BatteryTestDataMapper.java

@@ -1,16 +1,20 @@
package com.whyc.mapper;

import com.whyc.dto.AnalysisMonCapDTO;
import com.whyc.dto.BatteryInfo;
import com.whyc.dto.DataAnalysisFloatDTO;
import com.whyc.dto.AnalysisMonFieldDTO;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BatteryTestDataMapper {
    List<BatteryInfo> getStationAndBatteryGroupIds(Integer userId);

    DataAnalysisFloatDTO getStatisticsByBattGroupIds(Integer[] ids,String field);
    List<AnalysisMonFieldDTO> getStatisticsByTableNames(List<String> tableNames, String fieldName1, String fieldName2);

    List<BatteryInfo> getCapStatisticsByBattGroupIds(Integer[] ids);
    List<AnalysisMonCapDTO> getCapStatisticsByGroupIds(@Param("groupIds") List<String> groupIds);

    List<BatteryInfo> getVolAndCapStd(Integer[] ids);

    double getRestCapByCondition(AnalysisMonCapDTO monCapDTO);
}

 src/main/java/com/whyc/mapper/DBMapper.java

New file
@@ -0,0 +1,24 @@
package com.whyc.mapper;

import com.whyc.pojo.Tables;

import java.util.List;

/**
 * 建库建表相关Mapper
 */
public interface DBMapper {

    String DBExist(String dbName);

    String tableExist(String dbName,String tableName);

    boolean createDB(String dbName);

    boolean createTable(String sql);

    /**模糊查询表名,获取表名*/
    List<Tables> getTableNames(String dbName, String tableNameRegexp);

    boolean deleteAll(String dbName,String tableName);
}

 src/main/java/com/whyc/pojo/Tables.java

New file
@@ -0,0 +1,26 @@
package com.whyc.pojo;

/**
 * information_schema.tables表实体类
 */
public class Tables {

    private String tableSchema;
    private String tableName;

    public String getTableSchema() {
        return tableSchema;
    }

    public void setTableSchema(String tableSchema) {
        this.tableSchema = tableSchema;
    }

    public String getTableName() {
        return tableName;
    }

    public void setTableName(String tableName) {
        this.tableName = tableName;
    }
}

 src/main/java/com/whyc/schedule/AnalysisSchedule.java

New file
@@ -0,0 +1,66 @@
package com.whyc.schedule;

import com.whyc.dto.AnalysisMonFieldDTO;
import com.whyc.service.AnalysisMonFieldService;
import com.whyc.service.BatteryDataService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@Slf4j
@Component
public class AnalysisSchedule {

    @Resource
    private BatteryDataService dataService;

    @Resource
    private AnalysisMonFieldService service;

    @Scheduled(cron = "0 0 0 * * ?")
    @Transactional
    public void analysisMonVol(){
        List<AnalysisMonFieldDTO> analysisMonFieldList = dataService.monFieldStatistics("mon_vol","mon_tmp");
        //排除null值
        List<AnalysisMonFieldDTO> MonFieldList = analysisMonFieldList.stream().filter(Objects::nonNull).collect(Collectors.toList());
        //单体电压/温度数据更新到分析表中
        service.updateBatch("tb_mon_vol",MonFieldList);
        service.updateBatch("tb_mon_tmp",MonFieldList);

        System.out.println(System.currentTimeMillis()+":分析单体电压/温度");

    }

    @Scheduled(cron = "0 0 0 * * ?")
    @Transactional
    public void analysisMonRes(){
        List<AnalysisMonFieldDTO> analysisMonResList = dataService.monResStatistics();
        //排除null值
        List<AnalysisMonFieldDTO> monResList = analysisMonResList.stream().filter(Objects::nonNull).collect(Collectors.toList());
        //单体内阻更新到分析表中
        service.updateBatch("tb_mon_res",monResList);
        System.out.println(System.currentTimeMillis()+":分析单体电阻");
    }

    /**
     * 首先:查询所有的所有的测试数据stop表
     * 查询所有stop表中所有单体的最后一笔的单体容量,求最小值,最大值,平均值
     * 将结果放置到容量表
     */
    @Scheduled(cron = "0 * * * * ?")
    @Transactional
    public void analysisMonCap(){
        List<AnalysisMonFieldDTO> analysisMonCapList = dataService.monCapStatistics();
        //排除null值
        List<AnalysisMonFieldDTO> monCapList = analysisMonCapList.stream().filter(Objects::nonNull).collect(Collectors.toList());
        //单体容量更新到分析表中
        service.updateBatch("tb_mon_cap",monCapList);
        System.out.println(System.currentTimeMillis()+":分析单体容量");
    }
}

 src/main/java/com/whyc/service/AnalysisMonFieldService.java

New file
@@ -0,0 +1,32 @@
package com.whyc.service;

import com.whyc.mapper.AnalysisMonFieldMapper;
import com.whyc.dto.AnalysisMonFieldDTO;
import com.whyc.mapper.DBMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
public class AnalysisMonFieldService {

    @Resource
    private AnalysisMonFieldMapper mapper;

    @Resource
    private DBMapper dbMapper;

    @Transactional
    public void updateBatch(String tableName, List<AnalysisMonFieldDTO> analysisMonFieldList) {
        //删除原来记录
        dbMapper.deleteAll("db_analysis",tableName);
        //插入行记录
        String[] tableSplit = tableName.split("_");
        String filedStr = tableSplit[tableSplit.length-1];
        String fieldFirst = filedStr.substring(0,1).toUpperCase();
        String fieldStrNew = fieldFirst + filedStr.substring(1);
        mapper.insertBatch(tableName,analysisMonFieldList,fieldStrNew);
    }
}

 src/main/java/com/whyc/service/BatteryDataService.java

@@ -1,13 +1,13 @@
package com.whyc.service;

import com.whyc.dto.AnalysisMonCapDTO;
import com.whyc.dto.BatteryInfo;
import com.whyc.dto.DataAnalysisFloatDTO;
import com.whyc.dto.Response;
import com.whyc.mapper.BatteryDataMapper;
import com.whyc.mapper.BatteryResDataMapper;
import com.whyc.mapper.BatteryTestDataMapper;
import com.whyc.mapper.*;
import com.whyc.dto.AnalysisMonFieldDTO;
import com.whyc.pojo.BatteryEndurance;
import com.whyc.pojo.BatteryRTState;
import com.whyc.pojo.Tables;
import com.whyc.util.BattCapFactory;
import com.whyc.util.MathUtil;
import org.springframework.stereotype.Service;
@@ -15,6 +15,7 @@
import javax.annotation.Resource;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class BatteryDataService {
@@ -27,6 +28,12 @@

    @Resource
    private BatteryTestDataMapper testDataMapper;

    @Resource
    private AnalysisMonFieldMapper monFieldMapper;

    @Resource
    private DBMapper dbMapper;

    public Response getEndurance(Integer userId) {
        List<BatteryEndurance> enduranceList = mapper.endurance(userId);
@@ -109,9 +116,95 @@
        return maps;
    }

    /**单体信息统计*/
    public List<AnalysisMonFieldDTO> monFieldStatistics(String filedName, String fieldName2) {
            //查询所有的电池组
            List<Tables> tables = dbMapper.getTableNames("db_batt_testdata", "tb_batttestdata\\_[1-9]+");
            List<String> tableNames = new LinkedList<>();
            tables.forEach(tableName -> {
                tableNames.add(tableName.getTableName());
            });
            //查询每个电池组的单体字段数据
            List<AnalysisMonFieldDTO> list = testDataMapper.getStatisticsByTableNames(tableNames,filedName,fieldName2);

        return list;
    }

    /**单体内阻统计*/
    public List<AnalysisMonFieldDTO> monResStatistics() {
        //查询所有的电池组
        List<Tables> tables = dbMapper.getTableNames("db_batt_testdata", "tb_battresdata\\_[1-9]+");
        List<String> tableNames = new LinkedList<>();
        tables.forEach(tableName -> {
            tableNames.add(tableName.getTableName());
        });
        //查询每个电池组的单体字段数据
        List<AnalysisMonFieldDTO> list = resMapper.getResStatisticsByTableNames(tableNames);

        return list;
    }

    /**单体容量统计*/
    public List<AnalysisMonFieldDTO> monCapStatistics() {
        List<AnalysisMonFieldDTO> analysisMonFieldList = new LinkedList<>();
        //查询所有的stop表
        List<Tables> tables = dbMapper.getTableNames("db_batt_testdata","tb_batttestdatastop*");
        List<String> groupIds = new LinkedList<>();
        tables.forEach(tableName -> {
            groupIds.add(tableName.getTableName().split("_")[2]);
        });
        //查询每个电池组的单体字段数据,同时要查询出来标准字段,以此来计算每个单体的容量
        List<AnalysisMonCapDTO> analysisMonCapDTOs = testDataMapper.getCapStatisticsByGroupIds(groupIds);
        Map<Integer, List<AnalysisMonCapDTO>> analysisCapMap = analysisMonCapDTOs.stream().collect(Collectors.groupingBy(AnalysisMonCapDTO::getBattGroupId));
        //遍历每个电池组,获取统计数据
        for(Map.Entry<Integer,List<AnalysisMonCapDTO>> entry : analysisCapMap.entrySet()){
            AnalysisMonFieldDTO analysisMonField = new AnalysisMonFieldDTO();
            double minCap = 0d;
            double maxCap = 0d;
            double avgCap = 0d;
            double realCap = 0d;
            double capSum = 0d;
            int size =0;

            Integer battGroupId = entry.getKey();
            List<AnalysisMonCapDTO> capDTOList = entry.getValue();
            //执行容量统计
            for (AnalysisMonCapDTO monCapDTO : capDTOList){
                if(monCapDTO.getMonVol()>monCapDTO.getMonVolStd()*0.9f){
                    int hourRate=BattCapFactory.GetHourRate(monCapDTO.getMonCapStd(),monCapDTO.getTestCurr());
                    realCap = BattCapFactory.GetMonomerCap(monCapDTO.getMonCapStd(),hourRate,monCapDTO.getTestCap(),monCapDTO.getMaxMonVol(),
                            monCapDTO.getMonVol(),monCapDTO.getMonVolStd(),BattCapFactory.CapType_Real);
                }else{
                    //查询电池测试表中对应的测试批次的单体剩余容量
                    realCap = testDataMapper.getRestCapByCondition(monCapDTO);
                }
                if(realCap<minCap){
                    minCap = realCap;
                }
                if(realCap>maxCap){
                    maxCap=realCap;
                }
                capSum+=realCap;
                size++;
            }

            avgCap = capSum/size;

            analysisMonField.setBattGroupId(battGroupId);
            analysisMonField.setBattGroupName(capDTOList.get(0).getBattGroupName());
            analysisMonField.setStationName(capDTOList.get(0).getStationName());
            analysisMonField.setMinMonCap(minCap);
            analysisMonField.setMaxMonCap(maxCap);
            analysisMonField.setAvgMonCap(avgCap);
            //将统计数据放到数组中
            analysisMonFieldList.add(analysisMonField);
        }

        return analysisMonFieldList;
    }

    public Response getMonVol(Integer userId) {
        HashMap<String, Object> resMap = new HashMap<>();
        List<BatteryInfo> batteryInfos =  testDataMapper.getStationAndBatteryGroupIds(userId);
        /*List<BatteryInfo> batteryInfos =  testDataMapper.getStationAndBatteryGroupIds(userId);
        for (BatteryInfo temp:batteryInfos) {
            //根据BattGroupIds查询到对应的数值
            String[] batteryGroupIds = temp.getBatteryGroupIds().split(",");
@@ -121,13 +214,17 @@
            }
            DataAnalysisFloatDTO dataStatistics = testDataMapper.getStatisticsByBattGroupIds(ids,"mon_vol");
            resMap.put(temp.getStationName(),dataStatistics);
        }
        return new Response<>().set(1,resMap);
        }*/

        //查询单体电压数据
        List<AnalysisMonFieldDTO> monFields = monFieldMapper.getMonField("tb_mon_vol",userId);

        return new Response<>().set(1,monFields);
    }

    public Response getMonTemp(Integer userId) {
        HashMap<String, Object> resMap = new HashMap<>();
        List<BatteryInfo> batteryInfos =  testDataMapper.getStationAndBatteryGroupIds(userId);
        /*List<BatteryInfo> batteryInfos =  testDataMapper.getStationAndBatteryGroupIds(userId);
        for (BatteryInfo temp:batteryInfos) {
            //根据BattGroupIds查询到对应的数值
            String[] batteryGroupIds = temp.getBatteryGroupIds().split(",");
@@ -137,13 +234,18 @@
            }
            DataAnalysisFloatDTO dataStatistics = testDataMapper.getStatisticsByBattGroupIds(ids,"mon_tmp");
            resMap.put(temp.getStationName(),dataStatistics);
        }
        return new Response<>().set(1,resMap);
        }*/

        //查询单体温度数据
        List<AnalysisMonFieldDTO> monFields = monFieldMapper.getMonField("tb_mon_tmp",userId);


        return new Response<>().set(1,monFields);
    }

    public Response getMonRes(Integer userId) {
        HashMap<String, Object> resMap = new HashMap<>();
        List<BatteryInfo> batteryInfos =  resMapper.getResStationAndBatteryGroupIds(userId);
        /*List<BatteryInfo> batteryInfos =  resMapper.getResStationAndBatteryGroupIds(userId);
        for (BatteryInfo temp:batteryInfos) {
            //根据BattGroupIds查询到对应的数值
            String[] batteryGroupIds = temp.getBatteryGroupIds().split(",");
@@ -153,12 +255,16 @@
            }
            DataAnalysisFloatDTO dataStatistics = resMapper.getResStatisticsByBattGroupIds(ids);
            resMap.put(temp.getStationName(),dataStatistics);
        }
        return new Response<>().set(1,resMap);
        }*/

        //查询单体内阻数据
        List<AnalysisMonFieldDTO> monFields = monFieldMapper.getMonField("tb_mon_res",userId);

        return new Response<>().set(1,monFields);
    }

    public Response getMonCap(Integer userId) {
        HashMap<String, Object> resMap = new HashMap<>();
        /*HashMap<String, Object> resMap = new HashMap<>();
        List<BatteryInfo> batteryInfos =  testDataMapper.getStationAndBatteryGroupIds(userId);
        for (BatteryInfo temp:batteryInfos) {
            String[] batteryGroupIds = temp.getBatteryGroupIds().split(",");
@@ -181,12 +287,13 @@

            List<Double> minMonCapList =new LinkedList<>();
            List<Double> maxMonCapList =new LinkedList<>();
            List<Double> avgMonCapList =new LinkedList<>();

            for(BatteryInfo monData:batteryStatisticList){
                //求每个单体容量的最值
                //获取最小单体实际容量
                for (int i = 0; i < batteryStdList.size(); i++) {
                    if(batteryStdList.get(i).getBatteryGroupId()==monData.getBatteryGroupId()){
                    if(batteryStdList.get(i).getBatteryGroupId().intValue()==monData.getBatteryGroupId()){

                        int hourRateMin = BattCapFactory.GetHourRate(batteryStdList.get(i).getMonCapStd(), monData.getMinTestCurr());
                        double monRealCapMin = BattCapFactory.GetMonomerCap(batteryStdList.get(i).getMonCapStd(), hourRateMin, monData.getMinTestCap(), monData.getMaxMonVol(), monData.getMinMonVol(), batteryStdList.get(i).getMonVolStd(), BattCapFactory.CapType_Real);
@@ -213,13 +320,23 @@
            avgMonCap=Double.parseDouble(decimalFormat.format(avgMonCap));

            //单体容量
            /*minCapList.add(minMonCap);
            maxCapList.add(maxMonCap);
            averageCapList.add(avgMonCap);*/
            minMonCapList.add(minMonCap);
            maxMonCapList.add(maxMonCap);
            avgMonCapList.add(avgMonCap);

            List<List> capList = new LinkedList<>();
            capList.add(minMonCapList);
            capList.add(maxMonCapList);
            capList.add(avgMonCapList);
            
            resMap.put(temp.getStationName(),null);
        }
        return new Response<>().set(1,resMap);
            resMap.put(temp.getStationName(),capList);
        }*/
        //return new Response<>().set(1,resMap);

        //查询单体电压数据
        List<AnalysisMonFieldDTO> monFields = monFieldMapper.getMonField("tb_mon_cap",userId);

        return new Response<>().set(1,monFields);

    }

@@ -273,5 +390,4 @@
        Map map = enduranceAnalysis(batteryEnduranceList, timeList);

    }

}

 src/main/resources/mapper/AnalysisMonFieldMapper.xml

New file
@@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.whyc.mapper.AnalysisMonFieldMapper" >

    <insert id="insertBatch">
        insert into db_analysis.${tableName} values
        <foreach collection="analysisMonFieldList" item="monField" open="(" separator="),(" close=")">
            null,#{monField.battGroupId},#{monField.minMon${fieldStr}},#{monField.maxMon${fieldStr}},#{monField.avgMon${fieldStr}},now()
        </foreach>
    </insert>
    <select id="getMonField" resultType="com.whyc.dto.AnalysisMonFieldDTO">
        select at.*,bInf.StationName as stationName,bInf.BattGroupName as battGroupName from db_analysis.${tableName} at,db_battinf.tb_battinf bInf
        where at.batt_group_id = bInf.battGroupId
        and at.batt_group_id IN (
        SELECT DISTINCT
        db_battinf.tb_battinf.battgroupid
        FROM
        db_battinf.tb_battinf,
        db_user.tb_user_battgroup_baojigroup_battgroup,
        db_user.tb_user_battgroup_baojigroup_usr,
        db_user.tb_user_inf
        WHERE
        db_user.tb_user_battgroup_baojigroup_battgroup.BattGroupId = db_battinf.tb_battinf.BattGroupId
        AND db_user.tb_user_battgroup_baojigroup_usr.baoji_group_id = db_user.tb_user_battgroup_baojigroup_battgroup.baoji_group_id
        AND db_user.tb_user_inf.uid = db_user.tb_user_battgroup_baojigroup_usr.uid
        AND db_user.tb_user_inf.uid =#{userId}
        )
    </select>
</mapper>

 src/main/resources/mapper/BatteryResDataMapper.xml

@@ -29,10 +29,9 @@
        GROUP BY
            StationId
    </select>
    <select id="getResStatisticsByBattGroupIds" resultType="com.whyc.dto.DataAnalysisFloatDTO">
        select min(mon_res) as 'min',max(mon_res) as 'max',avg(mon_res) as 'average' from
        <foreach collection="array" item="batteryGroupId" separator="union" open="(" close=")temp">
            select mon_res  from db_batt_testdata.tb_battresdata_#{batteryGroupId}
    <select id="getResStatisticsByTableNames" resultType="com.whyc.dto.AnalysisMonFieldDTO">
        <foreach collection="tableNames" item="tableName" separator=") union (" open="(" close=")">
            select min(mon_res) as 'minMonRes',max(mon_res) as 'maxMonRes',avg(mon_res) as 'avgMonRes',BattGroupId as batt_group_id  from db_batt_testdata.${tableName}
        </foreach>
    </select>
</mapper>

 src/main/resources/mapper/BatteryTestDataMapper.xml

@@ -29,10 +29,9 @@
        GROUP BY
            StationId
    </select>
    <select id="getStatisticsByBattGroupIds" resultType="com.whyc.dto.DataAnalysisFloatDTO">
        select min(${field}) as 'min',max(${field}) as 'max',avg(${field}) as 'average' from
        <foreach collection="ids" item="batteryGroupId" separator="union" open="(" close=")temp">
            select ${field}  from db_batt_testdata.tb_batttestdata_#{batteryGroupId}
    <select id="getStatisticsByTableNames" resultType="com.whyc.dto.AnalysisMonFieldDTO">
        <foreach collection="tableNames" item="tableName" separator=") union (" open="(" close=")">
        select min(${fieldName1}) as 'min_${fieldName1}',max(${fieldName1}) as 'max_${fieldName1}',avg(${fieldName1}) as 'avg_${fieldName1}',min(${fieldName2}) as 'min_${fieldName2}',max(${fieldName2}) as 'max_${fieldName2}',avg(${fieldName2}) as 'avg_${fieldName2}',BattGroupId as batt_group_id from db_batt_testdata.${tableName}
        </foreach>
    </select>

@@ -42,25 +41,40 @@
            #{id}
        </foreach>
    </select>
    <select id="getCapStatisticsByBattGroupIds" resultType="com.whyc.dto.BatteryInfo">
        <foreach collection="array" item="id" separator=")union(" open="(" close=")">
    <select id="getCapStatisticsByGroupIds" resultType="com.whyc.dto.AnalysisMonCapDTO">
        <foreach collection="groupIds" item="groupId" separator=")union(" open="(" close=")">
            SELECT
                BattGroupId as batteryGroupId,
                max( abs( test_curr ) ) maxTestCurr,
                min( abs( test_curr ) ) minTestCurr,
                avg( abs( test_curr ) ) avgTestCurr,
                max( abs( test_cap ) ) maxTestCap,
                min( abs( test_cap ) ) minTestCap,
                avg( abs( test_cap ) ) avgTestCap,
                min( abs( mon_vol ) ) minMonVol,
                max( mon_vol ) maxMonVol
                ds.BattGroupId as batt_group_id,
                ds.test_curr,
                ds.test_cap,
                ds.mon_vol,
                ds.test_record_count,
                ds.mon_num,
                inf.max_monvol as max_mon_vol,
                bInf.moncapstd,
                bInf.monvolstd,
                binf.BattGroupName as battGroupName,
                binf.StationName as stationName
            FROM
                db_batt_testdata.tb_batttestdata_#{id}
            where
                test_type=3
            group by
                mon_num
            order by null
                db_batt_testdata.tb_batttestdatastop_${groupId} ds,
                db_batt_testdata.tb_batttestdata_inf inf,
                db_battinf.tb_battinf bInf
            where ds.BattGroupId=inf.BattGroupId
            and ds.BattGroupId=bInf.BattGroupId
            and  ds.test_starttime=inf.test_starttime
            and ds.test_record_count = (select max(test_record_count) from db_batt_testdata.tb_batttestdatastop_${groupId} where test_type=3 and data_available=1)
        </foreach>
    </select>
    <select id="getRestCapByCondition" resultType="java.lang.Double">
        select
            test_cap
        FROM
            db_batt_testdata.tb_batttestdata_${battGroupId}
        where test_record_count=#{testRecordCount}
        and mon_vol>=#{monVol}
        and mon_num=#{monNum}
        and data_available=1
        order by record_time DESC
        limit 1
    </select>
</mapper>

 src/main/resources/mapper/DBMapper.xml

New file
@@ -0,0 +1,23 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.whyc.mapper.DBMapper" >
    <update id="createDB">
        CREATE SCHEMA ${value} DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin ;
    </update>
    <update id="createTable">
        ${value}
    </update>
    <delete id="deleteAll">
        delete from ${dbName}.${tableName}
    </delete>

    <select id="DBExist" resultType="java.lang.String">
        select TABLE_SCHEMA from information_schema.tables where TABLE_SCHEMA=#{param1} limit 1
    </select>
    <select id="tableExist" resultType="java.lang.String">
        select TABLE_SCHEMA from information_schema.tables where TABLE_SCHEMA=#{param1} and TABLE_NAME=#{param2} limit 1
    </select>
    <select id="getTableNames" resultType="com.whyc.pojo.Tables">
        select TABLE_SCHEMA,TABLE_NAME from information_schema.tables where TABLE_SCHEMA=#{param1} and TABLE_NAME regexp #{param2}
    </select>
</mapper>