基于javaweb+mysql的ssm+maven课程在线学习与测试系统(java+ssm+redis+bootstrap+html+mysql) 运行环境 Java≥8、MySQL≥5.7、To

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量72 收藏
点赞数
文章标签： java html mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71481126/article/details/131883835
版权

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

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

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

适用

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

功能说明

基于javaweb+mysql的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 ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 获取专业信息&&查询专业
     */
    @RequestMapping("queryMajor.do")
    @ResponseBody
    public ServerResponse queryMajor(HttpServletRequest request, Major major,
                                     @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.queryMajor(major, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 查看单条专业信息
     */
    @RequestMapping("getMajorInfo.do")
    @ResponseBody
    public ServerResponse getMajorInfo(HttpServletRequest request, 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) {

    @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) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        return teacherService.resetTeacherPassword(passwordNew, passwordOld, teacher);
    }

    /**
     * @description 设置或更新找回密码问题和答案
     */
    @RequestMapping(value = "updateTeacherInformation.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse updateTeacherInformation(HttpServletRequest request, String question, String answer) {
        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(), "请先登录");
        }
        return teacherService.updateTeacherInformation(question, answer, teacher);

        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 查看教师关联班级

     * @description 查询我的试卷
     */
    @RequestMapping("queryMyPaper.do")
    @ResponseBody
    public ServerResponse queryMyPaper(HttpServletRequest request, Paper paper,
                                       @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 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())) {
            paper.setCreatedBy(teacher.getPkTeacher());
            return paperService.queryPaper(paper, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 新增试卷
     */
    @RequestMapping("addPaper.do")
    @ResponseBody
    public ServerResponse addPaper(HttpServletRequest request, String paperName, String publicFlag) {
        //判断登录
        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) {

     */
    @RequestMapping("queryMajor.do")
    @ResponseBody
    public ServerResponse queryMajor(HttpServletRequest request, Major major,
                                     @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.queryMajor(major, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 查看单条专业信息
     */
    @RequestMapping("getMajorInfo.do")
    @ResponseBody
    public ServerResponse getMajorInfo(HttpServletRequest request, 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.getMajorInfo(pkMajor);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }


        //验证用户登录信息是否正确
        ServerResponse sr = teacherService.login(username, password);
        //验证通过，将当前用户信息放入session
        if (sr.isSuccess()) {
            CookieUtil.writeCookie(response, session.getId());
            RedisPoolUtil.setEx(session.getId(), JacksonUtil.objToString(sr.getData()), 60 * 30);
        }
        return sr;
    }

    /**
     * @description 获取用户信息
     */
    @RequestMapping(value = "getUserName.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse getUserName(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.createBySuccess(teacher);
        }
        return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
    }

    /**
     * @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);
    }


 **/
@Controller
@RequestMapping("/teacher/")
public class TeacherController {

    @Autowired
    private TeacherService teacherService;

    /**
     * @description 用户登录
     */
    @RequestMapping(value = "login.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse login(String username, String password, HttpSession session, HttpServletResponse response) {
        //验证用户登录信息是否正确
        ServerResponse sr = teacherService.login(username, password);
        //验证通过，将当前用户信息放入session
        if (sr.isSuccess()) {
            CookieUtil.writeCookie(response, session.getId());
            RedisPoolUtil.setEx(session.getId(), JacksonUtil.objToString(sr.getData()), 60 * 30);
        }
        return sr;
    }

    /**
     * @description 获取用户信息
     */
    @RequestMapping(value = "getUserName.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse getUserName(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.createBySuccess(teacher);
        }
        return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
    }

    /**

        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.emptyTestsFromPaper(fkPaper, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 发布试卷
     */
    @RequestMapping("assignmentPaper.do")
    @ResponseBody
    public ServerResponse assignmentPaper(HttpServletRequest request, Integer fkPaper, Integer fkMajor) {
        //判断登录
        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.assignmentPaper(fkPaper, fkMajor, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @param paperName    试卷名称
     * @param subject      题目所属学科

        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.resetStudentPwd(pkStudent);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }
}
package com.bs.controller;

/**
 * @name PaperController
 * @description
 **/
@Controller

            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) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.addOrModifyTeacher(teacher, manager);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @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 manageService.getMajorInfo(pkMajor);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 新增或修改年级专业信息
     */
    @RequestMapping("addOrUpdateMajor.do")
    @ResponseBody
    public ServerResponse addOrUpdateMajor(HttpServletRequest request, Major major) {
        //判断登录
        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.addOrModifyMajor(major, manager);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 删除年级专业信息
     */
    @RequestMapping("delMajor.do")
    @ResponseBody
    public ServerResponse delMajor(HttpServletRequest request, 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(), "请先登录");

            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.delMajor(pkMajor);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 重置教师密码
     */
    @RequestMapping("resetTeacherPwd.do")
    @ResponseBody
    public ServerResponse resetTeacherPwd(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.resetTeacherPwd(pkTeacher);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 重置学生密码
     */
    @RequestMapping("resetStudentPwd.do")
    @ResponseBody
    public ServerResponse resetStudentPwd(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);

            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(), "请先登录");
        }
        //判断权限，业务处理
        if (Constant.Role.ROLE_ADMIN.equals(manager.getRole())) {
            return manageService.delTeacher(pkTeacher);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @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) {
        //判断登录

        } catch (Exception e) {
            log.error("上传文件出错", e);
            return ServerResponse.createByErrorMessage("上传文件出错");
        }
    }
}
package com.bs.util;

