AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Springboot+vue实现前后端分离智能化考试系统

2022-12-14 227
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
简介： Springboot+vue实现前后端分离智能化考试系统

项目编号：BS-GX-041

前言：

在生活中，我们通常使用传统的纸质化考试；这就意味着花费大量的人力、物力、财力、时间和纸张，日复一日，年复一年，这种考试方式在一定程度上影响了学校的工作效率。基于这一原因，本次设计开发一个在线考试系统，解决传统纸质化考试带来的不便因素。在线考试系统是以现代信息技术为手段，通过组卷生成无纸化考试试卷进行考试，并及时生成考试成绩，具有提高管理工作效率、节约考试资源、规范考试管理、方便考生应考等传统考试不可替代的优势。


考试系统采用前后端分离，前端采用了vue+elementUI,后端采用Java语言，系统应用了Springboot+MyBatis的框架技术，在IDEA环境下开发完成。前台功能主要有用户注册登录，试题练习，会员中心，个人设置等功能模块。后台功能主要有试题、试卷、会员、题库管理，网站设置等功能模块。


本系统按照软件工程原理、方法进行开发，为学生课程练习及考试提供了灵活、方便、科学的检测手段。经测试，试用，目前本系统基本达到了设计任务书的设计目标，能够用于学校的机考工作。

一，项目简介

本项目基于Springboot+Vue开发实现了一套前后端分离的智能化考试管理系统，系统拥有完善的权限管理系统，可以根据不同的用户角色分配不同的权限，不同角色的用户登陆系统后可以进行不同的功能操作。目前根据业务划分为三个角色：系统管理员、老师、学生

管理登陆系统后可以操作的功能模块：

  1. 用户管理：管理学生和教师
  2. 试题管理：添加和管理试题，可以添加主观题与客观题等
  3. 试卷管理：实现自动组卷功能
  4. 角色管理：管理不同的角色及权限分配
  5. 菜单管理：也即权限管理，对显示的菜单功能进行管理
  6. 考试科目管理：管理考试的科目
  7. 班级管理：管理班级信息
  8. 成绩查询:查询各班学生的考试成绩
  9. 成绩统计：以图形报表方式统计不同分数段的考试情况

教师登陆系统：

  1. 个人密码修改
  2. 试题管理
  3. 试卷管理
  4. 成绩查询
  5. 成绩统计

学生登陆系统

  1. 个人密码修改
  2. 参与考试：选择要参与的试卷进行在线答题并自动算分
  3. 成绩查询

二，环境介绍

语言环境：Java:  jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat:  tomcat8.5.31

开发工具：IDEA或eclipse

后台开发技术：springboot+mybatis

前台开发技术：vue+nodejs+elementUI

语言环境：Java:  jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat:  tomcat8.5.31

开发工具：IDEA或eclipse

三，系统展示

管理员登陆

image.png

用户注册

image.png

用户管理

image.png

角色管理及权限分配

image.png

菜单权限管理

image.png

试题管理

image.png

image.png

科目管理

image.png

试卷管理

image.png

image.png

班级管理

image.png

成绩查询

image.png

成绩统计

image.png

四，核心代码展示

package cn.exam.controller;
import cn.exam.config.BaseController;
import cn.exam.config.UserUtil;
import cn.exam.dao.mapper.zj.ZjPaperTestMapper;
import cn.exam.dao.mapper.zj.ZjSubjectUserLinkMapper;
import cn.exam.dao.mapper.zj.ZjTitleInfoMapper;
import cn.exam.domain.zj.*;
import cn.exam.query.PaperByUserIdQuery;
import cn.exam.query.PaperQuery;
import cn.exam.query.TitlePageQuery;
import cn.exam.service.ExaminationService;
import cn.exam.util.DateUtil;
import cn.exam.util.PageResult;
import cn.exam.util.ResultDTO;
import cn.exam.util.SystemCode;
import cn.exam.vo.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;
/**
 *
 * @version 1.0
 * @date 2022-02-26 14:30
 */
