基于java+springboot+vue个性化定制的智慧校园管理系统

最新推荐文章于 2024-10-06 20:16:20 发布

qq_3306428634

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量46

点赞数

分类专栏： JAVA项目文章标签： java spring boot vue mysql

本文链接：https://blog.csdn.net/qq_3306428634/article/details/132125082

版权

JAVA项目专栏收录该内容

994 篇文章 52 订阅

订阅专栏

本文介绍了开发的一款智慧校园管理系统，使用Java、Mysql和SpringBoot技术，提供记事本、备忘录、软件管理等功能，旨在优化校园信息管理，提升效率和安全性。详细描述了管理员、老师和用户的不同权限功能及其实现过程。

摘要由CSDN通过智能技术生成

项目介绍

如今社会上各行各业，都喜欢用自己行业的专属软件工作，互联网发展到这个时候，人们已经发现离不开了互联网。新技术的产生，往往能解决一些老技术的弊端问题。因为传统校园综合信息管理难度大，容错率低，管理人员处理数据费工费时，所以专门为解决这个难题开发了一个智慧校园管理系统，可以解决许多问题。

智慧校园管理系统可以实现记事本管理，备忘录管理，软件管理，软件留言管理，软件收藏管理，课程管理，课程留言管理，课程收藏管理，老师管理，宿舍管理，宿舍人员管理，宿舍归寝管理，宿舍报修管理，音乐管理，音乐留言管理，音乐收藏管理，用户管理，成绩管理等功能。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。

智慧校园管理系统可以提高校园综合信息管理问题的解决效率，优化校园综合信息处理流程，保证校园综合信息数据的安全，它是一个非常可靠，非常安全的应用程序。

4.1 功能结构设计
图4.1即为设计的管理员功能结构，管理员权限操作的功能包括管理记事本，管理备忘录，管理软件，管理课程，管理音乐，管理宿舍，管理成绩，管理老师等。
在这里插入图片描述
图4.2即为设计的老师功能结构，老师权限操作的功能包括管理成绩，管理宿舍，管理宿舍归寝，管理宿舍报修，管理音乐，管理软件等。

图4.3即为设计的用户功能结构，用户权限操作的功能包括下载软件安装包，观看课程视频以及软件安装视频，播放音乐，查看成绩，管理备忘录以及记事本信息，提交宿舍报修信息，查看宿舍人员信息等。
在这里插入图片描述

开发环境

编程语言：Java
数据库：Mysql
系统架构：B/S
后端框架：SpringBoot
编译工具：idea或者eclipse，jdk1.8，maven
支持定做：java/php/python/android/小程序vue/爬虫/c#/asp.net

系统实现

5.1 管理员功能实现
5.1.1 音乐管理
图5.1 即为编码实现的音乐管理界面，管理员下架音乐，上架音乐，修改音乐信息，包括修改音乐热度，音乐名称，音乐类型等信息，删除音乐，查询音乐等。
在这里插入图片描述

图5.1 音乐管理界面

5.1.2 软件管理
图5.2 即为编码实现的软件管理界面，管理员上传计算机专业相关的软件安装包，可以修改软件描述信息，包括软件名称，软件照片，安装教程，软件类型等信息，可以下架软件，删除软件信息等。
在这里插入图片描述

图5.2 软件管理界面

5.1.3 备忘录管理
图5.3 即为编码实现的备忘录管理界面，管理员增删改查备忘录信息，备忘录信息包括备忘录名称，备忘录类型，记录时间等信息。
在这里插入图片描述

图5.3 备忘录管理界面

5.2 老师功能实现
5.2.1 宿舍管理
图5.4 即为编码实现的宿舍管理界面，老师在宿舍管理界面录入宿舍信息，宿舍信息包括宿舍地址，宿舍名称，录入时间等信息，老师可以查询宿舍，修改宿舍信息等。
在这里插入图片描述

图5.4 宿舍管理界面

5.2.2 宿舍归寝管理
图5.5 即为编码实现的宿舍归寝管理界面，老师在宿舍归寝管理界面中登记宿舍归寝信息，宿舍归寝信息包括归寝状态，归寝日期，用户姓名等信息，老师可以修改宿舍归寝信息，查询宿舍归寝信息等。
在这里插入图片描述

图5.5 宿舍归寝管理界面

