陪练预约|基于微信小程序+Springboot+vue实现陪练预约系统-阿里云开发者社区

项目编号：BS-XCX-015

一，环境介绍

语言环境：Java: jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat: tomcat8.5.31

开发工具：IDEA+微信开发者工具+HBuilder

后台开发技术：Springboot+Mybatis

前台开发技术：微信小程序+Vue+Nodejs

二，项目简介

健身是一种体育项目，如各种健美操、韵律操、形体操以及各种自抗力动作。随着社会的发展和人们健康意识的提高，健身已成为一种流行的减压和维持身体健康的方式。科学表明，如果要达到缓解压力和提高健身效果的目的，一周至少要锻炼3次。近年来在科技助推下，我国健身行业发展加快，尤其是在中国奥运会等大型国际赛事带动以及国家政策鼓励下，中国健身行业保持稳定发展，逐渐向低线城市渗透，健身需求逐渐升级，行业蓬勃发展，催生了各种在线健身服务、居家健身服务和智能化健身器材。目前，健身行业上游包括健身器材、教练培训、课程研发；中游包括线下健身房、O2O服务平台、健身APP，覆盖线上线下各类健身场景；下游包括数据管理、社交平台、信息查找、运动周边，满足消费者不同衍生需求。

为了提高国民健康素质，近年来国家出台多项政策助推体育健康产业发展。2020年新冠病毒席卷全球，为减少疫情对体育产业影响，国家印发了《关于大力推广居家科学健身方法的通知》，鼓励居民居家健身，助推居家健身、互联网健身等行业逆袭。2021年，国家发布《“十四五”时期全民健身设施补短板工程实施方案》。《关于加强公共场所全民健身器材配建管理工作的意见》《关于推进体育公园建设的指导意见》《全民健身计划（2021-2025年）》等政策，致力于给国民提供更好的健身环境，不断推动健身行业发展。

这些政策的推出有力的推动了健身各个细分行业的发展和进步，我们虽然比国外在健身方面要落后一些，起步晚一些，但相信随着国家政策的不断支持，人们健身意识的不断加强，像陪练行业这些朝阳行业将来迎来一些新的机遇和发展。

本课题主要实现通过小程序进行在线预约陪练，下单支付，信息反馈，对陪练行业员工及其它信息的相关管理功能。系统利用所学的JAVA开发技术，利用Springboot框架实现系统的后台接口服务开发，使用VUE完成系统的前端页面开发，并通过微信小程序客户端来让用户进行在线使用更加方便，采用前后端分离的开发方式来实现。数据库采用MYSQL对陪你动系统中的业务数据进行存储，最终实现一个前后端分离的并结合微信小程序一起使用的陪练信息化系统。

本次开发设计的运动陪练小程序，使用的用户主要分为三类角色，一是系统管理员，二是公司员工，三是前端客户。这三类用户登陆系统后进行的操作权限是不同的，其中前端客户主要通过微信小程序进行登陆使用相关的预约下单等服务，管理员和员工通过后台管理系统进入可以管理相应的数据信息。

前端用户登陆系统后主要进行的操作如下：

（1）注册登陆：用户可以在微信小程序上注册个人账户并进行登陆，登陆后可以操作相关的模块。

（2）个人信息管理：查看自己所在的宿舍情况以及个人信息情况，并可以对个人信息进行相应的管理操作。

（3）陪练员浏览：可以浏览陪练人员的相关信息，根据相关条件进行搜索查看等。

（4）在线预约服务：对于指定的陪练员，用户可以在线预约陪练人员，指定陪练的时间信息并在线下单，同时可以在个人中心中查看自己的预约记录。

（5）查看陪练排行：可以查看陪练员工的各项排行指标信息，并对陪练人员进行在线评论等操作。

（6）反馈留言：可以在线实现相应的留言反馈功能。

（7）交流论坛：可以小程序中发布各种交流探讨的贴子，为各位喜欢健身的朋友提供一个交流场所。

（8）反馈留言：可以在线实现相应的留言反馈功能。

（9）资讯查看：可以查看后台管理员发布的相关资讯信息。

陪你动平台管理员登陆后台管理系统后进行的操作如下：

（1）轮播图管理模块：主要管理在微信小程序端展现的轮播图片。

（2）公告管理模块：主要管理在小程序端展现的系统公告信息。

（3）资讯管理模块：主要包含行业资讯信息管理和资讯分类管理。

（4）交流管理模块：主要管理交流论坛的主题分类和交流贴子信息。

（5）用户管理模块：主要管理系统管理员、员工管理、前端注册用户的信息。

（6）陪练人员管理模块：用户管理陪练公司的陪练人员信息。

（7）预约记录管理模块：主要管理前端用户预约下单的订单信息。

（8）排行管理模块：由平台系统管理员在后台平台管理前端展示的陪练人员排行信息。