@Controller
@RequestMapping("title")
public class ExaminationController extends BaseController {
    @Autowired
    private ExaminationService examinationService;
    @Autowired
    private UserUtil userUtil;
    @RequestMapping("queryTitlePage.htm")
    public void queryTitlePage(HttpServletResponse response, TitlePageQuery query) {
        ResultDTO<PageResult<List<TitleVO>>> resultDTO = new ResultDTO<>();
        PageResult<List<TitleVO>> listPageResult = examinationService.queryPage(query);
        resultDTO.setResult(listPageResult);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJsonSuccessPage(resultDTO, response);
    }
    //试卷分页
    @RequestMapping("queryPaperPage.htm")
    public void queryTitlePage(HttpServletResponse response, PaperQuery query) {
        ResultDTO<PageResult<List<PaperPageVO>>> resultDTO = new ResultDTO<>();
        PageResult<List<PaperPageVO>> listPageResult = examinationService.queryManagerPage(query);
        resultDTO.setResult(listPageResult);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJsonSuccessPage(resultDTO, response);
    }
    @RequestMapping("insertByTitle.htm")
    public void insertByTitle(ZjTitleInfo info, HttpServletResponse response) {
        UserVO user = userUtil.getUser();
        examinationService.insertTitle(info, user);
        sendJsonSuccess(response);
    }
    @RequestMapping("queryTitleInfo.htm")
    public void queryTitleInfo(HttpServletResponse response, Integer titleId) {
        ResultDTO<TitleVO> resultDTO = new ResultDTO<>();
        resultDTO.setResult(examinationService.queryTitleInfo(titleId));
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJsonSuccess(resultDTO, response);
    }
    @RequestMapping("deleteTileInfo.htm")
    public void deleteTileInfo(HttpServletResponse response, Integer titleId) {
        examinationService.deleteTitle(titleId);
        sendJsonSuccess(response);
    }
    @RequestMapping("updateTitle.htm")
    public void updateTitle(HttpServletResponse response,ZjTitleInfo info){
        examinationService.updateTitle(info);
        sendJsonSuccess(response);
    }
    //试卷页面
    @RequestMapping("queryPaper.htm")
    public void queryPaper(Integer paperId,HttpServletResponse response){
        ResultDTO<PaperTestLevel> resultDTO = new ResultDTO<>();
        resultDTO.setResult(examinationService.queryPaper(paperId));
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJsonSuccess(resultDTO, response);
    }
    //考生查看考完的试卷
    @RequestMapping("queryPaperCompleted.htm")
    public void   queryPaperCompleted(Integer paperId,HttpServletResponse response) {
        ResultDTO<PaperTestLevel> resultDTO = new ResultDTO<>();
        UserVO user = userUtil.getUser();
        resultDTO.setResult(examinationService.queryPaperCompleted(paperId,user.getUserId()));
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJsonSuccess(resultDTO, response);
    }
    //组卷功能
    @RequestMapping("audioExam.htm")
    public void audioExam(ZjPaperInfo paperInfo,HttpServletResponse response){
        UserVO user = userUtil.getUser();
        paperInfo.setTeachId(user.getUserId());
        paperInfo.setTeachName(user.getUserName());
        examinationService.audioPaper(paperInfo);
        sendJsonSuccess( response);
    }
    @RequestMapping("updateTitleByList.htm")
    public void updateTitleByList(String titleString,HttpServletResponse response){
        examinationService.updateTitle(titleString);
        sendJsonSuccess(response);
    }
    /**
     * 学生已考试卷查询分页
     */
    @RequestMapping("queryPaperByUserId.htm")
    public void queryPaperByUserId(PaperByUserIdQuery query, HttpServletResponse response){
        ResultDTO<PageResult<List<PaperByUserIdVO>>> resultDTO = new ResultDTO<>();
        UserVO user = userUtil.getUser();
        query.setUserId(user.getUserId());
        PageResult<List<PaperByUserIdVO>> listPageResult = examinationService.queryPaperByUserId(query);
        resultDTO.setResult(listPageResult);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJsonSuccessPage(resultDTO, response);
    }
}
package cn.exam.controller;
import cn.exam.config.BaseController;
import cn.exam.config.RedisUtil;
import cn.exam.dao.mapper.zj.ZjUserInfoMapper;
import cn.exam.dao.mapper.zj.ZjUserRoleMapper;
import cn.exam.domain.zj.ZjUserInfo;
import cn.exam.domain.zj.ZjUserRole;
import cn.exam.query.UserQuery;
import cn.exam.redis.RedisKeyEnum;
import cn.exam.service.UserInfoService;
import cn.exam.service.ZjRoleMenuService;
import cn.exam.util.*;
import cn.exam.vo.MenuInfoVO;
import cn.exam.vo.UserPageVO;
import cn.exam.vo.UserVO;
import cn.zq.exam.so.UserInfoSO;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
import java.util.stream.Collectors;
/**
 * @author YS
 * @version 1.0
 * @date 2021-02-02 14:49
 */