5.2.3 课程管理
图5.6 即为编码实现的课程管理界面，老师需要上传课程学习视频，上传课件，登记课程信息等，同时老师可以上架课程，下架课程，修改课程描述信息，删除课程等。
在这里插入图片描述

图5.6 课程管理界面

5.2.4 成绩管理
图5.7 即为编码实现的成绩管理界面，老师登记用户的课程成绩信息，可以修改成绩分数，查询用户成绩等。
在这里插入图片描述

图5.7 成绩管理界面

5.3 用户功能实现
5.3.1 软件信息
图5.8 即为编码实现的软件信息界面，用户下载软件安装包，查看软件安装视频，在软件信息界面的下方留言区域发布留言。
在这里插入图片描述

图5.8 软件信息界面

5.3.2 课程信息
图5.9 即为编码实现的课程信息界面，用户通过课程视频学习课程知识，可以下载课程课件，可以在课程信息界面下方的留言区域发布课程留言，可以可以收藏本界面的课程。
在这里插入图片描述

图5.9 课程信息界面

5.3.3 音乐信息
图5.10 即为编码实现的音乐信息界面，用户收听音乐，可以在音乐信息界面的下方留言区域发布音乐留言信息，可以收藏音乐，已经收藏的音乐可以取消收藏。
在这里插入图片描述

图5.10 音乐信息界面

5.3.4 宿舍报修管理
图5.11 即为编码实现的宿舍报修管理界面，用户在后台的宿舍报修管理界面提交宿舍报修信息，可以查询宿舍报修信息等。
在这里插入图片描述

图5.11 宿舍报修管理界面

5.3.5 成绩查看
图5.12 即为编码实现的成绩查看界面，用户在后台的成绩查看界面查看课程考试分数，查询课程成绩。
在这里插入图片描述

图5.12 成绩查看界面

核心代码

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("engji")
public class ChengjiController {
    private static final Logger logger = LoggerFactory.getLogger(ChengjiController.class);

    @Autowired
    private ChengjiService chengjiService;


    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;

    //级联表service
    @Autowired
    private KechengService kechengService;
    @Autowired
    private YonghuService yonghuService;

    @Autowired
    private LaoshiService laoshiService;


    /**
    * 后端列表
    */
    @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("laoshiId",request.getSession().getAttribute("userId"));
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        if(params.get("orderBy")==null || params.get("orderBy")==""){
            params.put("orderBy","id");
        }
        PageUtils page = chengjiService.queryPage(params);

        //字典表数据转换
        List<ChengjiView> list =(List<ChengjiView>)page.getList();
        for(ChengjiView 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);
        ChengjiEntity chengji = chengjiService.selectById(id);
        if(chengji !=null){
            //entity转view
            ChengjiView view = new ChengjiView();
            BeanUtils.copyProperties( chengji , view );//把实体数据重构到view中

                //级联表
                KechengEntity kecheng = kechengService.selectById(chengji.getKechengId());
                if(kecheng != null){
                    BeanUtils.copyProperties( kecheng , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setKechengId(kecheng.getId());
                }
                //级联表
                YonghuEntity yonghu = yonghuService.selectById(chengji.getYonghuId());
                if(yonghu != null){
                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setYonghuId(yonghu.getId());
                }
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

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

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");
        else if("用户".equals(role))
            chengji.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));