/**
 * @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信息
        cookie.setHttpOnly(true);
        //cookie有效期
        cookie.setMaxAge(60 * 60 * 24 * 365);
        response.addCookie(cookie);
    }

    /**
     * @description 读取Cookie
     */
    public static String readCookie(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        if (cookies != null && cookies.length > 0) {
            for (Cookie ck : cookies){
                if (StringUtils.equals(ck.getName(),COOKIE_NAME)){

        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.resetStudentPwd(pkStudent);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }
}
package com.bs.controller;

/**
 * @name PaperController
 * @description
 **/
@Controller
@RequestMapping("/paper/")
public class PaperController {

    @Autowired
    private PaperService paperService;

     */
    @RequestMapping("getTestsInfo.do")
    @ResponseBody
    public ServerResponse getTestsInfo(HttpServletRequest request, Integer pkTest) {
        //判断登录
        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.getTestsInfo(pkTest);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 新增试题
     */
    @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("不是教师，无法操作");
    }

    /**

        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())) {
            paper.setFlagPublic("Y");
            return paperService.queryPaper(paper, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 查询我的试卷
     */
    @RequestMapping("queryMyPaper.do")
    @ResponseBody
    public ServerResponse queryMyPaper(HttpServletRequest request, Paper paper,
                                       @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 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())) {
            paper.setCreatedBy(teacher.getPkTeacher());
            return paperService.queryPaper(paper, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 新增试卷

        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 {

    }
}
package com.bs.controller.interceptor;

/**
 * @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");
        response.setContentType("application/json;charset=utf-8");
        PrintWriter printWriter;

    public ServerResponse<String> forgetRestPassword(String username, String passwordNew, String forgetToken) {
        return studentService.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 studentStr = RedisPoolUtil.get(token);
        Student student = JacksonUtil.stringToObj(studentStr, Student.class);
        if (student == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        return studentService.resetStudentPassword(passwordNew, passwordOld, student);
    }

    /**
     * @description 设置或更新找回密码问题和答案
     */
    @RequestMapping(value = "updateStudentInformation.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse updateStudentInformation(HttpServletRequest request, String question, String answer) {
        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.updateStudentInformation(question, answer, student);
    }

    /**
     * @description 查询待完成的试卷
     */
    @RequestMapping(value = "getUnfinishedPaper.do", method = RequestMethod.POST)

        }
        String teacherStr = RedisPoolUtil.get(token);
        Teacher teacher = JacksonUtil.stringToObj(teacherStr, Teacher.class);
        if (teacher == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        return teacherService.resetTeacherPassword(passwordNew, passwordOld, teacher);
    }

    /**
     * @description 设置或更新找回密码问题和答案
     */
    @RequestMapping(value = "updateTeacherInformation.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse updateTeacherInformation(HttpServletRequest request, String question, String answer) {
        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(), "请先登录");
        }
        return teacherService.updateTeacherInformation(question, answer, teacher);
    }

    /**
     * @description 获取教师管理的专业信息
     */
    @RequestMapping(value = "getTeacherMajor.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse getTeacherMajor(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(), "请先登录");
        }
        return teacherService.getTeacherMajor(teacher);
    }
}

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信息
        cookie.setHttpOnly(true);
        //cookie有效期
        cookie.setMaxAge(60 * 60 * 24 * 365);
        response.addCookie(cookie);
    }

    /**
     * @description 读取Cookie
     */
    public static String readCookie(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        if (cookies != null && cookies.length > 0) {
            for (Cookie ck : cookies){
                if (StringUtils.equals(ck.getName(),COOKIE_NAME)){
                    return ck.getValue();
                }
            }
        }
        return null;
    }

    /**
     * @description 删除Cookie
     */
    public static void deleteCookie(HttpServletRequest request,HttpServletResponse response){
        Cookie[] cookies = request.getCookies();
        if (cookies != null && cookies.length > 0) {
            for (Cookie ck : cookies){

        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 获取年级

        if (student == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");
        }
        return studentService.updateStudentInformation(question, answer, student);
    }

    /**
     * @description 查询待完成的试卷
     */
    @RequestMapping(value = "getUnfinishedPaper.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse getUnfinishedPaper(HttpServletRequest request) {
        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.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 学生交卷，计算分数
     */

        }
        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.getTeacherMajor(pkTeacher, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 获取专业信息&&查询专业
     */
    @RequestMapping("queryMajor.do")
    @ResponseBody
    public ServerResponse queryMajor(HttpServletRequest request, Major major,
                                     @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.queryMajor(major, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是管理员，无法操作");
    }

    /**
     * @description 查看单条专业信息
     */
    @RequestMapping("getMajorInfo.do")
    @ResponseBody
    public ServerResponse getMajorInfo(HttpServletRequest request, Integer pkMajor) {
        //判断登录
        String token = CookieUtil.readCookie(request);
        if (StringUtils.isEmpty(token)) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "请先登录");

    /**
     * @description 获取单试题信息
     */
    @RequestMapping("getTestsInfo.do")
    @ResponseBody
    public ServerResponse getTestsInfo(HttpServletRequest request, Integer pkTest) {
        //判断登录
        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.getTestsInfo(pkTest);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 新增试题
     */
    @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("不是教师，无法操作");
    }

    /**

     */
    @RequestMapping("queryMyPaper.do")
    @ResponseBody
    public ServerResponse queryMyPaper(HttpServletRequest request, Paper paper,
                                       @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 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())) {
            paper.setCreatedBy(teacher.getPkTeacher());
            return paperService.queryPaper(paper, pageNum, pageSize);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

    /**
     * @description 新增试卷
     */
    @RequestMapping("addPaper.do")
    @ResponseBody
    public ServerResponse addPaper(HttpServletRequest request, String paperName, String publicFlag) {
        //判断登录
        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.addPaper(paperName, publicFlag, teacher);
        }
        return ServerResponse.createByErrorMessage("不是教师，无法操作");
    }

请添加图片描述

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

m0_71481126
关注
java编程Mysql数据库安装以及增删改查测试(2)，2024年最新2024最新软件测试高频精选面试题讲解
2401_83620959的博客
04-10 907
/设置参数1，将name改为王五。//设置参数2，将id为2的数据做修改。//设置参数2，创建id为5的数据。//设置参数1，name 为小明。//首先使用ISO-8859-1字符集将name解码为字节序列并将结果存储新的字节数组中。//1.getConnection()方法，连接MySQL数据库！//2.创建statement类对象，用来执行SQL语句！//3.ResultSet类，用来存放获取的结果集！//预处理添加数据，其中有两个参数–“？//查询修改数据后student表中的数据。
java编程Mysql数据库安装以及增删改查测试(1)，2024年最新开发这么久这些问题都不会
2401_83620959的博客
04-10 827
/设置参数2，name 为小明。//设置参数1，创建id为5的数据。//设置参数2，将id为2的数据做修改。//设置参数2，创建id为5的数据。System.out.println(“执行增加、修改、删除后的数据”);// //预处理添加数据，其中有两个参数–“？//查询修改数据后student表中的数据。
java 连接MySQL数据库的步骤与代码测试连通
last_memory的博客
02-10 1万+
一、MySQL的安装 二、登入MySQL并创建数据库和表 三、测试连通性
java 连接mysql 并测试是否成功
xyjikl
08-09 9609
java 连接MySQL 并测试是否成功。   [html] view plain copy package com.test.tool;    import java.sql.Connection;  import java.sql.DriverManager;  import java.sql.PreparedStatement;  import java.sq
基于javaweb的课程在线学习与测试系统(java+ssm+redis+bootstrap+tomcat+mysql)
m0_68552069的博客
10-24 385
基于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 1198
基于javaweb的餐厅点餐收银管理系统(java+ssm+jsp+bootstrap+mysql) 运行环境 Java≥8、MySQL≥5.7、Tomcat≥8 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
基于SSM(Spring+SpringMVC+Mybatis)+Shiro+Redis+Bootstrap的超市管理系统(电商网站)
刘信坚的博客
06-06 1万+
基于SSM(Spring+SpringMVC+Mybatis)+Shiro+Redis+Bootstrap的超市管理系统(可以说是电商网站) 转眼间就2018年6月6日了，很久之前就想写博客，但是每次都是没时间，就没有写，乘着今天想起来就正式开始写我的博客了，从大二以来课程特别多，每次都在想等我下个学期课少了就有时间写博客了，但是一次比一次课多，大家可以看下我大三下学期的课表，也就是现在我的课表...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统
12-15
两套UI实现(bootstrap+layer ui)，可以自由切换 报表后端采用技术： SpringBoot整合SSM(Spring+Mybatis-plus+ SpringMvc)，spring security 全注解式的权限管理和JWT方式禁用Session,采用redis存储token及权限信息 ...
java及javaweb编程教程、ssm、商城实战项目、how2j网站的全站教程、包含从前端到后端全栈技术
04-12
包括spring、spring mvc、mybatis、spring+mybatis、SSM、springboot、javaee 商城项目、ssm商城项目、springboot商城项目，工具和中间件，包括maven、git、Intellij IDEA、Redis、WebSocket、shiro、quartz、...
java连接mysql 测试代码
lizhengnanhua的专栏
01-10 1万+
package cvit.com.dao; import java.sql.*; public class GetConnection { public Connection getConnection() { Connection conn=null; try { try { Class.forName("com.mysql.jdbc.Driver"); }
Java使用JDBC连接mysql数据库及测试是否连接成功的方法
热门推荐
温暖不了你的心的博客
08-11 6万+
一、连接mysql数据库： 步骤一：在eclipse下面建一个项目，我的是JDBC_Test， 步骤二：选中项目名称，右键选择Build Path-&gt;Configure Build Path…. 步骤三：进入Java Build Path 选择Libraies,如下图所示 步骤四：选择Add External JARs.. 如下图 步骤五：找到已经下载好的MySQL驱...
java mysql 连接测试_java连接MySQL数据库的测试步骤
weixin_39559895的博客
01-19 621
以下的文章主要讲述的是java连接MySQL数据库的测试步骤， 其中包括对加载驱动程序的介绍，打开相关数据库连接MySQL数据库与如何执行sql命令等相关内容的描述，以下就是文章的主要内容。步骤1.加载驱动程序：1.先找到要使用的驱动程序类的名称：如com.MySQL.jdbc.Driver。可以使用命令行参数方式导入，可以使用修改classpath方式，***是使用导入jar包的方式。2.注册驱...
mysql java测试_JAVA 访问MySQL数据库(使用方法及测试)
weixin_31921223的博客
01-27 660
说明:本文使用的JDBC框架是基于Java SE 1.8 & MySQL & Eclipse工具下载:MySQL V5.5(x64) 64位MySQL V5.5(x86) 32位要根据你电脑的情况选择相应的MySQL版本。我的电脑是64位，所以本篇文章是使用64位讲解的，如果有同学在使用32位版本的时候出现问题的可以随时联系我。一.安装配置MySQL1.首先打开运行mysql-5....
Java 连接简单测试MySQL数据库
wabil的专栏
11-30 2798
import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement; public class TestMySQL { public static void main(String[] args) { t
JAVA连接MYSQL测试
学习的路上
05-15 390
刚刚安装了mysql，想测试一下，不多说，直接上java实例测试！ 测试准备：mysql-connector-java-5.1.6-bin.jar java测试类 package test; import java.sql.*; public class GetConnection { public Connection getConnection() { Conn...
JAVA MySQL性能测试
Dreaming_My_Dream的博客
02-27 851
测试目的 使用 JAVA 语言对数据库进行增删改查功能，验证是否能够达到预期的性能指标。 测试环境 平台：Win10 x64 操作系统 数据库：Navicat for MySQL，此数据库苹果，谷歌，微软，阿里等知名公司都有使用。 开发环境：IntelliJ IDEA，业界公认最好的 Java 开发环境。 测试指标 首先创建数据库并与开发环境进行关联，使之开发环境能够对数据库进行操作。 向数据库...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 70
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 475
Java StreamAPI的使用与常用方法
基于javaweb+mysql的图书馆图书管理系统(java+SSM+JSP+JS+HTML+mysql)
09-13
基于JavaWeb和MySQL的图书馆图书管理系统可以使用Java SSM框架（Spring、SpringMVC、MyBatis），结合JSP、JavaScript、HTML等前端技术来实现。以下是一个简单的系统架构和功能模块： 1. 用户管理模块： - 用户注册...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值