@Controller
@RequestMapping("login")
public class LoginController extends BaseController {
    @Autowired
    private UserInfoService userInfoService;
    @Autowired
    private ZjUserInfoMapper userInfoMapper;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private ZjRoleMenuService roleMenuService;
    @Autowired
    private ZjUserRoleMapper  userRoleMapper;
    /**
     * 登录
     */
    @RequestMapping("login.htm")
    public void login(ZjUserInfo userInfo, HttpServletResponse response) {
        ResultDTO<UserVO> resultDTO = new ResultDTO<>();
        //注册shiro
        UserVO tblUser = userInfoService.queryUserInfoByName(userInfo.getUserId());
        if (ObjectUtils.isEmpty(tblUser)) {
            throw new ExpressException(SystemCode.SERVICE_FAILD_CODE, "账号输入有误");
        }
        String s = MD5Utils.md5(userInfo.getPassword());
        if (!s.equals(tblUser.getPassword())) {
            throw new ExpressException(SystemCode.SERVICE_FAILD_CODE, "密码错误");
        }
        UsernamePasswordToken shiroToken = new UsernamePasswordToken(userInfo.getUserId(), MD5Utils.md5(userInfo.getPassword()));
        Subject currentUser = SecurityUtils.getSubject();
        currentUser.login(shiroToken);
        //获取用户信息
        Object principal = SecurityUtils.getSubject().getPrincipal();
        UserVO user1 = (UserVO) principal;
        try {
            resultDTO.setDescription(SystemCode.RET_MSG_SUCC);
            String token = UUID.randomUUID().toString();
            user1.setToken(token);
            resultDTO.setCode(SystemCode.RET_CODE_SUCC);
            resultDTO.setResult(user1);//LOGIN_USER_INFO:UUID.randomUUID().toString()
            redisUtil.setKeyTime(RedisKeyEnum.USER.getCode() + ":" + token, JSON.toJSONString(user1), Constant.KEY_IN_REDIS_TIME);
        } catch (IncorrectCredentialsException e) {
            resultDTO.setCode(SystemCode.USER_LOGIN_ERROR_CODE);
            resultDTO.setDescription("密码错误");
        } catch (LockedAccountException e) {
            resultDTO.setCode(SystemCode.USER_LOGIN_ERROR_CODE);
            resultDTO.setDescription("登录失败，该用户已被冻结");
        } catch (IllegalStateException e) {
            resultDTO.setCode(SystemCode.SYS_OVERDUE_CODE);
            resultDTO.setDescription(SystemCode.SYS_OVERDUE_CODE_DESC);
        } catch (Exception e) {
            resultDTO.setCode(SystemCode.USER_LOGIN_ERROR_CODE);
            resultDTO.setDescription(SystemCode.USER_LOGIN_ERROR_MSG);
        }
        sendJsonResult(resultDTO, response);
    }
    /**
     * 角色菜单查询
     *
     * @param roleId   角色id
     * @param response 响应体
     */
    @RequestMapping("queryMenuList.htm")
    public void queryMenuList(String roleId, HttpServletResponse response) {
        JSONArray array = JSON.parseArray(roleId);
        List<String> roleIdList = new ArrayList<>();
        for (Object json : array) {
            JSONObject jsonObject = JSON.parseObject(json.toString());
            Object roleId1 = jsonObject.get("roleId");
            roleIdList.add(roleId1.toString());
        }
        ResultDTO<List<MenuInfoVO>> resultDTO = new ResultDTO<>();
        List<MenuInfoVO> menuVOS = roleMenuService.queryMenuList(roleIdList);
        //jdk8新特性 stream流处理去重
        ArrayList<MenuInfoVO> infos2 =
                menuVOS.stream()
                        .collect(Collectors.collectingAndThen(Collectors
                                .toCollection(() -> new TreeSet<>(Comparator
                                        .comparing(MenuInfoVO::getMenuId))), ArrayList::new));
        resultDTO.setResult(infos2);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJson(resultDTO, response);
    }
    /**
     * 退出
     */
    @RequestMapping(method = RequestMethod.POST, value = "logout.htm")
    public void logout(HttpServletResponse response) {
        Subject currentUser = SecurityUtils.getSubject();
        currentUser.logout();
        sendJsonSuccess(response);
    }
    /**
     * 注册
     */
    @RequestMapping("registerLogin.htm")
    public void registerLogin(UserInfoSO so, HttpServletResponse response) {
        ResultDTO<ZjUserInfo> resultDTO = new ResultDTO<>();
        if (ObjectUtils.isEmpty(so.getUserId()) || ObjectUtils.isEmpty(so.getPassword()) || ObjectUtils.isEmpty(so.getUserName())) {
            throw new ExpressException(SystemCode.SERVICE_FAILD_CODE, "必填字段不能为空");
        }
        if (!so.getPassword().equals(so.getConfirmPassword())) {
            throw new ExpressException(SystemCode.SERVICE_FAILD_CODE, "密码不一致");
        }
        UserVO user = userInfoMapper.queryShiroUserInfoByUserName(so.getUserId());
        if (!ObjectUtils.isEmpty(user)) {
            throw new ExpressException(SystemCode.SERVICE_FAILD_CODE, "账号已存在，请勿重复注册");
        }
        ZjUserInfo userInfo = new ZjUserInfo();
        String currentTime = DateUtils.getCurrentTime();
        userInfo.setUserId(so.getUserId());
        userInfo.setUserName(so.getUserName());
        userInfo.setTypeId(so.getTypeId());
        if (so.getTypeId()==0){
            userInfo.setClassId(so.getClassId());
        }
        userInfo.setPassword(MD5Utils.md5(so.getPassword()));
        userInfo.setCreateTime(currentTime);
        userInfo.setUpdateTime(currentTime);
        userInfoMapper.insertSelective(userInfo);
        ZjUserRole userRole = new ZjUserRole();
        if (so.getTypeId()==0){
            userRole.setRoleId("student");
        }else if (so.getTypeId()==1){
            userRole.setRoleId("teacher");
        }
        userRole.setUserId(userInfo.getUserId());
        userRoleMapper.insertSelective(userRole);
        resultDTO.setDescription(SystemCode.RET_MSG_SUCC);
        resultDTO.setCode(SystemCode.RET_CODE_SUCC);
        sendJsonSuccess(resultDTO, response);
    }
    /**
     * 用户查询页面
     */
    @RequestMapping("queryUserInfo.htm")
    public void queryPage(HttpServletResponse response, UserQuery query) {
        ResultDTO<PageResult<List<UserPageVO>>> resultDTO = new ResultDTO<>();
        PageResult<List<UserPageVO>> listPageResult = userInfoService.queryPage(query);
        resultDTO.setResult(listPageResult);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC, SystemCode.RET_MSG_SUCC);
        sendJsonSuccessPage(resultDTO, response);
    }
    /**
     * 用户信息修改
     */
    @RequestMapping("updateUserInfo.htm")
    public void updateUserInfo(HttpServletResponse response, UserInfoSO so) {
        ZjUserInfo zjUserInfo = userInfoMapper.selectByPrimaryKey(so.getUserId());
        if (ObjectUtils.isEmpty(zjUserInfo)) {
            throw new ExpressException(SystemCode.SERVICE_FAILD_CODE, "用户信息异常");
        }
        ZjUserInfo userInfo = new ZjUserInfo();
        //如果密码修改，则和原密码对比  不一致新密码重新md5存入数据库
        if (!so.getPassword().equals(zjUserInfo.getPassword())) {
            String s = MD5Utils.md5(so.getPassword());
            userInfo.setPassword(s);
        }
        userInfo.setTypeId(Integer.valueOf(so.getTypeId()));
        userInfo.setIsDelete(Integer.valueOf(so.getIsDelete()));
        userInfo.setUserId(so.getUserId());
        userInfo.setUserName(so.getUserName());
        userInfo.setUpdateTime(DateUtils.getCurrentTime());
        userInfoMapper.updateByPrimaryKeySelective(userInfo);
        sendJsonSuccess(response);
    }
}
package cn.exam.controller;
import cn.exam.config.BaseController;
import cn.exam.domain.zj.ZjMenuInfo;
import cn.exam.query.ZjMenuQuery;
import cn.exam.service.ZjMenuInfoService;
import cn.exam.so.RoleMenuIdSO;
import cn.exam.util.*;
import cn.exam.vo.RoleMenuVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
 * @author YS
 * @version 1.0
 * @date 2021-02-22 9:12
 */
