基于微信小程序实现校篮球联赛系统

最新推荐文章于 2024-10-17 15:09:22 发布

qq_469603589

最新推荐文章于 2024-10-17 15:09:22 发布

阅读量1k

点赞数 13

分类专栏：微信小程序文章标签：微信小程序小程序篮球比赛小程序

本文链接：https://blog.csdn.net/znzbs/article/details/142504511

版权

微信小程序专栏收录该内容

118 篇文章 1 订阅

订阅专栏

作者简介：Java领域优质创作者、CSDN博客专家、CSDN内容合伙人、掘金特邀作者、阿里云博客专家、51CTO特邀作者、多年架构师设计经验、多年校企合作经验，被多个学校常年聘为校外企业导师，指导学生毕业设计并参与学生毕业答辩指导，有较为丰富的相关经验。期待与各位高校教师、企业讲师以及同行交流合作

主要内容：Java项目、Python项目、前端项目、PHP、ASP.NET、人工智能与大数据、单片机开发、物联网设计与开发设计、简历模板、学习资料、面试题库、技术互助、就业指导等

业务范围：免费功能设计、开题报告、任务书、中期检查PPT、系统功能实现、代码编写、论文编写和辅导、论文降重、长期答辩答疑辅导、腾讯会议一对一专业讲解辅导答辩、模拟答辩演练、和理解代码逻辑思路等。

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

文末获取源码

项目编号：BS-XCX-087

一，环境介绍

语言环境：微信小程序

数据库：Mysql: mysql5.7

WEB框架：SpringBoot+Vue

开发工具：IDEA和微信开发者工具

二，项目简介

篮球比赛小程序系统是一种基于移动互联网技术的应用程序，旨在提高篮球比赛的组织效率、参与度和互动性。以下是对篮球比赛小程序系统的详细说明：

（1）、系统概述

篮球比赛小程序系统通过微信小程序平台实现，结合了现代信息技术与篮球比赛管理的实际需求，为赛事组织者、参赛队伍、观众等提供便捷、实时、互动的服务。该系统不仅简化了比赛管理流程，还增强了比赛的趣味性和观赏性。

（2）、系统架构与技术选型

1. 系统架构

系统通常采用B/S（浏览器/服务器）架构，前端通过微信小程序展示，后端使用Java等编程语言结合SpringBoot等框架开发，数据库采用MySQL等关系型数据库管理系统。

2. 技术选型

前端：微信小程序，利用微信提供的开发者工具进行开发，实现跨平台运行。
后端：Java、SpringBoot等，提供稳定、高效的服务端支持。
数据库：MySQL，存储比赛数据、用户信息、赛事信息等。
其他工具：Maven用于项目管理，IDEA等IDE用于代码开发。

（3）、功能模块

篮球比赛小程序系统通常包含以下功能模块：

1. 用户管理

注册与登录：用户可以通过手机号、微信账号等方式注册并登录小程序。
个人信息管理：用户可以查看和编辑自己的个人信息，如姓名、头像、联系方式等。

2. 赛事管理

赛事发布：赛事组织者可以发布比赛信息，包括比赛时间、地点、参赛队伍等。
赛事报名：参赛队伍可以通过小程序进行报名，并查看报名状态。
赛事安排：系统根据报名情况自动或手动安排比赛日程。
赛事结果：实时更新比赛结果，包括比分、胜负情况等。

3. 球队与球员管理

球队信息：展示参赛队伍的基本信息，如队名、队徽、队员名单等。
球员信息：记录球员的详细信息，如姓名、位置、技术统计等。
球员报名：球员可以通过小程序报名参加比赛。

4. 技术统计与记分

实时记分：比赛过程中，可以实时更新比分和技术统计。
详细记录：记录球员的得分、篮板、助攻、抢断、盖帽等详细数据。
历史数据：保存比赛的历史数据，供用户随时查看。

5. 互动与交流

讨论区：用户可以在讨论区发表对比赛的看法、交流心得。
通知与提醒：系统可以发送比赛通知、报名提醒等给用户。

（4）、系统优势

便捷性：用户无需下载额外应用，只需在微信中打开小程序即可使用。
实时性：比赛结果和技术统计实时更新，用户可以随时查看。
互动性：提供讨论区等功能，增强用户之间的互动和交流。
高效性：简化比赛管理流程，提高组织效率。

