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

基于springboot广场舞团管理系统源码和论文

作者：2023面试高手 | 2024-02-18 09:12:37

赞

踩

基于springboot广场舞团管理系统源码和论文

随着信息技术和网络技术的飞速发展，人类已进入全新信息化时代，传统管理技术已无法高效，便捷地管理信息。为了迎合时代需求，优化管理效率，各种各样的管理系统应运而生，各行各业相继进入信息管理时代，广场舞团就是信息时代变革中的产物之一。

任何系统都要遵循系统设计的基本流程，本系统也不例外，同样需要经过市场调研，需求分析，概要设计，详细设计，编码，测试这些步骤，基于java语言设计并实现了广场舞团。该系统基于B/S即所谓浏览器/服务器模式，应用java技术，选择MySQL作为后台数据库。系统主要包括系统首页，社团，社团活动，交流中心，公告资讯，个人中心，后台管理等功能模块。

本文首先介绍了广场舞团管理的技术发展背景与发展现状，然后遵循软件常规开发流程，首先针对系统选取适用的语言和开发平台，根据需求分析制定模块并设计数据库结构，再根据系统总体功能模块的设计绘制系统的功能模块图，流程图以及E-R图。然后，设计框架并根据设计的框架编写代码以实现系统的各个功能模块。最后，对初步完成的系统进行测试，主要是功能测试、单元测试和性能测试。测试结果表明，该系统能够实现所需的功能，运行状况尚可并无明显缺点。

关键词：广场舞团；java；MySQL数据库

基于springboot广场舞团管理系统源码和论文368

基于springboot广场舞团管理系统源码和论文


Abstract

With the rapid development of information technology and network technology, mankind has entered a new era of information technology, and traditional management technology has been unable to manage information efficiently and conveniently. In order to meet the needs of the times and optimize management efficiency, a variety of management systems came into being, and all walks of life have entered the era of information management, and square dance troupes are one of the products of the change in the information age.

Any system must follow the basic process of system design, this system is no exception, the same need to go through market research, requirements analysis, outline design, detailed design, coding, testing these steps, based on the Java language design and the realization of square dance troupe. The system is based on B/S, the so-called browser/server model, which applies Java technology and selects MySQL as the background database. The system mainly includes functional modules such as system homepage, community, community activities, communication center, announcement information, personal center, background management and so on.

This article first introduces the technical development background and development status of square dance troupe management, and then follows the conventional development process of the software, first selects the applicable language and development platform for the system, formulates the module and designs the database structure according to the requirements analysis, and then draws the functional module diagram, flow chart and E-R diagram of the system according to the design of the overall functional module of the system. Then, design the framework and write code based on the designed framework to implement the various functional modules of the system. Finally, the initially completed system is tested, mainly functional, unit, and performance tests. The test results show that the system can achieve the required functions, and the operating conditions are not obvious.

Keywords: square dance troupe; java; MySQL database

  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/2023面试高手/article/detail/106893
推荐阅读
相关标签

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

  

闽ICP备14008679号