@Controller
@RequestMapping("menu")
public class MenuInfoController extends BaseController {
    @Autowired
    private ZjMenuInfoService  menuInfoService;
    /**
     * 分页
     * @param response 响应体
     * @param query 菜单名通用查询对象
     */
    @RequestMapping("queryPage.htm")
    public void  queryPage(HttpServletResponse response, ZjMenuQuery query){
        ResultDTO<PageResult<List<ZjMenuInfo>>> resultDTO = new ResultDTO<>();
        PageResult<List<ZjMenuInfo>> listPageResult = menuInfoService.queryMenuInfoPage(query);
        resultDTO.setResult(listPageResult);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC,SystemCode.RET_MSG_SUCC);
        sendJsonSuccessPage(resultDTO,response);
    }
    /**
     *
     * @param roleId 角色id
     * @param response 响应体
     */
    @RequestMapping("queryMenuIdListByRoleId.htm")
    public void queryMenuIdListByRoleId(String roleId, HttpServletResponse response){
        ResultDTO<List<Integer>> resultDTO = new ResultDTO<>();
        List<Integer> integers = menuInfoService.queryMenuIdListByRoleId(roleId);
        resultDTO.setResult(integers);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC,SystemCode.RET_MSG_SUCC);
        sendJsonSuccess(resultDTO,response);
    }
    /**
     *
     * @param roleId 角色id
     * @param response 响应体
     */
    @RequestMapping("queryMenuListByRoleId.htm")
    public void queryMenuListByRoleId(String roleId, HttpServletResponse response){
        ResultDTO<List<RoleMenuVO>> resultDTO = new ResultDTO<>();
        List<RoleMenuVO> menuVOS = menuInfoService.queryMenuTreeByRoleId(roleId);
        System.out.println(menuVOS);
        resultDTO.setResult(menuVOS);
        resultDTO.buildReturnCode(SystemCode.RET_CODE_SUCC,SystemCode.RET_MSG_SUCC);
        sendJson(resultDTO,response);
    }
    @RequestMapping("updateRoleMenuInfo.htm")
    public void updateRoleMenuInfo(HttpServletResponse response, RoleMenuIdSO so){
        menuInfoService.updateRoleMenuInfo(so);
        sendJsonSuccess(response);
    }
    @RequestMapping("insertMenuInfo.htm")
    public void insertMenuInfo(ZjMenuInfo info ,HttpServletResponse response){
        String currentDateTime = DateUtil.getCurrentDateTime();
        info.setMenuStatus(1);
        info.setCreateTime(currentDateTime);
        info.setUpdateTime(currentDateTime);
        menuInfoService.insertMenuInfo(info);
        sendJsonSuccess(response);
    }
}