（9）留言管理模块：主要管理前端用户在线留言信息。

（10）打分管理模块：由系统管理员在后台平台查看前端用户的打分信息。

陪你动员工登陆后台系统可以进行的操作如下：

（1）预约记录管理模块：主要管理前端用户预约下单的订单信息。

（2）排行管理模块：由员工在后台平台管理前端展示的陪练人员排行信息。

（3）打分管理模块：由员工在后台平台查看前端用户的打分信息。

三，系统展示

陪你动小程序系统的实现主要分为微信小程序端开发与实现，后台管理系统的开发与实现，结合三类用户不同的操作界面与功能来进行开发实现，下面展示一下系统主要的一些用户功能实现界面。

3.1 前端用户的基本功能

3.1.1 小程序用户登录管理的展示

会员通过小程序注册后可以在线登陆，输入账户和密码提交请求到后台服务接口进行验证，验证通过后即登陆成功。如下图3.1所示。

图3.1 登录界面

3.1.2陪练员浏览的展示

会员在小程序前端可以浏览查看陪你动平台的陪练员信息，可以通过陪练类型进行分类查询，同时可以根据点赞数据、点击数据和发布时间来进行指定排序，具体如下图3.2所示：

图3.2陪练员浏览展示图

3. 1.3 公告信息展示

会员进入小程序前端后可查看后台管理员发布的公告信息，以了解目前陪你动应用的最新动态，具体如下图3.3所示。

图3.3公告信息界面图

3.1.4 在线预约管理展示

会员登陆陪你动平台后，可以在个查看陪练员详情页进行在线预约，指定预约时间，根据预约时长自动计算预约总价，具体如下图3.4所示。

图34 在线预约管理界面图

3.1.5 排行信息查看展示

会员进入陪你动服务平台后，可以查看当前整个平台的陪练人员的综合排名情况，然后进行相关的预约操作，具体如下图3.5所示。

图3.5 排名查看界面图

3.2 后台管理功能展示

3.2.1 轮播图管理

管理员进入后台管理中选择轮播管理下的轮播图管理，可以对在小程序平台展示的轮播广告图片进行相应的管理操作，具体如下图3.6所示。

图3.6 轮播图管理界面图

3.2.2 公告管理功能展示

管理员进入后台管理中选择公告管理下的公告管理，可以对系统中发布的平台公告信息进行相应的管理操作，具体如下图3.7所示。

图3.7 公告管理信息界面

3.2.3 资讯管理功能展示

管理员进入后台管理中选择资讯管理，可以对系统中发布的新闻资读信息进行相应的管理操作，主要进行组合条件查询、新闻的添加、编辑和删除操作等，具体如下图3.8所示。

图3.8 资讯信息管理界面示意图

3.2.4 陪练员管理功能展示

管理员进入后台选择陪练员管理，在此处可对陪你动平台的陪练人员进行相关管理操作，如图3.9所示。

图3.9 陪练员管理界面图

3.2.5 预约记录管理

管理员进入后台选择预约记录管理，在此处可对陪你动前端用户在线预约的情况进行相关管理操作，如图3.10所示。

图3.10 预约记录管理界面图

四，核心代码展示