        Wrapper<ChengjiEntity> queryWrapper = new EntityWrapper<ChengjiEntity>()
            .eq("yonghu_id", chengji.getYonghuId())
            .eq("kecheng_id", chengji.getKechengId())
            .eq("chengji_name", chengji.getChengjiName())
            .eq("beizhu", chengji.getBeizhu())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChengjiEntity chengjiEntity = chengjiService.selectOne(queryWrapper);
        if(chengjiEntity==null){
            chengji.setInsertTime(new Date());
            chengji.setCreateTime(new Date());
            chengjiService.insert(chengji);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody ChengjiEntity chengji, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,chengji:{}",this.getClass().getName(),chengji.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");
//        else if("用户".equals(role))
//            chengji.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
        //根据字段查询是否有相同数据
        Wrapper<ChengjiEntity> queryWrapper = new EntityWrapper<ChengjiEntity>()
            .notIn("id",chengji.getId())
            .andNew()
            .eq("yonghu_id", chengji.getYonghuId())
            .eq("kecheng_id", chengji.getKechengId())
            .eq("chengji_name", chengji.getChengjiName())
            .eq("beizhu", chengji.getBeizhu())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChengjiEntity chengjiEntity = chengjiService.selectOne(queryWrapper);
        if(chengjiEntity==null){
            chengjiService.updateById(chengji);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        chengjiService.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");
        try {
            List<ChengjiEntity> chengjiList = 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){
                            //循环
                            ChengjiEntity chengjiEntity = new ChengjiEntity();
//                            chengjiEntity.setYonghuId(Integer.valueOf(data.get(0)));   //用户 要改的
//                            chengjiEntity.setKechengId(Integer.valueOf(data.get(0)));   //课程 要改的
//                            chengjiEntity.setChengjiName(data.get(0));                    //成绩名称 要改的
//                            chengjiEntity.setChengjiChengji(data.get(0));                    //成绩 要改的
//                            chengjiEntity.setBeizhu(data.get(0));                    //备注 要改的
//                            chengjiEntity.setInsertTime(date);//时间
//                            chengjiEntity.setCreateTime(date);//时间
                            chengjiList.add(chengjiEntity);


                            //把要查询是否重复的字段放入map中
                        }

                        //查询是否重复
                        chengjiService.insertBatch(chengjiList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }





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

        // 没有指定排序字段就默认id倒序
        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
            params.put("orderBy","id");
        }
        PageUtils page = chengjiService.queryPage(params);

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

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


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

                //级联表
                    KechengEntity kecheng = kechengService.selectById(chengji.getKechengId());
                if(kecheng != null){
                    BeanUtils.copyProperties( kecheng , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setKechengId(kecheng.getId());
                }
                //级联表
                    YonghuEntity yonghu = yonghuService.selectById(chengji.getYonghuId());
                if(yonghu != null){
                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setYonghuId(yonghu.getId());
                }
                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody ChengjiEntity chengji, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,chengji:{}",this.getClass().getName(),chengji.toString());
        Wrapper<ChengjiEntity> queryWrapper = new EntityWrapper<ChengjiEntity>()
            .eq("yonghu_id", chengji.getYonghuId())
            .eq("kecheng_id", chengji.getKechengId())
            .eq("chengji_name", chengji.getChengjiName())
            .eq("beizhu", chengji.getBeizhu())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChengjiEntity chengjiEntity = chengjiService.selectOne(queryWrapper);
        if(chengjiEntity==null){
            chengji.setInsertTime(new Date());
            chengji.setCreateTime(new Date());
        chengjiService.insert(chengji);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }


}

论文参考

在这里插入图片描述

目录
摘要 I
Abstract II
第1章绪论 1
1.1 课题背景 1
1.2 课题意义 1
1.3 研究内容 1
第2章开发环境与技术 3
2.1 Java语言 3
2.2 MYSQL数据库 3
2.3 IDEA开发工具 4
2.4 Spring Boot框架 4
第3章系统分析 5
3.1 可行性分析 5
3.1.1 技术可行性 5
3.1.2 经济可行性 5
3.1.3 操作可行性 5
3.2 系统流程 5
3.2.1 操作流程 6
3.2.2 登录流程 6
3.2.3 删除信息流程 7
3.2.4 添加信息流程 7
3.3 性能需求 8
3.4 功能需求 9
第4章系统设计 13
4.1 功能结构设计 13
4.2 数据库设计 15
4.2.1 数据库概念设计 15
4.2.2 数据库物理设计 19
第5章系统实现 27
5.1 管理员功能实现 27
5.1.1 音乐管理 27
5.1.2 软件管理 27
5.1.3 备忘录管理 28
5.2 老师功能实现 28
5.2.1 宿舍管理 28
5.2.2 宿舍归寝管理 29
5.2.3 课程管理 29
5.2.4 成绩管理 30
5.3 用户功能实现 30
5.3.1 软件信息 30
5.3.2 课程信息 31
5.3.3 音乐信息 31
5.3.4 宿舍报修管理 32
5.3.5 成绩查看 32
第6章系统测试 34
6.1 功能测试 34
6.1.1 登录功能测试 34
6.1.2 修改密码功能测试 35
6.2 系统测试结果 36
结论 37
参考文献 38
致谢 39