五，项目总结

多年来，国内外网络信息发展迅猛，因而传统的考试势必被信息化的产品所替代。网络信息时代将传统教育代逐推向信息教育，网络考试已经渐渐地替代了传统纸质考试是现代化技术教育的方向之一，且它的考试具有着不受地点限制，节约资源，快速方便等特点，深受各大院校师生的喜爱。


一般地，学校与社会中，不论多大规模的考试大都采用传统的纸质考试模式。在这一情况下,组织一次考试至少要经过教师手动出卷子、学生按教室地点指定时间参加考试、教师参加评阅试卷、学生成绩进行登记、考试试卷进行分析等步骤。这样一来,当考试种类渐渐地增加，考试的需求逐步增强，学校各学院老师们的工作量也变得很多，老师的压力也是巨大的。因此，传统的考试模式已经不能再满足各校学院教师学生的需求了。


况且学生面临很多学习压力，面对繁重的课业负担，教师则面临着繁琐的工作。如何让学生采取方便有效的复习方法和进行自我学习的检测，让教师从繁琐的工作中减轻压力成为本次研究对象。因此本系统能够符合教师学生们的需求，帮助学生解决知识复习，自我测评等问题，让学生在考试之前可以进行知识点的练习复习巩固，以更有效的方式参加考试取得优异的成绩。同时帮助老师更方便的出试卷，管理题库试题，以及不用手动批改试卷，大大增强老师工作效率，使得老师办公更得力！

