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

疫苗预约|疫苗管理|前后端分离Springboot+Vue儿童疫苗预约系统_selectbargroup

作者：你好赵伟 | 2024-03-01 10:22:30

赞

踩

selectbargroup

作者主页：编程指南针

作者简介：Java领域优质创作者、CSDN博客专家 、掘金特邀作者、多年架构师设计经验、腾讯课堂常驻讲师

主要内容：Java项目、毕业设计、简历模板、学习资料、面试题库、技术互助

收藏点赞不迷路  关注作者有好处

文末获取源码 

项目编号：

前言：

随着社会的发展，社会的各行各业都在利用信息化时代的优势。计算机的优势和普及使得各种信息系统的开发成为必需。

儿童疫苗预约管理，主要的模块包括查看首页、站点管理（轮播图、公告栏）用户管理（管理员、系统用户）内容管理（资讯列表、分类列表）更多管理（预约订单、疫苗信息、取消预约、疫苗采购、疫苗退货）等功能。系统中管理员主要是为了安全有效地存储和管理各类信息，还可以对系统进行管理与更新维护等操作，并且对后台有相应的操作权限。

要想实现儿童疫苗预约管理的各项功能，需要后台数据库的大力支持。管理员验证注册信息，收集的用户信息，并由此分析得出的关联信息等大量的数据都由数据库管理系统管理。本文中数据库服务器端采用了Mysql作为后台数据库，使Web与数据库紧密联系起来。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。

本系统的开发使获取儿童疫苗预约管理信息能够更加方便快捷，同时也使儿童疫苗预约管理管理信息变的更加系统化、有序化。系统界面较友好，易于操作。

一，项目简介

儿童疫苗预约管理从功能、数据流程、可行性、运行环境等方面进行需求分析。对儿童疫苗预约管理的数据库、功能进行了详细设计。分析了主要界面设计和相关组件设计，对儿童疫苗预约管理的具体实现进行了介绍。

采用Java技术，从数据库中获取数据、向数据库中写入数据，实现系统直接对数据库进行各种操作，在网页中加入动态内容，从而实现儿童疫苗预约管理所需要的各种基本功能。

系统用户分为前端用户和后台管理用户两类：下图展示的是各用户角色功能示例图：

二，环境介绍

语言环境：Java:  jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat:  tomcat8.5.31

开发工具：IDEA或eclipse

后台开发技术：Springboot+Mybatisplus

前台开发技术：Vue+ElementUi

三，系统展示

管理员登录，管理员通过输入用户，密码，角色等信息进行系统登录，如图3-1所示。

图3-1管理员登录界面图

管理员登录进入儿童疫苗预约管理可以查看管理员：首页、站点管理（轮播图、公告栏）用户管理（管理员、系统用户）内容管理（资讯列表、分类列表）更多管理（预约订单、疫苗信息、取消预约、疫苗采购、疫苗退货）等内容，如图3-2所示。

图3-2管理员功能首页界面图

用户管理，在用户管理页面可以查看等索引、用户账号、密码、用户姓名、性别、年龄、联系电话、电子邮箱、身份证号、家庭住址、个人照片等信息，并可根据需要进行修改或删除等操作，如图3-3所示。

图3-3用户管理界面图

疫苗信息，在疫苗信息页面可以查看索引、疫苗编号、疫苗名称、疫苗种类、疫苗详情、接种人群等信息，并可根据需要进行修改或删除等操作，如图3-4所示。

图3-4疫苗信息界面图

预约订单信息，在预约订单信息页面可以查看索引、用户编号、订单编号、疫苗编号、疫苗名称、疫苗价格、接种单位、接种医生等信息，并可根据需要进行修改或删除等操作，如图3-5所示。

图3-5预约订单信息界面图

取消预约，在取消预约页面可以查看索引、疫苗名称、疫苗编号、疫苗名称、疫苗价格、接种单位、单位地址、接种医生等信息，并可根据需要进行修改或删除等操作，如图5-6所示。

图3-6取消预约界面图

用户注册，在用户注册页面通过填写用户账号、密码、用户姓名、年龄、联系电话、电子邮箱、身份等信息完成用户注册，如图3-7所示。

图3-7用户注册界面图

