devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于springboot仓库管理系统源码和论文_基于springboot的仓库管理系统的论文

作者：知新_RL | 2024-05-17 14:33:15

赞

踩

基于springboot的仓库管理系统的论文

信息内容数据从传统到当今，一直在改变，忽然互联网技术让传统信息内容管理见到划时代的黎明，由于传统信息内容管理从时效性、安全系数、可执行性等多个方面，碰到互联网时代发觉弥补了从古至今的缺陷，有效提升管理效率工作能力。在传统的管理模式中，时间越长，管理具体内容越大，需要更多人梳理数据，数据归纳查看高效率非常低，数据安全性从来不会确保安全系数。融合数据具体内容管理的缺陷，在互联网时代能够得到很好的填补。融合前沿的大数据技术，开发设计满足要求的app，使数据具体内容管理可以最大程度地提升准确率，管理更科学便捷，不论是输入时效性、查询的时效性或是梳理总结的时效性。库房管理系统进行了字典管理、公告管理、老师管理、物资供应管理、物资申请管理、用户管理、等服务。设备采用关联数据库里的MySQL做为全面的数据库，合理存放数据，合理备份数据，确保数据稳定性。除此之外，程序流程还具备程序流程所需要的所有功能，大大提升了实际操作安全度，使库房管理系统软件从概念迈向实际，真真正正提升了信息资源管理效率。

关键字：信息管理，时效性，安全性，MySQL

基于springboot仓库管理系统源码和论文442


Abstract

Information data has been changing from traditional to contemporary, and the sudden Internet has allowed traditional information management to see a revolutionary dawn, because traditional information management is in terms of timeliness, security, or operability. It was only after encountering the Internet era that it was able to make up for the shortcomings since ancient times, and effectively improve the management efficiency and business level. The traditional management model, the longer the time, the more content is managed, and more people are needed to organize the data, and the efficiency of data aggregation and query is extremely low, and data security will never guarantee security performance. Combined with various shortcomings of data content management, they can be effectively supplemented in the Internet era. Combined with advanced Internet technology, develop software that meets the needs, so that the data content management can maximize the accuracy rate from the timeliness of entry, the timeliness of viewing, and the timeliness of summary analysis. The train ticket selling system developed this time has realized the functions of online booking, online payment, online change of ticket, and online refund of train tickets. The system uses MySQL, the king of the relational database, as the system database, which effectively stores the data safely and effectively backs up, ensuring the reliability of the data. And the program also has all the functions required by the program, which greatly improves the operability or security, so that the train ticket sales system can go from concept to reality, and it really allows people to improve the efficiency of information processing.