文章标签：
云数据库 Tair（兼容 Redis）
云数据库 RDS MySQL 版
Java
前端开发
Android开发
开发工具
应用服务中间件
BI
关系型数据库
数据安全/隐私保护
MySQL
数据库
关键词：
Spring boot vue
Spring Boot系统
Spring Boot vue系统
Spring Boot vue前后端分离系统
Spring Boot前后端分离系统
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
编程千纸鹤
目录
相关文章
疯狂的猿
|
19天前
|
存储 JavaScript 前端开发
基于 SpringBoot 和 Vue 开发校园点餐订餐外卖跑腿Java源码
一个非常实用的校园外卖系统，基于 SpringBoot 和 Vue 的开发。这一系统源于黑马的外卖案例项目 经过站长的进一步改进和优化，提供了更丰富的功能和更高的可用性。 这个项目的架构设计非常有趣。虽然它采用了SpringBoot和Vue的组合，但并不是一个完全分离的项目。 前端视图通过JS的方式引入了Vue和Element UI，既能利用Vue的快速开发优势，
疯狂的猿
101 13
高端源码库
|
27天前
|
JavaScript 安全 Java
java版药品不良反应智能监测系统源码，采用SpringBoot、Vue、MySQL技术开发
基于B/S架构，采用Java、SpringBoot、Vue、MySQL等技术自主研发的ADR智能监测系统，适用于三甲医院，支持二次开发。该系统能自动监测全院患者药物不良反应，通过移动端和PC端实时反馈，提升用药安全。系统涵盖规则管理、监测报告、系统管理三大模块，确保精准、高效地处理ADR事件。
高端源码库
44 1
刘大猫.
|
2月前
|
JavaScript NoSQL Java
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
刘大猫.
52 0
net936
|
4月前
|
前端开发 JavaScript Java
基于Java+Springboot+Vue开发的服装商城管理系统
基于Java+Springboot+Vue开发的服装商城管理系统（前后端分离），这是一项为大学生课程设计作业而开发的项目。该系统旨在帮助大学生学习并掌握Java编程技能，同时锻炼他们的项目设计与开发能力。通过学习基于Java的服装商城管理系统项目，大学生可以在实践中学习和提升自己的能力，为以后的职业发展打下坚实基础。
net936
200 2
基于Java+Springboot+Vue开发的服装商城管理系统
众所周知
|
3月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，包括版本兼容性、安全性、性能调优等方面。
众所周知
198 1
六卿
|
4月前
|
前端开发 JavaScript Java
SpringBoot项目部署打包好的React、Vue项目刷新报错404
本文讨论了在SpringBoot项目中部署React或Vue打包好的前端项目时，刷新页面导致404错误的问题，并提供了两种解决方案：一是在SpringBoot启动类中配置错误页面重定向到index.html，二是将前端路由改为hash模式以避免刷新问题。
六卿
356 1
众所周知
|
2月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。首先，创建并配置 Spring Boot 项目，实现后端 API；然后，使用 Ant Design Pro Vue 创建前端项目，配置动态路由和菜单。通过具体案例，展示了如何快速搭建高效、易维护的项目框架。
众所周知
128 62
东方睿赢
|
2月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，帮助开发者提高开发效率和应用的可维护性。
东方睿赢
120 2
程序员皮皮林
|
2月前
|
JavaScript Java 项目管理
Java毕设学习 基于SpringBoot + Vue 的医院管理系统 持续给大家寻找Java毕设学习项目（附源码）
基于SpringBoot + Vue的医院管理系统，涵盖医院、患者、挂号、药物、检查、病床、排班管理和数据分析等功能。开发工具为IDEA和HBuilder X，环境需配置jdk8、Node.js14、MySQL8。文末提供源码下载链接。
程序员皮皮林
206 0
net936
|
4月前
|
前端开发 JavaScript Java
基于Java+Springboot+Vue开发的大学竞赛报名管理系统
基于Java+Springboot+Vue开发的大学竞赛报名管理系统（前后端分离），这是一项为大学生课程设计作业而开发的项目。该系统旨在帮助大学生学习并掌握Java编程技能，同时锻炼他们的项目设计与开发能力。通过学习基于Java的大学竞赛报名管理系统项目，大学生可以在实践中学习和提升自己的能力，为以后的职业发展打下坚实基础。
net936
242 3
基于Java+Springboot+Vue开发的大学竞赛报名管理系统