用户登录进入后台可以查看首页、公告消息、疫情资讯、疫苗信息等内容，如图3-9所示。

图3-9用户功能界面图

疫苗信息，在疫苗信息页面可以查看疫苗编号、疫苗名称、疫苗图片等信息操作，如图3-10所示。

图3-10疫苗信息界面图

预约订单管理，在预约订单管理页面可以查看索引、疫苗名称、疫苗编号、接种人群、疫苗价格、接种单位、单位地址、接种医生、接种时间等信息，如图3-11所示。

图3-11预约订单界面图

四，核心代码展示

系统抽像的顶层Controller:

  1. package com.project.demo.controller.base;
  2.  
  3. import com.alibaba.fastjson.JSONArray;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.project.demo.service.base.BaseService;
  6. import lombok.Setter;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
  9. import org.springframework.transaction.annotation.Transactional;
  10. import org.springframework.web.bind.annotation.PostMapping;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.RequestParam;
  13. import org.springframework.web.multipart.MultipartFile;
  14. import javax.persistence.Query;
  15. import javax.servlet.http.HttpServletRequest;
  16. import javax.servlet.http.HttpServletResponse;
  17. import java.io.File;
  18. import java.io.IOException;
  19. import java.util.HashMap;
  20. import java.util.List;
  21. import java.util.Map;
  22.  
  23. /**
  24.  */
  25. @Slf4j
  26. public class BaseController<E, S extends BaseService<E>> {
  27.  
  28.     @Setter
  29.     protected S service;
  30.  
  31.  
  32.     @PostMapping("/add")
  33.     @Transactional
  34.     public Map<String, Object> add(HttpServletRequest request) throws IOException {
  35.         service.insert(service.readBody(request.getReader()));
  36.         return success(1);
  37.     }
  38.  
  39.     @Transactional
  40.     public Map<String, Object> addMap(Map<String,Object> map){
  41.         service.insert(map);
  42.         return success(1);
  43.     }
  44.  
  45.     @PostMapping("/set")
  46. 	@Transactional
  47.     public Map<String, Object> set(HttpServletRequest request) throws IOException {
  48.         service.update(service.readQuery(request), service.readConfig(request), service.readBody(request.getReader()));
  49.         return success(1);
  50.     }
  51.  
  52.  
  53.     @RequestMapping(value = "/del")
  54.     @Transactional
  55.     public Map<String, Object> del(HttpServletRequest request) {
  56.         service.delete(service.readQuery(request), service.readConfig(request));
  57.         return success(1);
  58.     }
  59.  
  60.     @RequestMapping("/get_obj")
  61.     public Map<String, Object> obj(HttpServletRequest request) {
  62.         Query select = service.select(service.readQuery(request), service.readConfig(request));
  63.         List resultList = select.getResultList();
  64.         if (resultList.size() > 0) {
  65.             JSONObject jsonObject = new JSONObject();
  66.             jsonObject.put("obj",resultList.get(0));
  67.             return success(jsonObject);
  68.         } else {
  69.             return success(null);
  70.         }
  71.     }
  72.  
  73.  
  74.     @RequestMapping("/get_list")
  75.     public Map<String, Object> getList(HttpServletRequest request) {
  76.         Map<String, Object> map = service.selectToPage(service.readQuery(request), service.readConfig(request));
  77.         return success(map);
  78.     }
  79.  
  80.     @RequestMapping("/list_group")
  81.     public Map<String, Object> listGroup(HttpServletRequest request) {
  82.         Map<String, Object> map = service.selectToList(service.readQuery(request), service.readConfig(request));
  83.         return success(map);
  84.     }
  85.  
  86.     @RequestMapping("/bar_group")
  87.     public Map<String, Object> barGroup(HttpServletRequest request) {
  88.         Map<String, Object> map = service.selectBarGroup(service.readQuery(request), service.readConfig(request));
  89.         return success(map);
  90.     }
  91.  
  92.     @RequestMapping(value = {"/count_group", "/count"})
  93.     public Map<String, Object> count(HttpServletRequest request) {
  94.         Query count = service.count(service.readQuery(request), service.readConfig(request));
  95.         return success(count.getResultList());
  96.     }
  97.  
  98.     @RequestMapping(value = {"/sum_group", "/sum"})
  99.     public Map<String, Object> sum(HttpServletRequest request) {
  100.         Query count = service.sum(service.readQuery(request), service.readConfig(request));
  101.         return success(count.getResultList());
  102.     }
  103.  
  104.     @RequestMapping(value = {"/avg_group", "/avg"})
  105. 	public Map<String, Object> avg(HttpServletRequest request) {
  106.         Query count = service.avg(service.readQuery(request), service.readConfig(request));
  107.         return success(count.getResultList());
  108.     }
  109.  
  110.  
  111.     @PostMapping("/upload")
  112.     public Map<String, Object> upload(@RequestParam("file") MultipartFile file) {
  113.         log.info("进入方法");
  114.         if (file.isEmpty()) {
  115.             return error(30000, "没有选择文件");
  116.         }
  117.         try {
  118.             //判断有没路径，没有则创建
  119.             String filePath = System.getProperty("user.dir") + "\\target\\classes\\static\\upload\\";
  120.             File targetDir = new File(filePath);
  121.             if (!targetDir.exists() && !targetDir.isDirectory()) {
  122.                 if (targetDir.mkdirs()) {
  123.                     log.info("创建目录成功");
  124.                 } else {
  125.                     log.error("创建目录失败");
  126.                 }
  127.             }
  128. //            String path = ResourceUtils.getURL("classpath:").getPath() + "static/upload/";
  129. //            String filePath = path.replace('/', '\\').substring(1, path.length());
  130.             String fileName = file.getOriginalFilename();
  131.             File dest = new File(filePath + fileName);
  132.             log.info("文件路径:{}", dest.getPath());
  133.             log.info("文件名:{}", dest.getName());
  134.             file.transferTo(dest);
  135.             JSONObject jsonObject = new JSONObject();
  136.             jsonObject.put("url", "/api/upload/" + fileName);
  137.             return success(jsonObject);
  138.         } catch (IOException e) {
  139.             log.info("上传失败：{}", e.getMessage());
  140.         }
  141.         return error(30000, "上传失败");
  142.     }
  143.  
  144.     @PostMapping("/import_db")
  145.     public Map<String, Object> importDb(@RequestParam("file") MultipartFile file) throws IOException {
  146.         service.importDb(file);
  147.         return success(1);
  148.     }
  149.  
  150.     @RequestMapping("/export_db")
  151.     public void exportDb(HttpServletRequest request, HttpServletResponse response) throws IOException {
  152.         HSSFWorkbook sheets = service.exportDb(service.readQuery(request), service.readConfig(request));
  153.         response.setContentType("application/octet-stream");
  154.         response.setHeader("Content-disposition", "attachment;filename=employee.xls");
  155.         response.flushBuffer();
  156.         sheets.write(response.getOutputStream());
  157.         sheets.close();
  158.     }
  159.  
  160.     public Map<String, Object> success(Object o) {
  161.         Map<String, Object> map = new HashMap<>();
  162.         if (o == null) {
  163.             map.put("result", null);
  164.             return map;
  165.         }
  166.         if (o instanceof List) {
  167.             if (((List) o).size() == 1) {
  168.                o =  ((List) o).get(0);
  169.                 map.put("result", o);
  170.             }else {
  171.                 String jsonString = JSONObject.toJSONString(o);
  172.                 JSONArray objects = service.covertArray(JSONObject.parseArray(jsonString));
  173.                 map.put("result", objects);
  174.             }
  175.         } else if (o instanceof Integer || o instanceof String) {
  176.             map.put("result", o);
  177.         } else {
  178.             String jsonString = JSONObject.toJSONString(o);
  179.             JSONObject jsonObject = JSONObject.parseObject(jsonString);
  180.             JSONObject j = service.covertObject(jsonObject);
  181.             map.put("result", j);
  182.         }
  183.         return map;
  184.     }
  185.  
  186.     public Map<String, Object> error(Integer code, String message) {
  187.         Map<String, Object> map = new HashMap<>();
  188.         map.put("error", new HashMap<String, Object>(4) {{
  189.             put("code", code);
  190.             put("message", message);
  191.         }});
  192.         return map;
  193.     }
  194. }