（5）、应用场景

篮球比赛小程序系统适用于各类篮球赛事的管理和运营，包括校园篮球联赛、业余篮球比赛、企业篮球赛等。通过该系统，赛事组织者可以更加高效地组织比赛，参赛队伍和观众可以更加便捷地获取比赛信息并参与互动。

综上所述，篮球比赛小程序系统是一种功能丰富、便捷高效的篮球赛事管理工具，对于提升篮球比赛的组织水平、参与度和观赏性具有重要意义。

以下是篮球比赛小程序系统说明相关的视频，提供了小程序的使用方法，包括创建比赛、添加球队和球员、以及计分等功能，可供参考:

三，系统展示

后台管理系统

四，核心代码展示


package com.controller;

import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;

import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;

/**
 * 球队
 * 后端接口
 * @author
 * @email
*/
@RestController
@Controller
@RequestMapping("/qiudui")
public class QiuduiController {
    private static final Logger logger = LoggerFactory.getLogger(QiuduiController.class);

    private static final String TABLE_NAME = "qiudui";

    @Autowired
    private QiuduiService qiuduiService;


    @Autowired
    private TokenService tokenService;

    @Autowired
    private DictionaryService dictionaryService;//字典
    @Autowired
    private GonggaoService gonggaoService;//公告
    @Autowired
    private QiuduiCollectionService qiuduiCollectionService;//球队收藏
    @Autowired
    private QiuduiLiuyanService qiuduiLiuyanService;//球队留言
    @Autowired
    private QiuyuanService qiuyuanService;//球员
    @Autowired
    private QiuyuanCollectionService qiuyuanCollectionService;//球员收藏
    @Autowired
    private QiuyuanLiuyanService qiuyuanLiuyanService;//球员留言
    @Autowired
    private SaishixinxiService saishixinxiService;//赛事信息
    @Autowired
    private SaishixinxiCollectionService saishixinxiCollectionService;//赛事信息收藏
    @Autowired
    private YonghuService yonghuService;//用户
    @Autowired
    private UsersService usersService;//管理员


    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永不会进入");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        CommonUtil.checkMap(params);
        PageUtils page = qiuduiService.queryPage(params);