热门文章

最新文章

  • 1
    Spring Cloud Alibaba：一站式微服务解决方案
  • 2
    从单体到微服务：如何借助 Spring Cloud 实现架构转型
  • 3
    深入 Spring Cloud Gateway 过滤器
  • 4
    Spring MVC中的请求映射：@RequestMapping注解深度解析
  • 5
    【SpringFramework】Spring初体验
  • 6
    利用Spring Cloud Gateway Predicate优化微服务路由策略
  • 7
    京东面试：聊聊Spring事务？Spring事务的10种失效场景？加入型传播和嵌套型传播有什么区别？
  • 8
    详解Spring Profiles：在Spring Boot中实现环境配置管理
  • 9
    Spring MVC中的控制器：@Controller注解全解析
  • 10
    使用lock4j-redis-template-spring-boot-starter实现redis分布式锁
  • 1
    springboot 启动原理、启动过程、启动机制的介绍
    529
  • 2
    springboot实现文件防盗链设计
    130
  • 3
    Spring Boot中一般如何使用线程池？
    782
  • 4
    Spring Boot 源码面试知识点
    104
  • 5
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    261
  • 6
    深入探索Spring Boot Web应用源码及实战应用
    113
  • 7
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    366
  • 8
    springboot数据库回滚失败原因
    66
  • 9
    springboot全局自定义异常
    45
  • 10
    springBoot+rabbit消息获取和消息确认
    134

    • 相关课程

    更多
  • 微服务+全栈在线教育实战项目演练（SpringCloud Alibaba+SpringBoot）
  • SpringBoot实战教程
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Springboot项目云开发快速迁移
  • 前端开发框架Bootstrap使用教程

    • 相关电子书

    更多
  • 利用编译将 Vue 组件转成 React 组件
  • 电商网站需求分析和架构设计Spring Boot2.6入门
  • React在大型后台管理项目中的工程实践

    • 相关实验场景

    更多
  • 前端开发基础1：前端开发环境的安装和配置
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月