Key Words：Information management, timeliness, security, MySQL

 

  1. package com.controller;
  2.  
  3. import java.io.*;
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.SQLException;
  7. import java.text.SimpleDateFormat;
  8. import java.util.*;
  9.  
  10. import javax.servlet.http.HttpServletRequest;
  11.  
  12. import com.alibaba.fastjson.JSON;
  13. import com.utils.StringUtil;
  14. import org.apache.commons.lang3.StringUtils;
  15. import org.json.JSONObject;
  16. import org.slf4j.Logger;
  17. import org.slf4j.LoggerFactory;
  18. import org.springframework.beans.factory.annotation.Autowired;
  19. import org.springframework.beans.factory.annotation.Value;
  20. import org.springframework.util.ResourceUtils;
  21. import org.springframework.web.bind.annotation.PathVariable;
  22. import org.springframework.web.bind.annotation.RequestBody;
  23. import org.springframework.web.bind.annotation.RequestMapping;
  24. import org.springframework.web.bind.annotation.RequestParam;
  25. import org.springframework.web.bind.annotation.RestController;
  26.  
  27. import com.annotation.IgnoreAuth;
  28. import com.baidu.aip.face.AipFace;
  29. import com.baidu.aip.face.MatchRequest;
  30. import com.baidu.aip.util.Base64Util;
  31. import com.baomidou.mybatisplus.mapper.EntityWrapper;
  32. import com.baomidou.mybatisplus.mapper.Wrapper;
  33. import com.entity.ConfigEntity;
  34. import com.service.CommonService;
  35. import com.service.ConfigService;
  36. import com.utils.BaiduUtil;
  37. import com.utils.FileUtil;
  38. import com.utils.R;
  39.  
  40. /**
  41.  * 通用接口
  42.  */
  43. @RestController
  44. public class CommonController {
  45.     private static final Logger logger = LoggerFactory.getLogger(CommonController.class);
  46.     @Autowired
  47.     private CommonService commonService;
  48.  
  49.  
  50.     /**
  51.      * Java代码实现MySQL数据库导出
  52.      *
  53.      * @param mysqlUrl     MySQL安装路径
  54.      * @param hostIP       MySQL数据库所在服务器地址IP
  55.      * @param userName     进入数据库所需要的用户名
  56.      * @param hostPort     数据库端口
  57.      * @param password     进入数据库所需要的密码
  58.      * @param savePath     数据库文件保存路径
  59.      * @param fileName     数据库导出文件文件名
  60.      * @param databaseName 要导出的数据库名
  61.      * @return 返回true表示导出成功，否则返回false。
  62.      */
  63.     @IgnoreAuth
  64.     @RequestMapping("/beifen")
  65.     public R beifen(String mysqlUrl, String hostIP, String userName, String hostPort, String password, String savePath, String fileName, String databaseName) {
  66.         File saveFile = new File(savePath);
  67.         if (!saveFile.exists()) {// 如果目录不存在 
  68.             saveFile.mkdirs();// 创建文件夹 
  69.         }
  70.         if (!savePath.endsWith(File.separator)) {
  71.             savePath = savePath + File.separator;
  72.         }
  73.         PrintWriter printWriter = null;
  74.         BufferedReader bufferedReader = null;
  75.         try {
  76.             Runtime runtime = Runtime.getRuntime();
  77.             String cmd = mysqlUrl + "mysqldump -h" + hostIP + " -u" + userName + " -P" + hostPort + " -p" + password + " " + databaseName;
  78.             runtime.exec(cmd);
  79.             Process process = runtime.exec(cmd);
  80.             InputStreamReader inputStreamReader = new InputStreamReader(process.getInputStream(), "utf8");
  81.             bufferedReader = new BufferedReader(inputStreamReader);
  82.             printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(savePath + fileName), "utf8"));
  83.             String line;
  84.             while ((line = bufferedReader.readLine()) != null) {
  85.                 printWriter.println(line);
  86.             }
  87.             printWriter.flush();
  88.         } catch (Exception e) {
  89.             e.printStackTrace();
  90.             return R.error("备份数据出错");
  91.         } finally {
  92.             try {
  93.                 if (bufferedReader != null) {
  94.                     bufferedReader.close();
  95.                 }
  96.                 if (printWriter != null) {
  97.                     printWriter.close();
  98.                 }
  99.             } catch (Exception e) {
  100.                 e.printStackTrace();
  101.             }
  102.         }
  103.         return R.ok();
  104.     }
  105.  
  106.     /**
  107.      * Java实现MySQL数据库导入
  108.      *
  109.      * @param mysqlUrl     MySQL安装路径
  110.      * @param hostIP       MySQL数据库所在服务器地址IP
  111.      * @param userName     进入数据库所需要的用户名
  112.      * @param hostPort     数据库端口
  113.      * @param password     进入数据库所需要的密码
  114.      * @param savePath     数据库文件保存路径
  115.      * @param fileName     数据库导出文件文件名
  116.      * @param databaseName 要导出的数据库名
  117.      */
  118.     @IgnoreAuth
  119.     @RequestMapping("/huanyuan")
  120.     public R huanyuan(String mysqlUrl, String hostIP, String userName, String hostPort, String password, String savePath, String fileName, String databaseName) {
  121.         try {
  122.             Runtime rt = Runtime.getRuntime();
  123.             Process child1 = rt.exec(mysqlUrl+"mysql.exe  -h" + hostIP + " -u" + userName + " -P" + hostPort + " -p" + password + " " + databaseName);
  124.             OutputStream out = child1.getOutputStream();//控制台的输入信息作为输出流
  125.             String inStr;
  126.             StringBuffer sb = new StringBuffer("");
  127.             String outStr;
  128.             BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(savePath+"/"+fileName), "utf-8"));
  129.             while ((inStr = br.readLine()) != null) {
  130.                 sb.append(inStr + "\r\n");
  131.             }
  132.             outStr = sb.toString();
  133.             OutputStreamWriter writer = new OutputStreamWriter(out, "utf8");
  134.             writer.write(outStr);
  135. // 注：这里如果用缓冲方式写入文件的话，会导致中文乱码，用flush()方法则可以避免
  136.             writer.flush();
  137.             out.close();
  138.             br.close();
  139.             writer.close();
  140.         } catch (Exception e) {
  141.             e.printStackTrace();
  142.             return R.error("数据导入出错");
  143.         }
  144.         return R.ok();
  145.     }
  146.  
  147.  
  148.     /**
  149.      * 饼状图求和
  150.      * @return
  151.      */
  152.     @RequestMapping("/pieSum")
  153.     public R pieSum(@RequestParam Map<String,Object> params) {
  154.         logger.debug("饼状图求和:,,Controller:{},,params:{}",this.getClass().getName(),params);
  155.         List<Map<String, Object>> result = commonService.pieSum(params);
  156.         return R.ok().put("data", result);
  157.     }
  158.  
  159.     /**
  160.      * 饼状图统计
  161.      * @return
  162.      */
  163.     @RequestMapping("/pieCount")
  164.     public R pieCount(@RequestParam Map<String,Object> params) {
  165.         logger.debug("饼状图统计:,,Controller:{},,params:{}",this.getClass().getName(),params);
  166.         List<Map<String, Object>> result = commonService.pieCount(params);
  167.         return R.ok().put("data", result);
  168.     }
  169.  
  170.     /**
  171.      * 柱状图求和单列
  172.      * @return
  173.      */
  174.     @RequestMapping("/barSumOne")
  175.     public R barSumOne(@RequestParam Map<String,Object> params) {
  176.         logger.debug("柱状图求和单列:,,Controller:{},,params:{}",this.getClass().getName(),params);
  177.         List<Map<String, Object>> result = commonService.barSumOne(params);
  179.         List<String> xAxis = new ArrayList<>();//报表x轴
  180.         List<List<String>> yAxis = new ArrayList<>();//y轴
  181.         List<String> legend = new ArrayList<>();//标题
  182.         List<String> yAxis0 = new ArrayList<>();
  183.         yAxis.add(yAxis0);
  184.         legend.add("");
  185.         for(Map<String, Object> map :result){
  186.             String oneValue = String.valueOf(map.get("name"));
  187.             String value = String.valueOf(map.get("value"));
  188.             xAxis.add(oneValue);
  189.             yAxis0.add(value);
  190.         }
  191.         Map<String, Object> resultMap = new HashMap<>();
  192.         resultMap.put("xAxis",xAxis);
  193.         resultMap.put("yAxis",yAxis);
  194.         resultMap.put("legend",legend);
  195.         return R.ok().put("data", resultMap);
  196.     }
  197.     /**
  198.      * 柱状图统计单列
  199.      * @return
  200.      */
  201.     @RequestMapping("/barCountOne")
  202.     public R barCountOne(@RequestParam Map<String,Object> params) {
  203.         logger.debug("柱状图统计单列:,,Controller:{},,params:{}",this.getClass().getName(),params);
  204.         List<Map<String, Object>> result = commonService.barCountOne(params);
  206.         List<String> xAxis = new ArrayList<>();//报表x轴
  207.         List<List<String>> yAxis = new ArrayList<>();//y轴
  208.         List<String> legend = new ArrayList<>();//标题
  209.  
  210.         List<String> yAxis0 = new ArrayList<>();
  211.         yAxis.add(yAxis0);
  212.         legend.add("");
  213.         for(Map<String, Object> map :result){
  214.             String oneValue = String.valueOf(map.get("name"));
  215.             String value = String.valueOf(map.get("value"));
  216.             xAxis.add(oneValue);
  217.             yAxis0.add(value);
  218.         }
  219.         Map<String, Object> resultMap = new HashMap<>();
  220.         resultMap.put("xAxis",xAxis);
  221.         resultMap.put("yAxis",yAxis);
  222.         resultMap.put("legend",legend);
  223.         return R.ok().put("data", resultMap);
  224.     }
  225.  
  226.     /**
  227.      * 柱状图统计双列
  228.      * @return
  229.      */
  230.     @RequestMapping("/barSumTwo")
  231.     public R barSumTwo(@RequestParam Map<String,Object> params) {
  232.         logger.debug("柱状图统计双列:,,Controller:{},,params:{}",this.getClass().getName(),params);
  233.         List<Map<String, Object>> result = commonService.barSumTwo(params);
  234.         List<String> xAxis = new ArrayList<>();//报表x轴
  235.         List<List<String>> yAxis = new ArrayList<>();//y轴
  236.         List<String> legend = new ArrayList<>();//标题
  237.  
  238.         Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
  239.         for(Map<String, Object> map :result){
  240.             String name1Value = String.valueOf(map.get("name1"));
  241.             String name2Value = String.valueOf(map.get("name2"));
  242.             String value = String.valueOf(map.get("value"));
  243.             if(!legend.contains(name2Value)){
  244.                 legend.add(name2Value);//添加完成后 就是最全的第二列的类型
  245.             }
  246.             if(dataMap.containsKey(name1Value)){
  247.                 dataMap.get(name1Value).put(name2Value,value);
  248.             }else{
  249.                 HashMap<String, String> name1Data = new HashMap<>();
  250.                 name1Data.put(name2Value,value);
  251.                 dataMap.put(name1Value,name1Data);
  252.             }
  253.  
  254.         }
  255.  
  256.         for(int i =0; i<legend.size(); i++){
  257.             yAxis.add(new ArrayList<String>());
  258.         }
  259.  
  260.         Set<String> keys = dataMap.keySet();
  261.         for(String key:keys){
  262.             xAxis.add(key);
  263.             HashMap<String, String> map = dataMap.get(key);
  264.             for(int i =0; i<legend.size(); i++){
  265.                 List<String> data = yAxis.get(i);
  266.                 if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
  267.                     data.add(map.get(legend.get(i)));
  268.                 }else{
  269.                     data.add("0");
  270.                 }
  271.             }
  272.         }
  273.         System.out.println();
  274.  
  275.         Map<String, Object> resultMap = new HashMap<>();
  276.         resultMap.put("xAxis",xAxis);
  277.         resultMap.put("yAxis",yAxis);
  278.         resultMap.put("legend",legend);
  279.         return R.ok().put("data", resultMap);
  280.     }
  281.     /**
  282.      * 柱状图统计双列
  283.      * @return
  284.      */
  285.     @RequestMapping("/barCountTwo")
  286.     public R barCountTwo(@RequestParam Map<String,Object> params) {
  287.         logger.debug("柱状图统计双列:,,Controller:{},,params:{}",this.getClass().getName(),params);
  288.         List<Map<String, Object>> result = commonService.barCountTwo(params);
  289.         List<String> xAxis = new ArrayList<>();//报表x轴
  290.         List<List<String>> yAxis = new ArrayList<>();//y轴
  291.         List<String> legend = new ArrayList<>();//标题
  292.  
  293.         Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
  294.         for(Map<String, Object> map :result){
  295.             String name1Value = String.valueOf(map.get("name1"));
  296.             String name2Value = String.valueOf(map.get("name2"));
  297.             String value = String.valueOf(map.get("value"));
  298.             if(!legend.contains(name2Value)){
  299.                 legend.add(name2Value);//添加完成后 就是最全的第二列的类型
  300.             }
  301.             if(dataMap.containsKey(name1Value)){
  302.                 dataMap.get(name1Value).put(name2Value,value);
  303.             }else{
  304.                 HashMap<String, String> name1Data = new HashMap<>();
  305.                 name1Data.put(name2Value,value);
  306.                 dataMap.put(name1Value,name1Data);
  307.             }
  308.  
  309.         }
  310.  
  311.         for(int i =0; i<legend.size(); i++){
  312.             yAxis.add(new ArrayList<String>());
  313.         }
  314.  
  315.         Set<String> keys = dataMap.keySet();
  316.         for(String key:keys){
  317.             xAxis.add(key);
  318.             HashMap<String, String> map = dataMap.get(key);
  319.             for(int i =0; i<legend.size(); i++){
  320.                 List<String> data = yAxis.get(i);
  321.                 if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
  322.                     data.add(map.get(legend.get(i)));
  323.                 }else{
  324.                     data.add("0");
  325.                 }
  326.             }
  327.         }
  328.         System.out.println();
  329.  
  330.         Map<String, Object> resultMap = new HashMap<>();
  331.         resultMap.put("xAxis",xAxis);
  332.         resultMap.put("yAxis",yAxis);
  333.         resultMap.put("legend",legend);
  334.         return R.ok().put("data", resultMap);
  335.     }
  336.  
  337.     /**
  338.      tableName 查询表
  339.      condition1 条件1
  340.      condition1Value 条件1值
  341.      average 计算平均评分
  342.  
  343.      取值
  344.      有值 Number(res.data.value.toFixed(1))
  345.      无值 if(res.data){}
  346.      * */
  347.     @IgnoreAuth
  348.     @RequestMapping("/queryScore")
  349.     public R queryScore(@RequestParam Map<String, Object> params) {
  350.         logger.debug("queryScore:,,Controller:{},,params:{}",this.getClass().getName(),params);
  351.         Map<String, Object> queryScore = commonService.queryScore(params);
  352.         return R.ok().put("data", queryScore);
  353.     }
  354.  
  355.     /**
  356.      * 查询字典表的分组统计总条数
  357.      *  tableName  		表名
  358.      *	groupColumn  	分组字段
  359.      * @return
  360.      */
  361.     @RequestMapping("/newSelectGroupCount")
  362.     public R newSelectGroupCount(@RequestParam Map<String,Object> params) {
  363.         logger.debug("newSelectGroupCount:,,Controller:{},,params:{}",this.getClass().getName(),params);
  364.         List<Map<String, Object>> result = commonService.newSelectGroupCount(params);
  365.         return R.ok().put("data", result);
  366.     }
  367.  
  368.     /**
  369.      * 查询字典表的分组求和
  370.      * tableName  		表名
  371.      * groupColumn  		分组字段
  372.      * sumCloum			统计字段
  373.      * @return
  374.      */
  375.     @RequestMapping("/newSelectGroupSum")
  376.     public R newSelectGroupSum(@RequestParam Map<String,Object> params) {
  377.         logger.debug("newSelectGroupSum:,,Controller:{},,params:{}",this.getClass().getName(),params);
  378.         List<Map<String, Object>> result = commonService.newSelectGroupSum(params);
  379.         return R.ok().put("data", result);
  380.     }
  381.  
  382.     /**
  383.      * 柱状图求和 老的
  384.      */
  385.     @RequestMapping("/barSum")
  386.     public R barSum(@RequestParam Map<String,Object> params) {
  387.         logger.debug("barSum方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params));
  388.         Boolean isJoinTableFlag =  false;//是否有级联表相关
  389.         String one =  "";//第一优先
  390.         String two =  "";//第二优先
  391.  
  392.         //处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组
  393.         //当前表
  394.         Map<String,Object> thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class);
  395.         params.put("thisTable",thisTable);
  396.  
  397.         //级联表
  398.         String joinTableString = String.valueOf(params.get("joinTable"));
  399.         if(StringUtil.isNotEmpty(joinTableString)) {
  400.             Map<String, Object> joinTable = JSON.parseObject(joinTableString, Map.class);
  401.             params.put("joinTable", joinTable);
  402.             isJoinTableFlag = true;
  403.         }
  404.  
  405.         if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))){//当前表日期
  406.             thisTable.put("date",String.valueOf(thisTable.get("date")).split(","));
  407.             one = "thisDate0";
  408.         }
  409.         if(isJoinTableFlag){//级联表日期
  410.             Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
  411.             if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("date")))){
  412.                 joinTable.put("date",String.valueOf(joinTable.get("date")).split(","));
  413.                 if(StringUtil.isEmpty(one)){
  414.                     one ="joinDate0";
  415.                 }else{
  416.                     if(StringUtil.isEmpty(two)){
  417.                         two ="joinDate0";
  418.                     }
  419.                 }
  420.             }
  421.         }
  422.         if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("string")))){//当前表字符串
  423.             thisTable.put("string",String.valueOf(thisTable.get("string")).split(","));
  424.             if(StringUtil.isEmpty(one)){
  425.                 one ="thisString0";
  426.             }else{
  427.                 if(StringUtil.isEmpty(two)){
  428.                     two ="thisString0";
  429.                 }
  430.             }
  431.         }
  432.         if(isJoinTableFlag){//级联表字符串
  433.             Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
  434.             if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("string")))){
  435.                 joinTable.put("string",String.valueOf(joinTable.get("string")).split(","));
  436.                 if(StringUtil.isEmpty(one)){
  437.                     one ="joinString0";
  438.                 }else{
  439.                     if(StringUtil.isEmpty(two)){
  440.                         two ="joinString0";
  441.                     }
  442.                 }
  443.             }
  444.         }
  445.         if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("types")))){//当前表类型
  446.             thisTable.put("types",String.valueOf(thisTable.get("types")).split(","));
  447.             if(StringUtil.isEmpty(one)){
  448.                 one ="thisTypes0";
  449.             }else{
  450.                 if(StringUtil.isEmpty(two)){
  451.                     two ="thisTypes0";
  452.                 }
  453.             }
  454.         }
  455.         if(isJoinTableFlag){//级联表类型
  456.             Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
  457.             if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("types")))){
  458.                 joinTable.put("types",String.valueOf(joinTable.get("types")).split(","));
  459.                 if(StringUtil.isEmpty(one)){
  460.                     one ="joinTypes0";
  461.                 }else{
  462.                     if(StringUtil.isEmpty(two)){
  463.                         two ="joinTypes0";
  464.                     }
  465.                 }
  466.  
  467.             }
  468.         }
  469.  
  470.         List<Map<String, Object>> result = commonService.barSum(params);
  472.         List<String> xAxis = new ArrayList<>();//报表x轴
  473.         List<List<String>> yAxis = new ArrayList<>();//y轴
  474.         List<String> legend = new ArrayList<>();//标题
  475.  
  476.         if(StringUtil.isEmpty(two)){//不包含第二列
  477.             List<String> yAxis0 = new ArrayList<>();
  478.             yAxis.add(yAxis0);
  479.             legend.add("");
  480.             for(Map<String, Object> map :result){
  481.                 String oneValue = String.valueOf(map.get(one));
  482.                 String value = String.valueOf(map.get("value"));
  483.                 xAxis.add(oneValue);
  484.                 yAxis0.add(value);
  485.             }
  486.         }else{//包含第二列
  487.             Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
  488.             if(StringUtil.isNotEmpty(two)){
  489.                 for(Map<String, Object> map :result){
  490.                     String oneValue = String.valueOf(map.get(one));
  491.                     String twoValue = String.valueOf(map.get(two));
  492.                     String value = String.valueOf(map.get("value"));
  493.                     if(!legend.contains(twoValue)){
  494.                         legend.add(twoValue);//添加完成后 就是最全的第二列的类型
  495.                     }
  496.                     if(dataMap.containsKey(oneValue)){
  497.                         dataMap.get(oneValue).put(twoValue,value);
  498.                     }else{
  499.                         HashMap<String, String> oneData = new HashMap<>();
  500.                         oneData.put(twoValue,value);
  501.                         dataMap.put(oneValue,oneData);
  502.                     }
  503.  
  504.                 }
  505.             }
  506.  
  507.             for(int i =0; i<legend.size(); i++){
  508.                 yAxis.add(new ArrayList<String>());
  509.             }
  510.  
  511.             Set<String> keys = dataMap.keySet();
  512.             for(String key:keys){
  513.                 xAxis.add(key);
  514.                 HashMap<String, String> map = dataMap.get(key);
  515.                 for(int i =0; i<legend.size(); i++){
  516.                     List<String> data = yAxis.get(i);
  517.                     if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
  518.                         data.add(map.get(legend.get(i)));
  519.                     }else{
  520.                         data.add("0");
  521.                     }
  522.                 }
  523.             }
  524.             System.out.println();
  525.         }
  526.  
  527.         Map<String, Object> resultMap = new HashMap<>();
  528.         resultMap.put("xAxis",xAxis);
  529.         resultMap.put("yAxis",yAxis);
  530.         resultMap.put("legend",legend);
  531.         return R.ok().put("data", resultMap);
  532.     }
  533.  
  534.     /**
  535.      * 柱状图统计 老的
  536.      */
  537.     @RequestMapping("/barCount")
  538.     public R barCount(@RequestParam Map<String,Object> params) {
  539.         logger.debug("barCount方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params));
  540.         Boolean isJoinTableFlag =  false;//是否有级联表相关
  541.         String one =  "";//第一优先
  542.         String two =  "";//第二优先
  543.  
  544.         //处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组
  545.         //当前表
  546.         Map<String,Object> thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class);
  547.         params.put("thisTable",thisTable);
  548.  
  549.         //级联表
  550.         String joinTableString = String.valueOf(params.get("joinTable"));
  551.         if(StringUtil.isNotEmpty(joinTableString)) {
  552.             Map<String, Object> joinTable = JSON.parseObject(joinTableString, Map.class);
  553.             params.put("joinTable", joinTable);
  554.             isJoinTableFlag = true;
  555.         }
  556.  
  557.         if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))){//当前表日期
  558.             thisTable.put("date",String.valueOf(thisTable.get("date")).split(","));
  559.             one = "thisDate0";
  560.         }
  561.         if(isJoinTableFlag){//级联表日期
  562.             Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
  563.             if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("date")))){
  564.                 joinTable.put("date",String.valueOf(joinTable.get("date")).split(","));
  565.                 if(StringUtil.isEmpty(one)){
  566.                     one ="joinDate0";
  567.                 }else{
  568.                     if(StringUtil.isEmpty(two)){
  569.                         two ="joinDate0";
  570.                     }
  571.                 }
  572.             }
  573.         }
  574.         if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("string")))){//当前表字符串
  575.             thisTable.put("string",String.valueOf(thisTable.get("string")).split(","));
  576.             if(StringUtil.isEmpty(one)){
  577.                 one ="thisString0";
  578.             }else{
  579.                 if(StringUtil.isEmpty(two)){
  580.                     two ="thisString0";
  581.                 }
  582.             }
  583.         }
  584.         if(isJoinTableFlag){//级联表字符串
  585.             Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
  586.             if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("string")))){
  587.                 joinTable.put("string",String.valueOf(joinTable.get("string")).split(","));
  588.                 if(StringUtil.isEmpty(one)){
  589.                     one ="joinString0";
  590.                 }else{
  591.                     if(StringUtil.isEmpty(two)){
  592.                         two ="joinString0";
  593.                     }
  594.                 }
  595.             }
  596.         }
  597.         if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("types")))){//当前表类型
  598.             thisTable.put("types",String.valueOf(thisTable.get("types")).split(","));
  599.             if(StringUtil.isEmpty(one)){
  600.                 one ="thisTypes0";
  601.             }else{
  602.                 if(StringUtil.isEmpty(two)){
  603.                     two ="thisTypes0";
  604.                 }
  605.             }
  606.         }
  607.         if(isJoinTableFlag){//级联表类型
  608.             Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
  609.             if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("types")))){
  610.                 joinTable.put("types",String.valueOf(joinTable.get("types")).split(","));
  611.                 if(StringUtil.isEmpty(one)){
  612.                     one ="joinTypes0";
  613.                 }else{
  614.                     if(StringUtil.isEmpty(two)){
  615.                         two ="joinTypes0";
  616.                     }
  617.                 }
  618.  
  619.             }
  620.         }
  621.  
  622.         List<Map<String, Object>> result = commonService.barCount(params);
  624.         List<String> xAxis = new ArrayList<>();//报表x轴
  625.         List<List<String>> yAxis = new ArrayList<>();//y轴
  626.         List<String> legend = new ArrayList<>();//标题
  627.  
  628.         if(StringUtil.isEmpty(two)){//不包含第二列
  629.             List<String> yAxis0 = new ArrayList<>();
  630.             yAxis.add(yAxis0);
  631.             legend.add("");
  632.             for(Map<String, Object> map :result){
  633.                 String oneValue = String.valueOf(map.get(one));
  634.                 String value = String.valueOf(map.get("value"));
  635.                 xAxis.add(oneValue);
  636.                 yAxis0.add(value);
  637.             }
  638.         }else{//包含第二列
  639.             Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
  640.             if(StringUtil.isNotEmpty(two)){
  641.                 for(Map<String, Object> map :result){
  642.                     String oneValue = String.valueOf(map.get(one));
  643.                     String twoValue = String.valueOf(map.get(two));
  644.                     String value = String.valueOf(map.get("value"));
  645.                     if(!legend.contains(twoValue)){
  646.                         legend.add(twoValue);//添加完成后 就是最全的第二列的类型
  647.                     }
  648.                     if(dataMap.containsKey(oneValue)){
  649.                         dataMap.get(oneValue).put(twoValue,value);
  650.                     }else{
  651.                         HashMap<String, String> oneData = new HashMap<>();
  652.                         oneData.put(twoValue,value);
  653.                         dataMap.put(oneValue,oneData);
  654.                     }
  655.  
  656.                 }
  657.             }
  658.  
  659.             for(int i =0; i<legend.size(); i++){
  660.                 yAxis.add(new ArrayList<String>());
  661.             }
  662.  
  663.             Set<String> keys = dataMap.keySet();
  664.             for(String key:keys){
  665.                 xAxis.add(key);
  666.                 HashMap<String, String> map = dataMap.get(key);
  667.                 for(int i =0; i<legend.size(); i++){
  668.                     List<String> data = yAxis.get(i);
  669.                     if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
  670.                         data.add(map.get(legend.get(i)));
  671.                     }else{
  672.                         data.add("0");
  673.                     }
  674.                 }
  675.             }
  676.             System.out.println();
  677.         }
  678.  
  679.         Map<String, Object> resultMap = new HashMap<>();
  680.         resultMap.put("xAxis",xAxis);
  681.         resultMap.put("yAxis",yAxis);
  682.         resultMap.put("legend",legend);
  683.         return R.ok().put("data", resultMap);
  684.     }
  685. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/583989
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号