基于javaweb+mysql的ssm+maven课程在线学习与测试系统(java+ssm+redis+bootstrap+html+mysql)

最新推荐文章于 2024-10-06 20:29:51 发布
最新推荐文章于 2024-10-06 20:29:51 发布
阅读量321 收藏 7
点赞数 5
文章标签： java html mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81060432/article/details/136116592
版权

基于javaweb+mysql的ssm+maven课程在线学习与测试系统(java+ssm+redis+bootstrap+html+mysql)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb的SSM+Maven课程在线学习与测试系统(java+ssm+redis+bootstrap+html+mysql)

基于B/S架构的课程在线学习与测试系统

启动说明

项目为maven管理，最近集成了redis，所以在运行项目是先要下载redis并启动客户端，方可正常运行项目，由于只需要下载redis，无需其他配置，这里就不做过多说明。

最近更新

集成redis来保存用户登录信息，添加过滤器重置用户登录有效期。拦截器实现统一登录和权限校验（相关重构还未完成）。

修改配置文件：com.bs.commonn.RedisPool 地址、端口号

pool = new JedisPool(config,“127.0.0.1”,6379,1000*2);

修改数据库配置文件，导入项目bs.sql文件

学生账号测试：lwj 123456

教师测试账号：lwj 123456

管理员测试账号：admin admin

  • 框架：SSM（Spring，SpringMVC，Mybatis）

  • 缓存：redis

  • 数据库：MySQL

  • IDE：Intellij IDEA/Eclipse

  • 其他：Maven，Git

项目亮点

  1. 前后端分离。

  2. 用户登录权限区分和控制。

  3. 防止横向越权和纵向越权。

  4. 设计高复用的服务器响应对象。

  5. guava缓存。

  6. pojo，vo抽象模型。

  7. 数据绑定对象。

  8. Mybatis分页

  9. Bootstrap。

  10. artTemplate，artDialog，iframe前端模板使用。

  11. select2、toastr、sweetalert等等前端插件的使用。

  12. redis缓存。

  13. 全局异常处理，拦截器权限统一检验。

        return sr;
    }

    /**
     * @description 获取教师信息&&查询教师
     */
    @RequestMapping("queryTeacher.do")
    @ResponseBody
    public ServerResponse queryTeacher(HttpServletRequest request, Teacher teacher,
                                       @RequestParam(value = "pageNum", defaultValue = "1") int pageNum,
                                       @RequestParam(value = "pageSize", defaultValue = "10") int pageSize) {
          //判断登录
//        String token = CookieUtil.readCookie(request);
//        if (StringUtils.isEmpty(token)) {
//            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
//        }
//        String manageStr = RedisPoolUtil.get(token);
//        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
//        if (manager == null) {
//            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
//        }
//        //判断权限，业务处理
//        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.queryTeacher(teacher, pageNum, pageSize);
//        }
//        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 新增或修改教师信息
     */
    @RequestMapping("addOrUpdateTeacher.do")
    @ResponseBody
    public ServerResponse addOrUpdateTeacher(HttpServletRequest request, Teacher teacher) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {

     */
    @RequestMapping("selectSubjectList.do")
    @ResponseBody
    public ServerResponse selectSubjectList(HttpServletRequest request) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_TEACHER.equals(teacher.getRole())) {
            return testsService.selectSubjectList();
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }
}

/**
 * @name TeacherController
 * @description 教师Controller
 **/
@Controller
@RequestMapping("/teacher/")
public class TeacherController {


            multipartFile.transferTo(file);
            Class<?> clazz = Class.forName(className);
            BaseModal bm = (BaseModal) clazz.newInstance();
            bm.setFile(file);
            return bm.parse();
        } catch (Exception e) {
            log.error("上传文件出错", e);
            return ServerResponse.createByErrorMessage("上传文件出错");
        }
    }
}

/**
 * @name CookieUtil
 * @description
 **/
public class CookieUtil {

    //cookie保存在localhost下
    private final static String COOKIE_DOMAIN = "localhost";
    //cookie名称
    private final static String COOKIE_NAME = "qx";

