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

简介: 陪练预约|基于微信小程序+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;
    }
}

五,项目总结

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

相关文章
|
4天前
|
移动开发 小程序 PHP
校园圈子论坛系统采取的PHP语音和uni账号开发的小程序APP公众号H5是否只需要4800元?是的,就是只需要4800元
关于校园圈子论坛系统采用PHP语言和uni-app开发的小程序、APP、公众号和H5是否仅需4800元这个问题,实际上很难给出一个确定的答案。这个价格可能受到多种因素的影响
|
7天前
|
缓存 移动开发 小程序
uni-vue3-wetrip自创跨三端(H5+小程序+App)酒店预订app系统模板
vue3-uni-wetrip原创基于vite5+vue3+uniapp+pinia2+uni-ui等技术开发的仿去哪儿/携程预约酒店客房app系统。实现首页酒店展示、预订搜索、列表/详情、订单、聊天消息、我的等模块。支持编译H5+小程序+App端。
42 8
|
22天前
|
移动开发 小程序
仿青藤之恋社交交友软件系统源码 即时通讯 聊天 微信小程序 App H5三端通用
仿青藤之恋社交交友软件系统源码 即时通讯 聊天 微信小程序 App H5三端通用
48 3
|
1月前
|
小程序 数据挖掘 UED
开发1个上门家政小程序APP系统,都有哪些功能?
在快节奏的现代生活中,家政服务已成为许多家庭的必需品。针对传统家政服务存在的问题,如服务质量不稳定、价格不透明等,我们历时两年开发了一套全新的上门家政系统。该系统通过完善信用体系、提供奖励机制、优化复购体验、多渠道推广和多样化盈利模式,解决了私单、复购、推广和盈利四大痛点,全面提升了服务质量和用户体验,旨在成为家政行业的领导者。
|
2月前
|
存储 传感器 小程序
跳绳计数小程序开发系统
首先,我们需要明确跳绳计数小程序的核心功能:为用户提供跳绳计数的便捷方式。这意味着小程序需要能够准确地记录用户的跳绳次数,并为用户提供清晰、直观的计数展示。
|
2月前
|
JSON JavaScript 前端开发
vue尚品汇商城项目-day00【项目介绍:此项目是基于vue2的前台电商项目和后台管理系统】
vue尚品汇商城项目-day00【项目介绍:此项目是基于vue2的前台电商项目和后台管理系统】
47 1
|
4月前
|
移动开发 安全 JavaScript
SpringBoot接入微信JSSDK,看这篇妥妥的
这篇教程详细介绍了如何在Spring Boot项目中接入微信JSSDK,实现H5页面的自定义分享和调用相册选取图片等功能。文章首先通过对比理想与现实的分享效果,引出了接入微信JSSDK的必要性。接着,作者提供了GitHub和Gitee上的项目源码链接,并逐步讲解了整个接入过程的关键步骤,包括配置文件、主要类和方法的实现细节,以及必要的微信公众号设置。此外,还特别强调了几个常见问题及其解决方案,如域名绑定、IP白名单设置和签名验证等。最后,通过实际测试验证了功能的正确性。适合初学者快速上手微信JSSDK接入。
74 8
SpringBoot接入微信JSSDK,看这篇妥妥的
|
4月前
|
小程序 前端开发 Java
SpringBoot+uniapp+uview打造H5+小程序+APP入门学习的聊天小项目
JavaDog Chat v1.0.0 是一款基于 SpringBoot、MybatisPlus 和 uniapp 的简易聊天软件,兼容 H5、小程序和 APP,提供丰富的注释和简洁代码,适合初学者。主要功能包括登录注册、消息发送、好友管理及群组交流。
115 0
SpringBoot+uniapp+uview打造H5+小程序+APP入门学习的聊天小项目
|
3月前
|
JavaScript 前端开发 搜索推荐
推荐5款免费、开箱即用的Vue后台管理系统模板
推荐5款免费、开箱即用的Vue后台管理系统模板
135 1
|
3月前
|
存储 JavaScript 前端开发
Vue 3的响应式系统是如何工作的呢
【9月更文挑战第3天】Vue 3的响应式系统是如何工作的呢
102 4

热门文章

最新文章