package com.project.demo.controller.base;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.project.demo.service.base.BaseService;
import com.project.demo.utils.IdWorker;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 */
@Slf4j
public class BaseController<E, S extends BaseService<E>> {
    @Setter
    protected S service;
    @PostMapping("/add")
    @Transactional
    public Map<String, Object> add(HttpServletRequest request) throws IOException {
        service.insert(service.readBody(request.getReader()));
        return success(1);
    }
    @Transactional
    public Map<String, Object> addMap(Map<String,Object> map){
        service.insert(map);
        return success(1);
    }
    @PostMapping("/set")
  @Transactional
    public Map<String, Object> set(HttpServletRequest request) throws IOException {
        service.update(service.readQuery(request), service.readConfig(request), service.readBody(request.getReader()));
        return success(1);
    }
    @RequestMapping(value = "/del")
    @Transactional
    public Map<String, Object> del(HttpServletRequest request) {
        service.delete(service.readQuery(request), service.readConfig(request));
        return success(1);
    }
    @RequestMapping("/get_obj")
    public Map<String, Object> obj(HttpServletRequest request) {
        List resultList = service.selectBaseList(service.select(service.readQuery(request), service.readConfig(request)));
        if (resultList.size() > 0) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("obj",resultList.get(0));
            return success(jsonObject);
        } else {
            return success(null);
        }
    }
    @RequestMapping("/get_list")
    public Map<String, Object> getList(HttpServletRequest request) {
        Map<String, Object> map = service.selectToPage(service.readQuery(request), service.readConfig(request));
        return success(map);
    }
    @RequestMapping("/list_group")
    public Map<String, Object> listGroup(HttpServletRequest request) {
        Map<String, Object> map = service.selectToList(service.readQuery(request), service.readConfig(request));
        return success(map);
    }
    @RequestMapping("/bar_group")
    public Map<String, Object> barGroup(HttpServletRequest request) {
        Map<String, Object> map = service.selectBarGroup(service.readQuery(request), service.readConfig(request));
        return success(map);
    }
    @RequestMapping(value = {"/count_group", "/count"})
    public Map<String, Object> count(HttpServletRequest request) {
        Integer value= service.selectSqlToInteger(service.groupCount(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }
    @RequestMapping(value = {"/sum_group", "/sum"})
    public Map<String, Object> sum(HttpServletRequest request) {
        Integer value = service.selectSqlToInteger(service.sum(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }
    @RequestMapping(value = {"/avg_group", "/avg"})
    public Map<String, Object> avg(HttpServletRequest request) {
        Integer value = service.selectSqlToInteger(service.avg(service.readQuery(request), service.readConfig(request)));
        return success(value);
    }
//    @RequestMapping(value = {"/count_group", "/count"})
//    public Map<String, Object> count(HttpServletRequest request) {
//        Query count = service.count(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }
//
//    @RequestMapping(value = {"/sum_group", "/sum"})
//    public Map<String, Object> sum(HttpServletRequest request) {
//        Query count = service.sum(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }
//
//    @RequestMapping(value = {"/avg_group", "/avg"})
//  public Map<String, Object> avg(HttpServletRequest request) {
//        Query count = service.avg(service.readQuery(request), service.readConfig(request));
//        return success(count.getResultList());
//    }
    @PostMapping("/upload")
    public Map<String, Object> upload(@RequestParam(value = "file",required=false) MultipartFile file,HttpServletRequest request) {
        log.info("进入方法");
        if (file.isEmpty()) {
            return error(30000, "没有选择文件");
        }
        try {
            //判断有没路径，没有则创建
            String filePath = request.getSession().getServletContext().getRealPath("\\") +"upload\\";
//            String filePath = System.getProperty("user.dir") + "\\target\\classes\\static\\upload\\";
            File targetDir = new File(filePath);
            if (!targetDir.exists() && !targetDir.isDirectory()) {
                if (targetDir.mkdirs()) {
                    log.info("创建目录成功");
                } else {
                    log.error("创建目录失败");
                }
            }
//            String path = ResourceUtils.getURL("classpath:").getPath() + "static/upload/";
//            String filePath = path.replace('/', '\\').substring(1, path.length());
            String fileName = file.getOriginalFilename();
            int lastIndexOf = fileName.lastIndexOf(".");
            //获取文件的后缀名 .jpg
            String suffix = fileName.substring(lastIndexOf);
            fileName = IdWorker.getId()+suffix;
            File dest = new File(filePath + fileName);
            log.info("文件路径:{}", dest.getPath());
            log.info("文件名:{}", dest.getName());
            file.transferTo(dest);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("url", "/api/upload/" + fileName);
            return success(jsonObject);
        } catch (IOException e) {
            log.info("上传失败：{}", e.getMessage());
        }
        return error(30000, "上传失败");
    }
//    @PostMapping("/import_db")
//    public Map<String, Object> importDb(@RequestParam("file") MultipartFile file) throws IOException {
//        service.importDb(file);
//        return success(1);
//    }
//
//    @RequestMapping("/export_db")
//    public void exportDb(HttpServletRequest request, HttpServletResponse response) throws IOException {
//        HSSFWorkbook sheets = service.exportDb(service.readQuery(request), service.readConfig(request));
//        response.setContentType("application/octet-stream");
//        response.setHeader("Content-disposition", "attachment;filename=employee.xls");
//        response.flushBuffer();
//        sheets.write(response.getOutputStream());
//        sheets.close();
//    }
    public Map<String, Object> success(Object o) {
        Map<String, Object> map = new HashMap<>();
        if (o == null) {
            map.put("result", null);
            return map;
        }
        if (o instanceof List) {
            if (((List) o).size() == 1) {
               o =  ((List) o).get(0);
                map.put("result", o);
            }else {
                String jsonString = JSONObject.toJSONString(o);
                JSONArray objects = service.covertArray(JSONObject.parseArray(jsonString));
                map.put("result", objects);
            }
        } else if (o instanceof Integer || o instanceof String) {
            map.put("result", o);
        } else {
            String jsonString = JSONObject.toJSONString(o);
            JSONObject jsonObject = JSONObject.parseObject(jsonString);
            JSONObject j = service.covertObject(jsonObject);
            map.put("result", j);
        }
        return map;
    }
    public Map<String, Object> error(Integer code, String message) {
        Map<String, Object> map = new HashMap<>();
        map.put("error", new HashMap<String, Object>(4) {{
            put("code", code);
            put("message", message);
        }});
        return map;
    }
}

package com.project.demo.service.base;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.project.demo.constant.FindConfig;
import com.project.demo.dao.base.BaseMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.ParameterizedType;
import java.net.URLDecoder;
import java.security.MessageDigest;
import java.util.*;
/**
 */
@Slf4j
public class BaseService<E>{
    @Autowired
    private BaseMapper<E> baseMapper;
    Class<E> eClass = (Class<E>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    private final String table = humpToLine(eClass.getSimpleName());
    public List selectBaseList(String select) {
        List<Map<String,Object>> mapList = baseMapper.selectBaseList(select);
        List<E> list = new ArrayList<>();
        for (Map<String,Object> map:mapList) {
            list.add(JSON.parseObject(JSON.toJSONString(map),eClass));
        }
        return list;
    }
    public int selectBaseCount(String sql) {
        return baseMapper.selectBaseCount(sql);
    }
    public int deleteBaseSql(String sql) {
        return baseMapper.deleteBaseSql(sql);
    }
    public int updateBaseSql(String sql) {
        return baseMapper.updateBaseSql(sql);
    }
    public void insert(Map<String,Object> body){
        E entity = JSON.parseObject(JSON.toJSONString(body),eClass);
        baseMapper.insert(entity);
        log.info("[{}] - 插入操作：{}",entity);
    }
    @Transactional
    public void update(Map<String,String> query,Map<String,String> config,Map<String,Object> body){
        QueryWrapper wrapper = new QueryWrapper<E>();
        toWhereWrapper(query,"0".equals(config.get(FindConfig.LIKE)),wrapper);
        E entity = JSON.parseObject(JSON.toJSONString(body),eClass);
        baseMapper.update(entity,wrapper);
        log.info("[{}] - 更新操作：{}",entity);
    }
    public Map<String,Object> selectToPage(Map<String,String> query,Map<String,String> config){
        Map<String,Object> map = new HashMap<>();
        List list = baseMapper.selectBaseList(select(query, config));
        map.put("list",list);
        map.put("count",baseMapper.selectBaseCount(count(query,config)));
        return map;
    }
    public Map<String,Object> selectToList(Map<String,String> query,Map<String,String> config){
        Map<String,Object> map = new HashMap<>();
        List<Map<String,Object>> resultList = baseMapper.selectBaseList(selectGroupCount(query, config));
        List list = new ArrayList();
        for (Map<String,Object> resultMap:resultList) {
            List subList = new ArrayList();
            for(String key:resultMap.keySet()){//keySet获取map集合key的集合  然后在遍历key即可
                subList.add(resultMap.get(key));
            }
            list.add(subList);
        }
        map.put("list",list);
        return map;
    }
    public Integer selectSqlToInteger(String sql){
        Integer value = baseMapper.selectBaseCount(sql);
        return value;
    }
    public Map<String,Object> selectBarGroup(Map<String,String> query,Map<String,String> config){
        Map<String,Object> map = new HashMap<>();
        List<Map<String,Object>> resultList = baseMapper.selectBaseList(barGroup(query, config));
        List list = new ArrayList();
        for (Map<String,Object> resultMap:resultList) {
            List subList = new ArrayList();
            for(String key:resultMap.keySet()){//keySet获取map集合key的集合  然后在遍历key即可
                subList.add(resultMap.get(key));
            }
            list.add(subList);
        }
        map.put("list",list);
        return map;
    }
//    public void barGroup(Map<String,String> query,Map<String,String> config,QueryWrapper wrapper){
//        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
//            wrapper.select(config.get(FindConfig.GROUP_BY));
//            if (config.get(FindConfig.FIELD) != null && !"".equals(config.get(FindConfig.FIELD))){
//                String[] fieldList = config.get(FindConfig.FIELD).split(",");
//                for (int i=0;i<fieldList.length;i++)
//                    wrapper.select("SUM("+fieldList[i]+")");
//            }
//            toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),wrapper);
//            wrapper.groupBy(config.get(FindConfig.GROUP_BY));
//        }else {
//            wrapper.select("SUM("+config.get(FindConfig.GROUP_BY)+")");
//            toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),wrapper);
//        }
//        log.info("[{}] - 查询操作，sql: {}",wrapper.getSqlSelect());
//    }
    public String barGroup(Map<String,String> query,Map<String,String> config){
        StringBuffer sql = new StringBuffer(" SELECT ");
        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
            sql.append(config.get(FindConfig.GROUP_BY));
            if (config.get(FindConfig.FIELD) != null && !"".equals(config.get(FindConfig.FIELD))){
                String[] fieldList = config.get(FindConfig.FIELD).split(",");
                for (int i=0;i<fieldList.length;i++)
                    sql.append(" ,SUM(").append(fieldList[i]).append(")");
            }
            sql.append(" FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
        }else {
            sql.append(" SUM(").append(config.get(FindConfig.GROUP_BY)).append(") FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
        }
        log.info("[{}] - 查询操作，sql: {}",table,sql);
        return sql.toString();
    }
//    public void selectGroupCount(Map<String,String> query,Map<String,String> config,QueryWrapper wrapper){
//        wrapper.select("count(*) AS count_value",config.get(FindConfig.GROUP_BY));
//        toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),wrapper);
//        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
//            wrapper.groupBy(config.get(FindConfig.GROUP_BY));
//        }
//        log.info("[{}] - 查询操作，sql: {}",wrapper.getSqlSelect());
//    }
    public String selectGroupCount(Map<String,String> query,Map<String,String> config){
        StringBuffer sql = new StringBuffer("select COUNT(*) AS count_value, ");
        sql.append(config.get(FindConfig.GROUP_BY)).append(" ");
        sql.append("from ").append("`").append(table).append("` ");
        sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
            sql.append("group by ").append(config.get(FindConfig.GROUP_BY)).append(" ");
        }
        log.info("[{}] - 查询操作，sql: {}",table,sql);
        return sql.toString();
    }
//    public void select(Map<String,String> query,Map<String,String> config,QueryWrapper wrapper){
//        wrapper.select(config.get(FindConfig.FIELD) == null || "".equals(config.get(FindConfig.FIELD)) ? "*" : config.get(FindConfig.FIELD));
//        toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),wrapper);
//        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
//            wrapper.groupBy(config.get(FindConfig.GROUP_BY));
//        }
//        if (config.get(FindConfig.ORDER_BY) != null && !"".equals(config.get(FindConfig.ORDER_BY))){
//            if (config.get(FindConfig.ORDER_BY).toUpperCase().contains("DESC")){
//                wrapper.orderByDesc(config.get(FindConfig.ORDER_BY).toUpperCase().replaceAll(" DESC",""));
//            }else {
//                wrapper.orderByAsc(config.get(FindConfig.ORDER_BY).toUpperCase().replaceAll(" ASC",""));
//            }
//        }
//        if (config.get(FindConfig.PAGE) != null && !"".equals(config.get(FindConfig.PAGE))){
//            int page = config.get(FindConfig.PAGE) != null && !"".equals(config.get(FindConfig.PAGE)) ? Integer.parseInt(config.get(FindConfig.PAGE)) : 1;
//            int limit = config.get(FindConfig.SIZE) != null && !"".equals(config.get(FindConfig.SIZE)) ? Integer.parseInt(config.get(FindConfig.SIZE)) : 10;
//            wrapper.last("limit "+(page-1)*limit+" , "+limit);
//        }
//        log.info("[{}] - 查询操作，sql: {}",wrapper.getSqlSelect());
//    }
    public String select(Map<String,String> query,Map<String,String> config){
        StringBuffer sql = new StringBuffer("select ");
        sql.append(config.get(FindConfig.FIELD) == null || "".equals(config.get(FindConfig.FIELD)) ? "*" : config.get(FindConfig.FIELD)).append(" ");
        sql.append("from ").append("`").append(table).append("`").append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
            sql.append("group by ").append(config.get(FindConfig.GROUP_BY)).append(" ");
        }
        if (config.get(FindConfig.ORDER_BY) != null && !"".equals(config.get(FindConfig.ORDER_BY))){
            sql.append("order by ").append(config.get(FindConfig.ORDER_BY)).append(" ");
        }
        if (config.get(FindConfig.PAGE) != null && !"".equals(config.get(FindConfig.PAGE))){
            int page = config.get(FindConfig.PAGE) != null && !"".equals(config.get(FindConfig.PAGE)) ? Integer.parseInt(config.get(FindConfig.PAGE)) : 1;
            int limit = config.get(FindConfig.SIZE) != null && !"".equals(config.get(FindConfig.SIZE)) ? Integer.parseInt(config.get(FindConfig.SIZE)) : 10;
            sql.append(" limit ").append( (page-1)*limit ).append(" , ").append(limit);
        }
        log.info("[{}] - 查询操作，sql: {}",table,sql);
        return sql.toString();
    }
    @Transactional
    public void delete(Map<String,String> query,Map<String,String> config){
        QueryWrapper wrapper = new QueryWrapper<E>();
        toWhereWrapper(query, "0".equals(config.get(FindConfig.GROUP_BY)),wrapper);
        baseMapper.delete(wrapper);
        log.info("[{}] - 删除操作：{}",wrapper.getSqlSelect());
    }
//    public void count(Map<String,String> query,Map<String,String> config, QueryWrapper wrapper){
        log.info("拼接统计函数前");
//        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
//            wrapper.select(config.get(FindConfig.GROUP_BY));
//            wrapper.select("COUNT("+config.get(FindConfig.GROUP_BY)+")");
//            toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),wrapper);
//        }else {
//            wrapper.select("COUNT(*)");
//            toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),wrapper);
//        }
//        log.info("[{}] - 统计操作，sql: {}",wrapper.getSqlSelect());
//    }
    public String count(Map<String,String> query,Map<String,String> config){
        StringBuffer sql = new StringBuffer("SELECT ");
//        log.info("拼接统计函数前");
        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
            sql.append("COUNT(").append(config.get(FindConfig.GROUP_BY)).append(") FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
//            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
        }else {
            sql.append("COUNT(*) FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
        }
        log.info("[{}] - 统计操作，sql: {}",table,sql);
        return sql.toString();
    }
//    public Query sum(Map<String,String> query,Map<String,String> config){
//        StringBuffer sql = new StringBuffer(" SELECT ");
//        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
//            sql.append(config.get(FindConfig.GROUP_BY)).append(" ,SUM(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
//            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
//            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
//        }else {
//            sql.append(" SUM(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
//            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
//        }
//        log.info("[{}] - 查询操作，sql: {}",table,sql);
//        return runCountSql(sql.toString());
//    }
//
//    public Query avg(Map<String,String> query,Map<String,String> config){
//        StringBuffer sql = new StringBuffer(" SELECT ");
//        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
//            sql.append(config.get(FindConfig.GROUP_BY)).append(" ,AVG(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
//            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
//            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
//        }else {
//            sql.append(" AVG(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
//            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE))));
//        }
//        log.info("[{}] - 查询操作，sql: {}",table,sql);
//        return runCountSql(sql.toString());
//    }
    public String groupCount(Map<String,String> query,Map<String,String> config){
        StringBuffer sql = new StringBuffer("SELECT ");
//        log.info("拼接统计函数前");
        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
            sql.append("COUNT(").append(config.get(FindConfig.GROUP_BY)).append(") FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
//            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
        }else {
            sql.append("COUNT(*) FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
        }
        log.info("[{}] - 统计操作，sql: {}",table,sql);
        return sql.toString();
    }
    public String sum(Map<String,String> query,Map<String,String> config){
        StringBuffer sql = new StringBuffer(" SELECT ");
        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
            sql.append("SUM(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
        }else {
            sql.append(" SUM(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
        }
        log.info("[{}] - 查询操作，sql: {}",table,sql);
        return sql.toString();
    }
    public String avg(Map<String,String> query,Map<String,String> config){
        StringBuffer sql = new StringBuffer(" SELECT ");
        if (config.get(FindConfig.GROUP_BY) != null && !"".equals(config.get(FindConfig.GROUP_BY))){
            sql.append("AVG(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
            sql.append(" ").append("GROUP BY ").append(config.get(FindConfig.GROUP_BY));
        }else {
            sql.append(" AVG(").append(config.get(FindConfig.FIELD)).append(") FROM ").append("`").append(table).append("`");
            sql.append(toWhereSql(query, "0".equals(config.get(FindConfig.LIKE)),config.get(FindConfig.SQLHWERE)));
        }
        log.info("[{}] - 查询操作，sql: {}",table,sql);
        return sql.toString();
    }
    public void toWhereWrapper(Map<String,String> query, Boolean like, QueryWrapper wrapper) {
        if (query.size() > 0) {
            try {
                for (Map.Entry<String, String> entry : query.entrySet()) {
                    if (entry.getKey().contains(FindConfig.MIN_)) {
                        String min = humpToLine(entry.getKey()).replace("_min", "");
                        wrapper.ge(min,URLDecoder.decode(entry.getValue(), "UTF-8"));
                        continue;
                    }
                    if (entry.getKey().contains(FindConfig.MAX_)) {
                        String max = humpToLine(entry.getKey()).replace("_max", "");
                        wrapper.le(max,URLDecoder.decode(entry.getValue(), "UTF-8"));
                        continue;
                    }
                    if (like == true) {
                        if (entry.getValue()!=null)
                            wrapper.like(humpToLine(entry.getKey()),"%"+URLDecoder.decode(entry.getValue(), "UTF-8")+"%");
                    } else {
                        if (entry.getValue()!=null)
                            wrapper.eq(humpToLine(entry.getKey()),URLDecoder.decode(entry.getValue(), "UTF-8"));
                    }
                }
            } catch (UnsupportedEncodingException e) {
                log.info("拼接sql 失败：{}", e.getMessage());
            }
        }
    }
    public String toWhereSql(Map<String,String> query, Boolean like,String sqlwhere) {
        if (query.size() > 0) {
            try {
                StringBuilder sql = new StringBuilder(" WHERE ");
                for (Map.Entry<String, String> entry : query.entrySet()) {
                    if (entry.getKey().contains(FindConfig.MIN_)) {
                        String min = humpToLine(entry.getKey()).replace("_min", "");
                        sql.append("`"+min+"`").append(" >= '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("' and ");
                        continue;
                    }
                    if (entry.getKey().contains(FindConfig.MAX_)) {
                        String max = humpToLine(entry.getKey()).replace("_max", "");
                        sql.append("`"+max+"`").append(" <= '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("' and ");
                        continue;
                    }
                    if (like == true) {
                        sql.append("`"+humpToLine(entry.getKey())+"`").append(" LIKE '%").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("%'").append(" and ");
                    } else {
                        sql.append("`"+humpToLine(entry.getKey())+"`").append(" = '").append(URLDecoder.decode(entry.getValue(), "UTF-8")).append("'").append(" and ");
                    }
                }
                if (sqlwhere!=null && !sqlwhere.trim().equals("")) {
                    sql.append(sqlwhere).append(" and ");
                }
                sql.delete(sql.length() - 4, sql.length());
                sql.append(" ");
                return sql.toString();
            } catch (UnsupportedEncodingException e) {
                log.info("拼接sql 失败：{}", e.getMessage());
            }
        }else {
            if (sqlwhere!=null && !sqlwhere.trim().equals("")) {
                StringBuilder sql = new StringBuilder(" WHERE ");
                sql.append(sqlwhere);
                return sql.toString();
            }
        }
        return "";
    }
    public Map<String,Object> readBody(BufferedReader reader){
        BufferedReader br = null;
        StringBuilder sb = new StringBuilder("");
        try{
            br = reader;
            String str;
            while ((str = br.readLine()) != null){
                sb.append(str);
            }
            br.close();
            String json = sb.toString();
            return JSONObject.parseObject(json, Map.class);
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            if (null != br){
                try{
                    br.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
    public Map<String,String> readQuery(HttpServletRequest request){
        String queryString = request.getQueryString();
        if (queryString != null && !"".equals(queryString)) {
            String[] querys = queryString.split("&");
            Map<String, String> map = new HashMap<>();
            for (String query : querys) {
                String[] q = query.split("=");
                map.put(q[0], q[1]);
            }
            map.remove(FindConfig.PAGE);
            map.remove(FindConfig.SIZE);
            map.remove(FindConfig.LIKE);
            map.remove(FindConfig.ORDER_BY);
            map.remove(FindConfig.FIELD);
            map.remove(FindConfig.GROUP_BY);
            map.remove(FindConfig.MAX_);
            map.remove(FindConfig.MIN_);
            map.remove(FindConfig.SQLHWERE);
            return map;
        }else {
            return new HashMap<>();
        }
    }
    public Map<String,String> readConfig(HttpServletRequest request){
        Map<String,String> map = new HashMap<>();
        map.put(FindConfig.PAGE,request.getParameter(FindConfig.PAGE));
        map.put(FindConfig.SIZE,request.getParameter(FindConfig.SIZE));
        map.put(FindConfig.LIKE,request.getParameter(FindConfig.LIKE));
        map.put(FindConfig.ORDER_BY,request.getParameter(FindConfig.ORDER_BY));
        map.put(FindConfig.FIELD,request.getParameter(FindConfig.FIELD));
        map.put(FindConfig.GROUP_BY,request.getParameter(FindConfig.GROUP_BY));
        map.put(FindConfig.MAX_,request.getParameter(FindConfig.MAX_));
        map.put(FindConfig.MIN_,request.getParameter(FindConfig.MIN_));
        map.put(FindConfig.SQLHWERE,request.getParameter(FindConfig.SQLHWERE));
        return map;
    }
//
    public void importDb(MultipartFile file) throws IOException {
        if (file.isEmpty()) {
            return;
        }
        List<Map<String,String>> body = new ArrayList<>();
        String fileName = file.getOriginalFilename();
        if (fileName == null){
            return;
        }
        String suffix = fileName.substring(fileName.lastIndexOf(".")+1);
        InputStream ins = file.getInputStream();
        Workbook wb = null;
        if(suffix.equals("xlsx")){
            wb = new XSSFWorkbook(ins);
        }else{
            wb = new HSSFWorkbook(ins);
        }
        Sheet sheet = wb.getSheetAt(0);
        if(null != sheet){
            for(int line = 0; line <= sheet.getLastRowNum();line++){
                Row row = sheet.getRow(line);
                if(null == row){
                    continue;
                }
                Iterator<Cell> cellIterator = row.cellIterator();
                StringBuffer sql = new StringBuffer("INSERT INTO ").append(table).append(" VALUES (null,");
                while (cellIterator.hasNext()){
                    sql.append(cellIterator.next().getStringCellValue()).append(",");
                }
                sql.deleteCharAt(sql.length());
                sql.append(")");
//                runCountSql(sql.toString());
            }
        }
    }
//    public HSSFWorkbook exportDb(Map<String,String> query, Map<String,String> config){
//        List<Map<String,String>> resultList = baseMapper.selectBaseList(select(query, config));
//        HSSFWorkbook workbook = new HSSFWorkbook();
//        HSSFSheet sheet = workbook.createSheet(table);
//        HSSFCellStyle headerStyle = workbook.createCellStyle();
//        headerStyle.setFillForegroundColor(IndexedColors.YELLOW.index);
//        headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
//        for (int i = 0; i < resultList.size(); i++) {
//            HSSFRow row = sheet.createRow(i);
//            Map<String,String> map = resultList.get(i);
//            int j = 0;
//            for (Map.Entry<String,String> entry:map.entrySet()){
//                row.createCell(j).setCellValue(new HSSFRichTextString(entry.getValue()));
//            }
//        }
//        return workbook;
//    }
    @Transactional
    public void save(E e){
        String s = JSONObject.toJSONString(e);
        Map map = JSONObject.parseObject(s, Map.class);
        insert(map);
    }
    public E findOne(Map<String, String> map){
        try {
            return (E)baseMapper.selectBaseOne(select(map, new HashMap<>()));
        }catch (Exception e){
            return null;
        }
    }
    public String encryption(String plainText) {
        String re_md5 = new String();
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(plainText.getBytes());
            byte b[] = md.digest();
            int i;
            StringBuffer buf = new StringBuffer("");
            for (int offset = 0; offset < b.length; offset++) {
                i = b[offset];
                if (i < 0)
                    i += 256;
                if (i < 16)
                    buf.append("0");
                buf.append(Integer.toHexString(i));
            }
            re_md5 = buf.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return re_md5;
    }
    public static String humpToLine(String str) {
        if (str == null) {
            return null;
        }
        // 将驼峰字符串转换成数组
        char[] charArray = str.toCharArray();
        StringBuilder buffer = new StringBuilder();
        //处理字符串
        for (int i = 0, l = charArray.length; i < l; i++) {
            if (charArray[i] >= 65 && charArray[i] <= 90) {
                buffer.append("_").append(charArray[i] += 32);
            } else {
                buffer.append(charArray[i]);
            }
        }
        String s = buffer.toString();
        if (s.startsWith("_")){
            return s.substring(1);
        }else {
            return s;
        }
    }
    public JSONObject covertObject(JSONObject object) {
        if (object == null) {
            return null;
        }
        JSONObject newObject = new JSONObject();
        Set<String> set = object.keySet();
        for (String key : set) {
            Object value = object.get(key);
            if (value instanceof JSONArray) {
                //数组
                value = covertArray(object.getJSONArray(key));
            } else if (value instanceof JSONObject) {
                //对象
                value = covertObject(object.getJSONObject(key));
            }
            //这个方法自己写的改成下划线
            key = humpToLine(key);
            newObject.put(key, value);
        }
        return newObject;
    }
    public JSONArray covertArray(JSONArray array) {
        if (array == null) {
            return null;
        }
        JSONArray newArray = new JSONArray();
        for (int i = 0; i < array.size(); i++) {
            Object value = array.get(i);
            if (value instanceof JSONArray) {
                //数组
                value = covertArray(array.getJSONArray(i));
            } else if (value instanceof JSONObject) {
                //对象
                value = covertObject(array.getJSONObject(i));
            }
            newArray.add(value);
        }
        return newArray;
    }
}

五，项目总结

通过研究如何利用微信小程序来帮助陪练行业进行信息化的运作和管理，可以有效的解决客户和陪练行业的远程对接问题。用户只需要打开微信小程序即可在线查看陪练员的信息以及相应的排名情况，并完成在线预约下单，对陪练员进行相应的反馈操作等。同时系统后台还可以对陪练公司的员工、订单等数据进行相应的管理操作。通过本课题的研发，一是有助于了解这个新兴的陪练行业，二是有助于提高陪练行业运作的效率和信息化运用的水平。

陪练预约|基于微信小程序+Springboot+vue实现陪练预约系统

项目编号：BS-XCX-015

一，环境介绍

二，项目简介

三，系统展示

3.1 前端用户的基本功能

3.2 后台管理功能展示

3.2.3 资讯管理功能展示

3.2.5 预约记录管理

四，核心代码展示

五，项目总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

陪练预约|基于微信小程序+Springboot+vue实现陪练预约系统

项目编号：BS-XCX-015

一，环境介绍

二，项目简介

三，系统展示

3.1 前端用户的基本功能

3.2 后台管理功能展示

3.2.3 资讯管理功能展示

3.2.5 预约记录管理

四，核心代码展示

五，项目总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景