    /**
     * @description 存入Cookie
     */
    public static void writeCookie(HttpServletResponse response, String value) {
        Cookie cookie = new Cookie(COOKIE_NAME, value);
        cookie.setDomain(COOKIE_DOMAIN);
        cookie.setPath("/");
        //防止脚本获取cookie信息

            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_TEACHER.equals(teacher.getRole())) {
            return paperService.compositionPaper(paperDetail, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 删除试卷试题
     */
    @RequestMapping("deleteTestsFromPaper.do")
    @ResponseBody
    public ServerResponse deleteTestsFromPaper(HttpServletRequest request, Integer fkTest, Integer fkPaper) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_TEACHER.equals(teacher.getRole())) {
            return paperService.deleteTestsFromPaper(fkTest, fkPaper, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 清空试卷试题
     */
    @RequestMapping("emptyTestsFromPaper.do")
    @ResponseBody
    public ServerResponse emptyTestsFromPaper(HttpServletRequest request, Integer fkPaper) {
        //判断登录


/**
 * @name TeacherInterceptor
 * @description
 **/
public class TeacherInterceptor implements HandlerInterceptor {

    private static final Logger log = LoggerFactory.getLogger(TeacherInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        String methodName = handlerMethod.getMethod().getName();
        String className = handlerMethod.getBean().getClass().getName();
        log.info("拦截类名：{}，方法名：{}", className, methodName);
        Teacher teacher = null;
        //从redis获取用户信息
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isNotEmpty(token)) {
            String studentStr = RedisPoolUtil.get(token);
            teacher = JacksonUtil.stringToObj(studentStr, Teacher.class);
        }
        //判断用户信息是否为空或者身份权限不对
        return teacher != null && (StringUtils.equals(teacher.getRole(), "1")) || BaseInterceptor.check(response, teacher);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

     */
    @RequestMapping("getStudentInfo.do")
    @ResponseBody
    public ServerResponse getStudentInfo(HttpServletRequest request, Integer pkStudent) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.getStudentInfo(pkStudent);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 删除学生
     */
    @RequestMapping("delStudent.do")
    @ResponseBody
    public ServerResponse delStudent(HttpServletRequest request, Integer pkStudent) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.delStudent(pkStudent);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 查看教师关联班级


/**
 * @name ManageInterceptor
 * @description
 **/
public class ManageInterceptor implements HandlerInterceptor {

    private static final Logger log = LoggerFactory.getLogger(ManageInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        String methodName = handlerMethod.getMethod().getName();
        String className = handlerMethod.getBean().getClass().getName();
        log.info("拦截类名：{}，方法名：{}", className, methodName);
        Manager manager = null;
        //从redis获取用户信息
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isNotEmpty(token)) {
            String studentStr = RedisPoolUtil.get(token);
            manager = JacksonUtil.stringToObj(studentStr, Manager.class);
        }
        //判断用户信息是否为空或者身份权限不对
        return manager != null && (StringUtils.equals(manager.getRole(), "0")) || BaseInterceptor.check(response, manager);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}


     */
    @RequestMapping("modifyTestFlag.do")
    @ResponseBody
    public ServerResponse modifyTestFlag(HttpServletRequest request, Integer pkTest, String flag) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_TEACHER.equals(teacher.getRole())) {
            return testsService.modifyTestFlag(pkTest, flag, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 查询科目列表
     */
    @RequestMapping("selectSubjectList.do")
    @ResponseBody
    public ServerResponse selectSubjectList(HttpServletRequest request) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_TEACHER.equals(teacher.getRole())) {
            return testsService.selectSubjectList();
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }
}


    @RequestMapping("addTest.do")
    @ResponseBody
    public ServerResponse addTest(HttpServletRequest request, Tests tests) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_TEACHER.equals(teacher.getRole())) {
            return testsService.addTest(tests, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 修改试题状态
     */
    @RequestMapping("modifyTestFlag.do")
    @ResponseBody
    public ServerResponse modifyTestFlag(HttpServletRequest request, Integer pkTest, String flag) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_TEACHER.equals(teacher.getRole())) {
            return testsService.modifyTestFlag(pkTest, flag, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 查询科目列表
     */
    @RequestMapping("selectSubjectList.do")
    @ResponseBody
    public ServerResponse selectSubjectList(HttpServletRequest request) {
        //判断登录

        Manager manager = null;
        //从redis获取用户信息
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isNotEmpty(token)) {
            String studentStr = RedisPoolUtil.get(token);
            manager = JacksonUtil.stringToObj(studentStr, Manager.class);
        }
        //判断用户信息是否为空或者身份权限不对
        return manager != null && (StringUtils.equals(manager.getRole(), "0")) || BaseInterceptor.check(response, manager);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

/**
 * @name BaseInterceptor
 * @description
 **/
class BaseInterceptor {

    private static final Logger log = LoggerFactory.getLogger(BaseInterceptor.class);

    static boolean check(HttpServletResponse response, Object object) {
        //重置response
        response.reset();
        response.setCharacterEncoding("utf-8");

    }

    /**
     * @description 未登录：忘记密码，获取问题
     */
    @RequestMapping(value = "forgetGetQuestion.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<String> forgetGetQuestion(String username) {
        return teacherService.selectQuestion(username);
    }

    /**
     * @description 未登录：忘记密码，检查答案是否正确
     */
    @RequestMapping(value = "forgetCheckAnswer.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<String> forgetCheckAnswer(String username, String question, String answer) {
        return teacherService.checkAnswer(username, question, answer);
    }

    /**
     * @description 未登录：忘记密码，重置密码
     */
    @RequestMapping(value = "forgetResetPassword.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<String> forgetRestPassword(String username, String passwordNew, String forgetToken) {
        return teacherService.forgetResetPassword(username, passwordNew, forgetToken);
    }

    /**
     * @description 已登录，重置密码
     */
    @RequestMapping(value = "resetPassword.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<String> resetPassword(HttpServletRequest request, String passwordOld, String passwordNew) {
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {

     * @description 获取单条教师信息
     */
    @RequestMapping("getTeacherInfo.do")
    @ResponseBody
    public ServerResponse getTeacherInfo(HttpServletRequest request, Integer pkTeacher) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.getTeacherInfo(pkTeacher);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 删除教师
     */
    @RequestMapping("delTeacher.do")
    @ResponseBody
    public ServerResponse delTeacher(HttpServletRequest request, Integer pkTeacher) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }

                                           @RequestParam(value = "pageNum", defaultValue = "1") int pageNum,
                                           @RequestParam(value = "pageSize", defaultValue = "100") int pageSize) {
        //判断用户是否登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String userStr = RedisPoolUtil.get(token);
        if (StringUtils.isBlank(userStr)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        notice.setFlag("Y");
        return noticeService.queryNotice(notice, pageNum, pageSize);
    }

    /**
     * @description 查询通知
     */
    @RequestMapping("queryNotice.do")
    @ResponseBody
    public ServerResponse queryNotice(HttpServletRequest request, Notice notice,
                                      @RequestParam(value = "pageNum", defaultValue = "1") int pageNum,
                                      @RequestParam(value = "pageSize", defaultValue = "10") int pageSize) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return noticeService.queryNotice(notice, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 新增或更新通知
     */

            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String studentStr = RedisPoolUtil.get(token);
        Student student = JacksonUtil.stringToObj(studentStr, Student.class);
        if (student == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        return studentService.getUnfinishedPaper(student);
    }

    /**
     * @description 获取试卷内容
     */
    @RequestMapping("getPaperDetail.do")
    @ResponseBody
    public ServerResponse getPaperDetail(HttpServletRequest request, Integer pkPaper) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String studentStr = RedisPoolUtil.get(token);
        Student student = JacksonUtil.stringToObj(studentStr, Student.class);
        if (student == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        return studentService.getPaperDetail(pkPaper, student);
    }

    /**
     * @description 学生交卷，计算分数
     */
    @RequestMapping("submitPaper.do")
    @ResponseBody
    public ServerResponse submitPaper(HttpServletRequest request, Integer pkPaper, String testsAndAnswer) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String studentStr = RedisPoolUtil.get(token);
        Student student = JacksonUtil.stringToObj(studentStr, Student.class);
        if (student == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        return studentService.submitPaper(pkPaper, student, testsAndAnswer);
    }

    /**

     * @description 新增教师关联班级
     */
    @RequestMapping("addRelTeacherMajor.do")
    @ResponseBody
    public ServerResponse addRelTeacherMajor(HttpServletRequest request, Integer pkTeacher, Integer pkMajor) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.addRelTeacherMajor(pkTeacher, pkMajor, manager);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 删除教师关联班级
     */
    @RequestMapping("delRelTeacherMajor.do")
    @ResponseBody
    public ServerResponse delRelTeacherMajor(HttpServletRequest request, Integer pkTeacher, Integer pkMajor) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            log.info(manager.getPkManager() + "执行了删除教师：" + pkTeacher + " 关联的：" + pkMajor + " 专业的操作");
            return manageService.delRelTeacherMajor(pkTeacher, pkMajor);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 获取年级

    /**
     * @description 查询学生
     */
    @RequestMapping("queryStudent.do")
    @ResponseBody
    public ServerResponse queryStudent(HttpServletRequest request, Student student,
                                       @RequestParam(value = "pageNum", defaultValue = "1") int pageNum,
                                       @RequestParam(value = "pageSize", defaultValue = "10") int pageSize) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.queryStudent(student, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 新增或修改学生信息
     */
    @RequestMapping("addOrUpdateStudent.do")
    @ResponseBody
    public ServerResponse addOrUpdateStudent(HttpServletRequest request, Student student) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {

     */
    @RequestMapping("getNotice.do")
    @ResponseBody
    public ServerResponse getNotice(HttpServletRequest request, Integer pkNotice) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        String manageStr = RedisPoolUtil.get(token);
        Manager manager = JacksonUtil.stringToObj(manageStr, Manager.class);
        if (manager == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return noticeService.getNotice(pkNotice);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }
}

/**

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

Java源码jdk
关注
基于javaweb的课程在线学习与测试系统(java+ssm+redis+bootstrap+tomcat+mysql)
m0_68552069的博客
10-24 388
基于javaweb的课程在线学习与测试系统(java+ssm+redis+bootstrap+tomcat+mysql) 运行环境 Java≥8、MySQL≥5.7、Tomcat≥8 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等
基于javaweb的餐厅点餐收银管理系统(java+ssm+jsp+bootstrap+mysql)
m0_69590785的博客
10-28 1206
基于javaweb的餐厅点餐收银管理系统(java+ssm+jsp+bootstrap+mysql) 运行环境 Java≥8、MySQL≥5.7、Tomcat≥8 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
基于javaweb+mysql的课程在线学习与测试系统(java+SSM+redis+Bootstrap+Tomcat+mysql)
m0_71326634的博客
05-24 300
基于B/S架构的课程在线学习与测试系统 启动说明 项目为maven管理，最近集成了redis，所以在运行项目是先要下载redis并启动客户端，方可正常运行项目，由于只需要下载redis，无需其他配置，这里就不做过多说明。 最近更新 集成redis来保存用户登录信息，添加过滤器重置用户登录有效期。拦截器实现统一登录和权限校验（相关重构还未完成）。 修改配置文件：com.bs.commonn.RedisPool 地址、端口号 pool = new JedisPool(config,“127.0.0.1”,637
基于javaweb+mysql的ssm+maven课程在线学习与测试系统(java+ssm+redis+bootstrap+html+mysql) 运行环境 Java≥8、MySQL≥5.7、To
m0_71481126的博客
07-23 73
项目为maven管理，最近集成了redis，所以在运行项目是先要下载redis并启动客户端，方可正常运行项目，由于只需要下载redis，无需其他配置，这里就不做过多说明。基于javaweb+mysql的ssm+maven课程在线学习与测试系统(java+ssm+redis+bootstrap+html+mysql)基于javaweb+mysql的SSM+Maven课程在线学习与测试系统(java+ssm+redis+bootstrap+html+mysql)全局异常处理，拦截器权限统一检验。
基于javaweb+SpringBoot的课程在线学习与测试系统(java+SSM+redis+Bootstrap+Tomcat+mysql)
m0_71015850的博客
05-16 189
基于B/S架构的课程在线学习与测试系统 启动说明 项目为maven管理，最近集成了redis，所以在运行项目是先要下载redis并启动客户端，方可正常运行项目，由于只需要下载redis，无需其他配置，这里就不做过多说明。 最近更新 集成redis来保存用户登录信息，添加过滤器重置用户登录有效期。拦截器实现统一登录和权限校验（相关重构还未完成）。 修改配置文件：com.bs.commonn.RedisPool 地址、端口号 pool = new JedisPool(config,“127.0.0.1”,637
基于javaweb+mysql的ssm+maven智能餐厅管理系统(java+ssm+jsp+bootstrap+mysql)
m0_71016350的博客
07-25 268
3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可 4.硬件环境：windows 7/8/10 1G内存以上；主要功能包括： 客户可以根据自己的要求去选择菜品，厨师部会收到你点的菜单。基于javaweb+mysql的ssm+maven智能餐厅管理系统(java+ssm+jsp+bootstrap+mysql)基于javaweb+mysql的SSM+Maven智能餐厅管理系统(java+ssm+jsp+bootstrap+mysql)课程设计，大作业，毕业设计，项目练习，学习演示等。
基于javaweb+mysql的校园外卖点餐系统(java+SSM+JSP+maven+mysql)
m0_71463355的博客
05-28 1068
一、项目简述 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持） 项目技术： JSP +Spring + SpringMVC + MyBatis + css + JavaScript + JQuery + Ajax + layui+ maven等等。 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 String encodedPasswor
基于javaweb+mysql的校园人力人事资源管理系统(java+Springboot+ssm+mysql+jsp+maven)
m0_71463355的博客
05-28 584
校园人力资源管理系统：学校部门管理，教室管理，学历信息管理，职务，教师职称，奖励，学历，社会关系，工作经历，培训管理，公告等信息功能等等。 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 @GetMapping("/getPage") public ModelAndView getPage(@RequestParam("currentPage") Integer currentPage){ employeeService.getPageDatas(current
基于javaweb+mysql的校园二手市场系统(java+SSM+mysql+maven+tomcat)
m0_71463355的博客
05-28 339
一、项目简述（ +IW文档） 功能：本系统分用户前台和管理员后台。 本系统用例模型有三种，分别是游客、注册用户和系统管 理员。下面分别对这三个角色的功能进行描述： 1） 诞 游客是未注册的用户，他们可以浏览物物品，可以搜索物 品，如需购买物品，必须先注册成为网站用户。游客主要 功触吓： a.浏览物品 b.搜索物品 c.注册成为网站用户 2） 注册用户 注册用户是经过网站合法认证的用户，登录网站后可以浏 览物品、搜索物品、发布物品、关注物品、购买物品和查 看个人中心。 3） 系统管理员 系统管理员主要负责系统
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统
12-15
两套UI实现(bootstrap+layer ui)，可以自由切换 报表后端采用技术： SpringBoot整合SSM(Spring+Mybatis-plus+ SpringMvc)，spring security 全注解式的权限管理和JWT方式禁用Session,采用redis存储token及权限信息 ...
JavaWeb程序设计SSM框架选课系统开发大作业有数据库文
05-09
以上就是基于SSM框架开发JavaWeb选课系统涉及的主要知识点，涵盖了后端开发、数据库设计、前端交互以及系统运维等多个方面。在实际开发中，开发者需要深入理解并熟练掌握这些技术，才能构建出高效、稳定、易维护的...
基于SSM(Spring+SpringMVC+Mybatis)+Shiro+Redis+Bootstrap的超市管理系统(电商网站)
热门推荐
刘信坚的博客
06-06 1万+
基于SSM(Spring+SpringMVC+Mybatis)+Shiro+Redis+Bootstrap的超市管理系统(可以说是电商网站) 转眼间就2018年6月6日了，很久之前就想写博客，但是每次都是没时间，就没有写，乘着今天想起来就正式开始写我的博客了，从大二以来课程特别多，每次都在想等我下个学期课少了就有时间写博客了，但是一次比一次课多，大家可以看下我大三下学期的课表，也就是现在我的课表...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 882
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 285
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 489
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1000
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 627
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Springboot人才求职招聘系统源码（前台+后台）
最新发布
10-06 458
项目技术：springboot运行环境：jdk1.8+idea/eclipse+maven3+mysql5.6。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值