        //字典表数据转换
        List<QiuduiView> list =(List<QiuduiView>)page.getList();
        for(QiuduiView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        QiuduiEntity qiudui = qiuduiService.selectById(id);
        if(qiudui !=null){
            //entity转view
            QiuduiView view = new QiuduiView();
            BeanUtils.copyProperties( qiudui , view );//把实体数据重构到view中
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody QiuduiEntity qiudui, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,qiudui:{}",this.getClass().getName(),qiudui.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");

        Wrapper<QiuduiEntity> queryWrapper = new EntityWrapper<QiuduiEntity>()
            .eq("qiudui_name", qiudui.getQiuduiName())
            .eq("qiudui_address", qiudui.getQiuduiAddress())
            .eq("zan_number", qiudui.getZanNumber())
            .eq("cai_number", qiudui.getCaiNumber())
            .eq("qiudui_types", qiudui.getQiuduiTypes())
            .eq("qiudui_shenglv", qiudui.getQiuduiShenglv())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        QiuduiEntity qiuduiEntity = qiuduiService.selectOne(queryWrapper);
        if(qiuduiEntity==null){
            qiudui.setZanNumber(1);
            qiudui.setCaiNumber(1);
            qiudui.setQiuduiClicknum(1);
            qiudui.setInsertTime(new Date());
            qiudui.setCreateTime(new Date());
            qiuduiService.insert(qiudui);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody QiuduiEntity qiudui, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
        logger.debug("update方法:,,Controller:{},,qiudui:{}",this.getClass().getName(),qiudui.toString());
        QiuduiEntity oldQiuduiEntity = qiuduiService.selectById(qiudui.getId());//查询原先数据

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");
        if("".equals(qiudui.getQiuduiPhoto()) || "null".equals(qiudui.getQiuduiPhoto())){
                qiudui.setQiuduiPhoto(null);
        }
        if("".equals(qiudui.getQiuduiContent()) || "null".equals(qiudui.getQiuduiContent())){
                qiudui.setQiuduiContent(null);
        }

            qiuduiService.updateById(qiudui);//根据id更新
            return R.ok();
    }



    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        List<QiuduiEntity> oldQiuduiList =qiuduiService.selectBatchIds(Arrays.asList(ids));//要删除的数据
        qiuduiService.deleteBatchIds(Arrays.asList(ids));

        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName, HttpServletRequest request){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //.eq("time", new SimpleDateFormat("yyyy-MM-dd").format(new Date()))
        try {
            List<QiuduiEntity> qiuduiList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            QiuduiEntity qiuduiEntity = new QiuduiEntity();
//                            qiuduiEntity.setQiuduiUuidNumber(data.get(0));                    //球队编号 要改的
//                            qiuduiEntity.setQiuduiName(data.get(0));                    //球队名称 要改的
//                            qiuduiEntity.setQiuduiPhoto("");//详情和图片
//                            qiuduiEntity.setQiuduiAddress(data.get(0));                    //球队位置 要改的
//                            qiuduiEntity.setZanNumber(Integer.valueOf(data.get(0)));   //赞 要改的
//                            qiuduiEntity.setCaiNumber(Integer.valueOf(data.get(0)));   //踩 要改的
//                            qiuduiEntity.setQiuduiTypes(Integer.valueOf(data.get(0)));   //球队类型 要改的
//                            qiuduiEntity.setQiuduiShenglv(data.get(0));                    //胜率 要改的
//                            qiuduiEntity.setQiuduiClicknum(Integer.valueOf(data.get(0)));   //球队热度 要改的
//                            qiuduiEntity.setQiuduiContent("");//详情和图片
//                            qiuduiEntity.setInsertTime(date);//时间
//                            qiuduiEntity.setCreateTime(date);//时间
                            qiuduiList.add(qiuduiEntity);


                            //把要查询是否重复的字段放入map中
                                //球队编号
                                if(seachFields.containsKey("qiuduiUuidNumber")){
                                    List<String> qiuduiUuidNumber = seachFields.get("qiuduiUuidNumber");
                                    qiuduiUuidNumber.add(data.get(0));//要改的
                                }else{
                                    List<String> qiuduiUuidNumber = new ArrayList<>();
                                    qiuduiUuidNumber.add(data.get(0));//要改的
                                    seachFields.put("qiuduiUuidNumber",qiuduiUuidNumber);
                                }
                        }

                        //查询是否重复
                         //球队编号
                        List<QiuduiEntity> qiuduiEntities_qiuduiUuidNumber = qiuduiService.selectList(new EntityWrapper<QiuduiEntity>().in("qiudui_uuid_number", seachFields.get("qiuduiUuidNumber")));
                        if(qiuduiEntities_qiuduiUuidNumber.size() >0 ){
                            ArrayList<String> repeatFields = new ArrayList<>();
                            for(QiuduiEntity s:qiuduiEntities_qiuduiUuidNumber){
                                repeatFields.add(s.getQiuduiUuidNumber());
                            }
                            return R.error(511,"数据库的该表中的 [球队编号] 字段已经存在 存在数据为:"+repeatFields.toString());
                        }
                        qiuduiService.insertBatch(qiuduiList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }



    /**
    * 个性推荐
    */
    @IgnoreAuth
    @RequestMapping("/gexingtuijian")
    public R gexingtuijian(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("gexingtuijian方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        CommonUtil.checkMap(params);
        List<QiuduiView> returnQiuduiViewList = new ArrayList<>();

        //查看收藏
        Map<String, Object> params1 = new HashMap<>(params);params1.put("sort","id");params1.put("yonghuId",request.getSession().getAttribute("userId"));
        params1.put("shangxiaTypes",1);
        params1.put("qiuduiYesnoTypes",2);
        PageUtils pageUtils = qiuduiCollectionService.queryPage(params1);
        List<QiuduiCollectionView> collectionViewsList =(List<QiuduiCollectionView>)pageUtils.getList();
        Map<Integer,Integer> typeMap=new HashMap<>();//购买的类型list
        for(QiuduiCollectionView collectionView:collectionViewsList){
            Integer qiuduiTypes = collectionView.getQiuduiTypes();
            if(typeMap.containsKey(qiuduiTypes)){
                typeMap.put(qiuduiTypes,typeMap.get(qiuduiTypes)+1);
            }else{
                typeMap.put(qiuduiTypes,1);
            }
        }
        List<Integer> typeList = new ArrayList<>();//排序后的有序的类型 按最多到最少
        typeMap.entrySet().stream().sorted((o1, o2) -> o2.getValue() - o1.getValue()).forEach(e -> typeList.add(e.getKey()));//排序
        Integer limit = Integer.valueOf(String.valueOf(params.get("limit")));
        for(Integer type:typeList){
            Map<String, Object> params2 = new HashMap<>(params);params2.put("qiuduiTypes",type);
            params2.put("shangxiaTypes",1);
            params2.put("qiuduiYesnoTypes",2);
            PageUtils pageUtils1 = qiuduiService.queryPage(params2);
            List<QiuduiView> qiuduiViewList =(List<QiuduiView>)pageUtils1.getList();
            returnQiuduiViewList.addAll(qiuduiViewList);
            if(returnQiuduiViewList.size()>= limit) break;//返回的推荐数量大于要的数量 跳出循环
        }
        params.put("shangxiaTypes",1);
        params.put("qiuduiYesnoTypes",2);
        //正常查询出来商品,用于补全推荐缺少的数据
        PageUtils page = qiuduiService.queryPage(params);
        if(returnQiuduiViewList.size()<limit){//返回数量还是小于要求数量
            int toAddNum = limit - returnQiuduiViewList.size();//要添加的数量
            List<QiuduiView> qiuduiViewList =(List<QiuduiView>)page.getList();
            for(QiuduiView qiuduiView:qiuduiViewList){
                Boolean addFlag = true;
                for(QiuduiView returnQiuduiView:returnQiuduiViewList){
                    if(returnQiuduiView.getId().intValue() ==qiuduiView.getId().intValue()) addFlag=false;//返回的数据中已存在此商品
                }
                if(addFlag){
                    toAddNum=toAddNum-1;
                    returnQiuduiViewList.add(qiuduiView);
                    if(toAddNum==0) break;//够数量了
                }
            }
        }else {
            returnQiuduiViewList = returnQiuduiViewList.subList(0, limit);
        }

        for(QiuduiView c:returnQiuduiViewList)
            dictionaryService.dictionaryConvert(c, request);
        page.setList(returnQiuduiViewList);
        return R.ok().put("data", page);
    }

    /**
    * 前端列表
    */
    @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));