系统抽像的顶层Service:

  1. package com.project.demo.service.base;
  2.  
  3. import com.alibaba.fastjson.JSONArray;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.project.demo.constant.FindConfig;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.apache.poi.hssf.usermodel.*;
  8. import org.apache.poi.ss.usermodel.*;
  9. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.transaction.annotation.Transactional;
  12. import org.springframework.web.multipart.MultipartFile;
  13.  
  14. import javax.persistence.EntityManager;
  15. import javax.persistence.PersistenceContext;
  16. import javax.persistence.Query;
  17. import javax.servlet.http.HttpServletRequest;
  18. import java.io.BufferedReader;
  19. import java.io.IOException;
  20. import java.io.InputStream;
  21. import java.io.UnsupportedEncodingException;
  22. import java.lang.reflect.ParameterizedType;
  23. import java.net.URLDecoder;
  24. import java.security.MessageDigest;
  25. import java.util.*;
  26.  
  27. /**
  28.  */
  29. @Slf4j
  30. public class BaseService <E>{
  31.  
  32.     @Autowired
  33.     @PersistenceContext
  34.     private EntityManager entityManager;
  35.  
  36.     Class<E> eClass = (Class<E>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
  37.  
  38.     private final String table = humpToLine(eClass.getSimpleName());
  39.  
  40.     public Query runEntitySql(String sql){
  41.         return entityManager.createNativeQuery(sql, eClass);
  42.     }
  43.  
  44.     public Query runCountSql(String sql){
  45.         return entityManager.createNativeQuery(sql);
  46.     }
  47.  
  48.     public void insert(Map<String,Object> body){
  49.         StringBuffer sql = new StringBuffer("INSERT INTO ");
  50.         sql.append("`").append(table).append("`").append(" (");
  51.         for (Map.Entry<String,Object> entry:body.entrySet()){
  52.             sql.append("`"+humpToLine(entry.getKey())+"`").append(",");
  53.         }
  54.         sql.deleteCharAt(sql.length()-1);
  55.         sql.append(") VALUES (");
  56.         for (Map.Entry<String,Object> entry:body.entrySet()){
  57.             Object value = entry.getValue();
  58.             if (value instanceof String){
  59.                 sql.append("'").append(entry.getValue()).append("'").append(",");
  60.             }else {
  61.                 sql.append(entry.getValue()).append(",");
  62.             }
  63.         }
  64.         sql.deleteCharAt(sql.length() - 1);
  65.         sql.append(")");
  66.         log.info("[{}] - 插入操作：{}",table,sql);
  67.         Query query = runCountSql(sql.toString());
  68.         query.executeUpdate();
  69.     }
  70.  
  71.     @Transactional
  72.     public void update(Map<String,String> query,Map<String,String> config,Map<String,Object> body){
  73.         StringBuffer sql = new StringBuffer("UPDATE ").append("`").append(table).append("`").append(" SET ");
  74.         for (Map.Entry<String,Object> entry:body.entrySet()){
  75.             Object value = entry.getValue();
  76.             if (value instanceof String){
  77.                 sql.append("`"+humpToLine(entry.getKey())+"`").append("=").append("'").append(value).append("'").append(",");
  78.             }else {
  79.                 sql.append("`"+humpToLine(entry.getKey())+"`").append("=").append(value).append(",");
  80.             }
  81.  
  82.         }
  83.         sql.deleteCharAt(sql.length()-1);
  84.         sql.append(toWhereSql(query,"0".equals(config.get(FindConfig.LIKE))));
  85. //        sql.append(";");
  86.         log.info("[{}] - 更新操作：{}",table,sql);
  87.         Query query1 = runCountSql(sql.toString());
  88.         query1.executeUpdate();
  89.     }
  90.  
  91.     public Map<String,Object> selectToPage(Map<String,String> query,Map<String,String> config){
  92.         Query select = select(query, config);
  93.         Map<String,Object> map = new HashMap<>();
  94.         map.put("list",select.getResultList());
  95.         map.put("count",count(query,config).getSingleResult());
  96.         return map;
  97.     }
  98.  
  99.     public Map<String,Object> selectToList(Map<String,String> query,Map<String,String> config){
  100.         Query select = selectGroupCount(query, config);
  101.         Map<String,Object> map = new HashMap<>();
  102.         map.put("list",select.getResultList());
  103.         return map;
  104.     }
  105.  
  106.     public Map<String,Object> selectBarGroup(Map<String,String> query,Map<String,String> config){
  107.         Query select = barGroup(query, config);
  108.         Map<String,Object> map = new HashMap<>();
  109.         map.put("list",select.getResultList());
  110.         return map;
  111.     }
  112.  
  113.     public Query barGroup(Map<String,String> query,Map<String,String> config){
  114.         StringBuffer sql = new StringBuffer(" SELECT ");
  115.         if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
  116.             sql.append(config.get(FindConfig.GROUP_BY));
  117.             if (config.get(FindConfig.FIELD) != null && !"".equals(config.get(FindConfig.FIELD))){
  118.                 String[] fieldList = config.get(FindConfig.FIELD).split(",");
  119.                 for (int i=0;i<fieldList.length;i++)
  120.                     sql.append(" ,SUM(").append(fieldList[i]).append(")");
  121.             }
  122.             sql.append(" FROM ").append("`").append(table).append("`");
  123.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  124.             sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
  125.         }else {
  126.             sql.append(" SUM(").append(config.get(FindConfig.GROUP_BY)).append(") FROM ").append("`").append(table).append("`");
  127.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  128.         }
  129.         log.info("[{}] - 查询操作，sql: {}",table,sql);
  130.         return runCountSql(sql.toString());
  131.     }
  132.  
  133.     public Query selectGroupCount(Map<String,String> query,Map<String,String> config){
  134.         StringBuffer sql = new StringBuffer("select COUNT(*) AS count_value, ");
  135.         sql.append(config.get(FindConfig.GROUP_BY)).append(" ");
  136.         sql.append("from ").append("`").append(table).append("` ");
  137.         sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  138.         if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
  139.             sql.append("group by ").append(config.get(FindConfig.GROUP_BY)).append(" ");
  140.         }
  141.         log.info("[{}] - 查询操作，sql: {}",table,sql);
  142.         return runCountSql(sql.toString());
  143.     }
  144.  
  145.     public Query select(Map<String,String> query,Map<String,String> config){
  146.         StringBuffer sql = new StringBuffer("select ");
  147.         sql.append(config.get(FindConfig.FIELD) == null || "".equals(config.get(FindConfig.FIELD)) ? "*" : config.get(FindConfig.FIELD)).append(" ");
  148.         sql.append("from ").append("`").append(table).append("`").append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  149.         if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
  150.             sql.append("group by ").append(config.get(FindConfig.GROUP_BY)).append(" ");
  151.         }
  152.         if (config.get(FindConfig.ORDER_BY) != null && !"".equals(config.get(FindConfig.ORDER_BY))){
  153.             sql.append("order by ").append(config.get(FindConfig.ORDER_BY)).append(" ");
  154.         }
  155.         if (config.get(FindConfig.PAGE) != null && !"".equals(config.get(FindConfig.PAGE))){
  156.             int page = config.get(FindConfig.PAGE) != null && !"".equals(config.get(FindConfig.PAGE)) ? Integer.parseInt(config.get(FindConfig.PAGE)) : 1;
  157.             int limit = config.get(FindConfig.SIZE) != null && !"".equals(config.get(FindConfig.SIZE)) ? Integer.parseInt(config.get(FindConfig.SIZE)) : 10;
  158.             sql.append(" limit ").append( (page-1)*limit ).append(" , ").append(limit);
  159.         }
  160.         log.info("[{}] - 查询操作，sql: {}",table,sql);
  161.         return runEntitySql(sql.toString());
  162.     }
  163.  
  164.     @Transactional
  165.     public void delete(Map<String,String> query,Map<String,String> config){
  166.         StringBuffer sql = new StringBuffer("DELETE FROM ").append("`").append(table).append("`").append(" ");
  167.         sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.GROUP_BY))));
  168.         log.info("[{}] - 删除操作：{}",table,sql);
  169.         Query query1 = runCountSql(sql.toString());
  170.         query1.executeUpdate();
  171.     }
  172.  
  173.     public Query count(Map<String,String> query,Map<String,String> config){
  174.         StringBuffer sql = new StringBuffer("SELECT ");
  175. //        log.info("拼接统计函数前");
  176.         if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
  177.             sql.append(config.get(FindConfig.GROUP_BY)).append(" ,COUNT(").append(config.get(FindConfig.GROUP_BY)).append(") FROM ").append("`").append(table).append("`");
  178.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  179. //            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
  180.         }else {
  181.             sql.append("COUNT(*) FROM ").append("`").append(table).append("`");
  182.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  183.         }
  184.         log.info("[{}] - 统计操作，sql: {}",table,sql);
  185.         return runCountSql(sql.toString());
  186.     }
  187.  
  188.     public Query sum(Map<String,String> query,Map<String,String> config){
  189.         StringBuffer sql = new StringBuffer(" SELECT ");
  190.         if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
  191.             sql.append(config.get(FindConfig.GROUP_BY)).append(" ,SUM(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
  192.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  193.             sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
  194.         }else {
  195.             sql.append(" SUM(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
  196.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  197.         }
  198.         log.info("[{}] - 查询操作，sql: {}",table,sql);
  199.         return runCountSql(sql.toString());
  200.     }
  201.  
  202.     public Query avg(Map<String,String> query,Map<String,String> config){
  203.         StringBuffer sql = new StringBuffer(" SELECT ");
  204.         if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
  205.             sql.append(config.get(FindConfig.GROUP_BY)).append(" ,AVG(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
  206.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  207.             sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
  208.         }else {
  209.             sql.append(" AVG(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
  210.             sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
  211.         }
  212.         log.info("[{}] - 查询操作，sql: {}",table,sql);
  213.         return runCountSql(sql.toString());
  214.     }
  215.  
  216.     public String toWhereSql(Map<String,String> query, Boolean like) {
  217.         if (query.size() > 0) {
  218.             try {
  219.                 StringBuilder sql = new StringBuilder(" WHERE ");
  220.                 for (Map.Entry<String, String> entry : query.entrySet()) {
  221.                     if (entry.getKey().contains(FindConfig.MIN_)) {
  222.                         String min = humpToLine(entry.getKey()).replace("_min", "");
  223.                         sql.append("`"+min+"`").append(" >= '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("' and ");
  224.                         continue;
  225.                     }
  226.                     if (entry.getKey().contains(FindConfig.MAX_)) {
  227.                         String max = humpToLine(entry.getKey()).replace("_max", "");
  228.                         sql.append("`"+max+"`").append(" <= '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("' and ");
  229.                         continue;
  230.                     }
  231.                     if (like == true) {
  232.                         sql.append("`"+humpToLine(entry.getKey())+"`").append(" LIKE '%").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("%'").append(" and ");
  233.                     } else {
  234.                         sql.append("`"+humpToLine(entry.getKey())+"`").append(" = '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("'").append(" and ");
  235.                     }
  236.                 }
  237.                 sql.delete(sql.length() - 4, sql.length());
  238.                 sql.append(" ");
  239.                 return sql.toString();
  240.             } catch (UnsupportedEncodingException e) {
  241.                 log.info("拼接sql 失败：{}", e.getMessage());
  242.             }
  243.         }
  244.         return "";
  245.     }
  246.  
  247.     public Map<String,Object> readBody(BufferedReader reader){
  248.         BufferedReader br = null;
  249.         StringBuilder sb = new StringBuilder("");
  250.         try{
  251.             br = reader;
  252.             String str;
  253.             while ((str = br.readLine()) != null){
  254.                 sb.append(str);
  255.             }
  256.             br.close();
  257.             String json = sb.toString();
  258.             return JSONObject.parseObject(json, Map.class);
  259.         }catch (IOException e){
  260.             e.printStackTrace();
  261.         }finally{
  262.             if (null != br){
  263.                 try{
  264.                     br.close();
  265.                 }catch (IOException e){
  266.                     e.printStackTrace();
  267.                 }
  268.             }
  269.         }
  270.         return null;
  271.     }
  272.  
  273.     public Map<String,String> readQuery(HttpServletRequest request){
  274.         String queryString = request.getQueryString();
  275.         if (queryString != null && !"".equals(queryString)) {
  276.             String[] querys = queryString.split("&");
  277.             Map<String, String> map = new HashMap<>();
  278.             for (String query : querys) {
  279.                 String[] q = query.split("=");
  280.                 map.put(q[0], q[1]);
  281.             }
  282.             map.remove(FindConfig.PAGE);
  283.             map.remove(FindConfig.SIZE);
  284.             map.remove(FindConfig.LIKE);
  285.             map.remove(FindConfig.ORDER_BY);
  286.             map.remove(FindConfig.FIELD);
  287.             map.remove(FindConfig.GROUP_BY);
  288.             map.remove(FindConfig.MAX_);
  289.             map.remove(FindConfig.MIN_);
  290.             return map;
  291.         }else {
  292.             return new HashMap<>();
  293.         }
  294.     }
  295.  
  296.     public Map<String,String> readConfig(HttpServletRequest request){
  297.         Map<String,String> map = new HashMap<>();
  298.         map.put(FindConfig.PAGE,request.getParameter(FindConfig.PAGE));
  299.         map.put(FindConfig.SIZE,request.getParameter(FindConfig.SIZE));
  300.         map.put(FindConfig.LIKE,request.getParameter(FindConfig.LIKE));
  301.         map.put(FindConfig.ORDER_BY,request.getParameter(FindConfig.ORDER_BY));
  302.         map.put(FindConfig.FIELD,request.getParameter(FindConfig.FIELD));
  303.         map.put(FindConfig.GROUP_BY,request.getParameter(FindConfig.GROUP_BY));
  304.         map.put(FindConfig.MAX_,request.getParameter(FindConfig.MAX_));
  305.         map.put(FindConfig.MIN_,request.getParameter(FindConfig.MIN_));
  306.         return map;
  307.     }
  308.  
  309.     public void importDb(MultipartFile file) throws IOException {
  310.         if (file.isEmpty()) {
  311.             return;
  312.         }
  313.         List<Map<String,String>> body = new ArrayList<>();
  314.         String fileName = file.getOriginalFilename();
  315.         if (fileName == null){
  316.             return;
  317.         }
  318.         String suffix = fileName.substring(fileName.lastIndexOf(".")+1);
  319.         InputStream ins = file.getInputStream();
  320.         Workbook wb = null;
  321.         if(suffix.equals("xlsx")){
  322.             wb = new XSSFWorkbook(ins);
  323.         }else{
  324.             wb = new HSSFWorkbook(ins);
  325.         }
  326.         Sheet sheet = wb.getSheetAt(0);
  327.         if(null != sheet){
  328.             for(int line = 0; line <= sheet.getLastRowNum();line++){
  329.                 Row row = sheet.getRow(line);
  330.                 if(null == row){
  331.                     continue;
  332.                 }
  333.                 Iterator<Cell> cellIterator = row.cellIterator();
  334.                 StringBuffer sql = new StringBuffer("INSERT INTO ").append(table).append(" VALUES (null,");
  335.                 while (cellIterator.hasNext()){
  336.                     sql.append(cellIterator.next().getStringCellValue()).append(",");
  337.                 }
  338.                 sql.deleteCharAt(sql.length());
  339.                 sql.append(")");
  340.                 runCountSql(sql.toString());
  341.             }
  342.         }
  343.     }
  344.  
  345.     public HSSFWorkbook exportDb(Map<String,String> query,Map<String,String> config){
  346.         Query select = select(query, config);
  347.         List<Map<String,String>> resultList = select.getResultList();
  348.         HSSFWorkbook workbook = new HSSFWorkbook();
  349.         HSSFSheet sheet = workbook.createSheet(table);
  350.         HSSFCellStyle headerStyle = workbook.createCellStyle();
  351.         headerStyle.setFillForegroundColor(IndexedColors.YELLOW.index);
  352.         headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
  353.         for (int i = 0; i < resultList.size(); i++) {
  354.             HSSFRow row = sheet.createRow(i);
  355.             Map<String,String> map = resultList.get(i);
  356.             int j = 0;
  357.             for (Map.Entry<String,String> entry:map.entrySet()){
  358.                 row.createCell(j).setCellValue(new HSSFRichTextString(entry.getValue()));
  359.             }
  360.         }
  361.         return workbook;
  362.     }
  363.  
  364.     @Transactional
  365.     public void save(E e){
  366.         String s = JSONObject.toJSONString(e);
  367.         Map map = JSONObject.parseObject(s, Map.class);
  368.         insert(map);
  369.     }
  370.  
  371.     public E findOne(Map<String, String> map){
  372.         try {
  373.             Query select = select(map, new HashMap<>());
  374.             return (E) select.getSingleResult();
  375.         }catch (Exception e){
  376.             return null;
  377.         }
  378.     }
  379.  
  380.  
  381.     public String encryption(String plainText) {
  382.         String re_md5 = new String();
  383.         try {
  384.             MessageDigest md = MessageDigest.getInstance("MD5");
  385.             md.update(plainText.getBytes());
  386.             byte b[] = md.digest();
  387.  
  388.             int i;
  389.  
  390.             StringBuffer buf = new StringBuffer("");
  391.             for (int offset = 0; offset < b.length; offset++) {
  392.                 i = b[offset];
  393.                 if (i < 0)
  394.                     i += 256;
  395.                 if (i < 16)
  396.                     buf.append("0");
  397.                 buf.append(Integer.toHexString(i));
  398.             }
  399.  
  400.             re_md5 = buf.toString();
  401.  
  402.         } catch (Exception e) {
  403.             e.printStackTrace();
  404.         }
  405.         return re_md5;
  406.     }
  407.  
  408.  
  409.     public static String humpToLine(String str) {
  410.         if (str == null) {
  411.             return null;
  412.         }
  413.         // 将驼峰字符串转换成数组
  414.         char[] charArray = str.toCharArray();
  415.         StringBuilder buffer = new StringBuilder();
  416.         //处理字符串
  417.         for (int i = 0, l = charArray.length; i < l; i++) {
  418.             if (charArray[i] >= 65 && charArray[i] <= 90) {
  419.                 buffer.append("_").append(charArray[i] += 32);
  420.             } else {
  421.                 buffer.append(charArray[i]);
  422.             }
  423.         }
  424.         String s = buffer.toString();
  425.         if (s.startsWith("_")){
  426.             return s.substring(1);
  427.         }else {
  428.             return s;
  429.         }
  430.     }
  431.  
  432.  
  433.     public JSONObject covertObject(JSONObject object) {
  434.         if (object == null) {
  435.             return null;
  436.         }
  437.         JSONObject newObject = new JSONObject();
  438.         Set<String> set = object.keySet();
  439.         for (String key : set) {
  440.             Object value = object.get(key);
  441.             if (value instanceof JSONArray) {
  442.                 //数组
  443.                 value = covertArray(object.getJSONArray(key));
  444.             } else if (value instanceof JSONObject) {
  445.                 //对象
  446.                 value = covertObject(object.getJSONObject(key));
  447.             }
  448.             //这个方法自己写的改成下划线
  449.             key = humpToLine(key);
  450.             newObject.put(key, value);
  451.         }
  452.         return newObject;
  453.     }
  454.  
  455.     public JSONArray covertArray(JSONArray array) {
  456.         if (array == null) {
  457.             return null;
  458.         }
  459.         JSONArray newArray = new JSONArray();
  460.         for (int i = 0; i < array.size(); i++) {
  461.             Object value = array.get(i);
  462.             if (value instanceof JSONArray) {
  463.                 //数组
  464.                 value = covertArray(array.getJSONArray(i));
  465.             } else if (value instanceof JSONObject) {
  466.                 //对象
  467.                 value = covertObject(array.getJSONObject(i));
  468.             }
  469.             newArray.add(value);
  470.         }
  471.         return newArray;
  472.     }
  473.  
  474.  
  475. }

五，项目总结

　随着社会的快速发展，计算机的影响是全面且深入的。人们生活水平的不断提高，日常生活中人们儿童疫苗预约信息管理方面的要求也在不断提高，需要儿童疫苗预约的人数更是不断增加，使得儿童疫苗预约管理的开发成为必需而且紧迫的事情。儿童疫苗预约管理主要是借助计算机，通过对儿童疫苗预约管理所需的信息管理，增加用户选择，同时也方便对广大用户信息的及时查询、修改以及对用户信息的及时了解。儿童疫苗预约管理对用户带来了更多的便利, 该系统通过和数据库管理系统软件协作来满足用户的需求。

1.2课题意义

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

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

  

闽ICP备14008679号