        CommonUtil.checkMap(params);
        PageUtils page = qiuduiService.queryPage(params);

        //字典表数据转换
        List<QiuduiView> list =(List<QiuduiView>)page.getList();
        for(QiuduiView c:list)
            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段

        return R.ok().put("data", page);
    }

    /**
    * 前端详情
    */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        QiuduiEntity qiudui = qiuduiService.selectById(id);
            if(qiudui !=null){

                //点击数量加1
                qiudui.setQiuduiClicknum(qiudui.getQiuduiClicknum()+1);
                qiuduiService.updateById(qiudui);

                //entity转view
                QiuduiView view = new QiuduiView();
                BeanUtils.copyProperties( qiudui , view );//把实体数据重构到view中

                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody QiuduiEntity qiudui, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,qiudui:{}",this.getClass().getName(),qiudui.toString());
        Wrapper<QiuduiEntity> queryWrapper = new EntityWrapper<QiuduiEntity>()
            .eq("qiudui_uuid_number", qiudui.getQiuduiUuidNumber())
            .eq("qiudui_name", qiudui.getQiuduiName())
            .eq("qiudui_address", qiudui.getQiuduiAddress())
            .eq("zan_number", qiudui.getZanNumber())
            .eq("cai_number", qiudui.getCaiNumber())
            .eq("qiudui_types", qiudui.getQiuduiTypes())
            .eq("qiudui_shenglv", qiudui.getQiuduiShenglv())
            .eq("qiudui_clicknum", qiudui.getQiuduiClicknum())
//            .notIn("qiudui_types", new Integer[]{102})
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        QiuduiEntity qiuduiEntity = qiuduiService.selectOne(queryWrapper);
        if(qiuduiEntity==null){
                qiudui.setZanNumber(1);
                qiudui.setCaiNumber(1);
            qiudui.setQiuduiClicknum(1);
            qiudui.setInsertTime(new Date());
            qiudui.setCreateTime(new Date());
        qiuduiService.insert(qiudui);

            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

}