• SpringBoot + Servlet + Mybatis+ layui 学生选课管理系统

    课程设计目的

    本次课设做的系统为学生课程设计管理系统，鉴于学校规模的不断扩大，而且随着每年的扩招，人数不断的增加，每次课程设计都采用手工操作，费时费力。为了解决这个问题，决定做一个课程设计管理系统，对每个学期选修课程设计的学生基本情况作个统计。学生可以在系统中注册账号，登录后学生从该系统中选题，填写同组学生的姓名，组长等基本情况；查询自己的课程设计成绩，课程设计的选择情况，成绩的合格情况，小组成员信息，上课程设计报告的上传，下载，删除，预览等功能。老师通过该系统添加课设信息，查看学生的选题情况，给出学生的分数。这有利于老师教学，及时了解学生的情况，提高教学质量，减轻老师的工作量，改善原有的比较繁锁的工作。

    题目基本情况

    本系统涉及权限管理，以老师,学生分别登录以进行不同的操作，老师可以对查看学生信息，给出学生成绩查看学生选题情况，添加课设信息。学生可以添加同组成员信息选择课程设计，退掉课程设计，查看课程设计的成绩，上传实验报告.为了提高信息的处理效率，设计一款小型的课程设计管理系统。将数据库的内容通过web服务器配合前端框架在浏览器展现出来，达到直观，方便的管理目的。

    数据库表设计

    教师属性：教师号，姓名，职称，密码。

    学生属性：学号，姓名，班级，密码。

    题目属性：课题号，课题目名称，题目信息，教工号。

    选题属性：学号，题号，成绩，组号。

    小组属性：组号，组员，组长。

    文件属性：文件号，文件名，后缀，路径大小，类型，下载次数，上传时间，学号

    技术栈

    数据库连接池技术  maven工具    servlet技术

    Ajax请求  Spring-Boot框架   Mybatis框架    JSON数据格式                                                         

     commons-fileupload组件  layui框架  

    程序流程图

     

     

    5.3.1登录操作

    本程序设计的权限管理中，不同身份可以进行的操作不一样，因此不同的身份，决定执行什么样的操作，如图6-1所示为教师登录验证界面，前端使用leyui框架布局，

    验证码使用BufferedImage类绘制，用户输入信息后进行后台的逻辑判断，成功则进入到后台管理界面。若用户名和姓名和验证码输入正确，则跳转到对应的请求映射，若勾选记住密码，则会在信息全部正确匹配后将正确的信息存入cookie，若其中一项输入错误，则会重新定向到登录界面。

    图6-1教师登录界面

    图6-2学生登录界面

    登录部分代码:

    1. Dao层：
    2.  
    3.  @Select("SELECT * from student where stdname =#{stdname} and stdpassword =#{stdpassword}")
    4.  
    5. public Student findstudentByNameAndPassword(Student student);//通过用户的姓名和密码查询
    6.  
    7. Controller层：
    8.  
    9. @RequestMapping("/tologin")
    10.  
    11.     public String index() {
    12.  
    13.         return "login";}
    14.  
    15.  //登录1
    16.  
    17.     @RequestMapping(value = "/login")
    18.  
    19.     public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response, Student student) throws Exception {
    20.  
    21.         String name = request.getParameter("stdname");
    22.  
    23.         String pwd = request.getParameter("stdpassword");
    24.  
    25.         String yzm = request.getParameter("captcha");
    26.  
    27.         String shenfen = request.getParameter("shenfen");
    28.  
    29.         HttpSession session = request.getSession();
    30.  
    31.         String code = (String) session.getAttribute("code");
    32.  
    33.         String rember = request.getParameter("rememberMe");
    34.  
    35.         //3.处理跳转
    36.  
    37.         //创建ModelAndView对象
    38.  
    39.         ModelAndView mav = new ModelAndView();
    40.  
    41.         if (yzm.equals(code)) {
    42.  
    43.             Student student_find = studentService.login(student);
    44.  
    45.             System.out.println(student_find);
    46.  
    47.             if (student_find != null) {
    48.  
    49.                 //1.办卡
    50.  
    51.                 String cusername = java.net.URLEncoder.encode(name, "utf-8");
    52.  
    53.                 Cookie cookie1 = new Cookie("uname", cusername);
    54.  
    55.                 Cookie cookie2 = new Cookie("passwd", pwd);
    56.  
    57.                 //3.设置范围
    58.  
    59. /* cookie1.setPath("/mydemo3/");
    61. cookie2.setPath("/mydemo3/");
    63. */
    64.  
    65.                 if ("true".equals(rember)) {
    66.  
    67.                     //2.设置时效(一次浏览器的关闭)
    68.  
    69.                     cookie1.setMaxAge(60 * 60 * 24 * 10);
    70.  
    71.                     cookie2.setMaxAge(60 * 60 * 24 * 10);
    72.  
    73.                 } else {
    74.  
    75.                     cookie1.setMaxAge(0);
    76.  
    77.                     cookie2.setMaxAge(0);
    78.  
    79.                 }
    80.  
    81.                 //4.给客户
    82.  
    83.                 response.addCookie(cookie1);
    84.  
    85.                 response.addCookie(cookie2);
    86.  
    87.                 //向模型对象中添加数据
    88.  
    89.                 mav.addObject("student", student_find);
    90.  
    91.                 session.setAttribute("stulogin", student_find);
    92.  
    93.                 session.setAttribute("studentname", student.getStdname());
    94.  
    95.                 session.setAttribute("stdpwd", student.getStdpassword());
    96.  
    97.                 //设置逻辑视图名
    98.  
    99.                 mav.setViewName("studentstage");
    100.  
    101.                 //返回ModelAndView对象
    102.  
    103.                 return mav;
    104.  
    105.             } else {
    106.  
    107.                 mav.addObject("name", "请重新登录！");
    108.  
    109.                 //设置逻辑视图名
    110.  
    111.                 mav.setViewName("login");
    112.  
    113.                 //返回ModelAndView对象
    114.  
    115.                 return mav;
    116.  
    117.             }
    118.  
    119.         } else {
    120.  
    121.             mav.setViewName("login");
    122.  
    123.         }
    124.  
    125.         return mav;
    126.  
    127.     }
    128.  
    129. 验证码：
    130.  
    131. public class CaptcahCode {
    132.  
    133.     public static String drawImageVerificate(HttpServletResponse response) {
    134.  
    135.         //定义验证码的宽度和高度
    136.  
    137.         int width = 120;
    138.  
    139.         int height = 25;
    140.  
    141.         //在内存中创建图片
    142.  
    143.         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    144.  
    145.         //创建图片上下文
    146.  
    147.         Graphics2D g = image.createGraphics();
    148.  
    149.         //产生随机对象，此随机对象主要用于算术表达式的数字
    150.  
    151.         Random random = new Random();
    152.  
    153.         //设置背景
    154.  
    155.         g.setColor(getRandomColor(240, 250));
    156.  
    157.         //设置字体
    158.  
    159.         g.setFont(new Font("微软雅黑", Font.PLAIN, 22));
    160.  
    161.         //开始绘制
    162.  
    163.         g.fillRect(0, 0, width, height);
    164.  
    165.         //干扰线的绘制，绘制干扰线到图片中
    166.  
    167.         g.setColor(getRandomColor(180, 230));
    168.  
    169.         for (int i = 0; i < 100; i++) {
    170.  
    171.             int x = random.nextInt(width);
    172.  
    173.             int y = random.nextInt(height);
    174.  
    175.             int x1 = random.nextInt(60);
    176.  
    177.             int y1 = random.nextInt(60);
    178.  
    179.             g.drawLine(x, y, x1, y1);
    180.  
    181.         }
    182.  
    183.         //开始进行对算术验证码表达式的拼接
    184.  
    185.         int num1 = (int) (Math.random() * 10 + 1);
    186.  
    187.         int num2 = (int) (Math.random() * 10 + 1);
    188.  
    189.         int fuhao = random.nextInt(3);//产生一个0-2之间的随机整数
    190.  
    191.         //记录符号
    192.  
    193.         String fuhaostr = null;
    194.  
    195.         int result = 0;
    196.  
    197.         switch (fuhao) {
    198.  
    199.             case 0:
    200.  
    201.                 fuhaostr = "+";
    202.  
    203.                 result = num1 + num2;
    204.  
    205.                 break;
    206.  
    207.             case 1:
    208.  
    209.                 fuhaostr = "-";
    210.  
    211.                 result = num1 - num2;
    212.  
    213.                 break;
    214.  
    215.             case 2:
    216.  
    217.                 fuhaostr = "*";
    218.  
    219.                 result = num1 * num2;
    220.  
    221.                 break;
    222.  
    223.         }
    224.  
    225.         //拼接算术表达式，用户图片显示
    226.  
    227.         String calc = num1 + " " + fuhaostr + " " + num2 + " = ?";
    228.  
    229.         //设置随机颜色
    230.  
    231.         g.setColor(new Color(20 + random.nextInt(110), 20 + random.nextInt(110), 20 + random.nextInt(110)));
    232.  
    233.         //绘制表达式
    234.  
    235.         g.drawString(calc, 5, 25);
    236.  
    237.         //结束绘制
    238.  
    239.         try {
    240.  
    241.             //输出图片到页面
    242.  
    243.             ImageIO.write(image, "jpg", response.getOutputStream());
    244.  
    245.             return String.valueOf(result);
    246.  
    247.         } catch (Exception e) {
    248.  
    249.             e.printStackTrace();
    250.  
    251.             return null;
    252.  
    253.         }
    254.  
    255.     }
    256.  
    257.     public static Color getRandomColor(int fc, int bc) {
    258.  
    259.         //利用随机数
    260.  
    261.         Random random = new Random();
    262.  
    263.         //随机颜色，了解颜色-Color(red,green,blue).rgb三元色0-255
    264.  
    265.         if (fc > 255) fc = 255;
    266.  
    267.         if (bc > 255) bc = 255;
    268.  
    269.         int r = fc + random.nextInt(bc - fc);
    270.  
    271.         int g = fc + random.nextInt(bc - fc);
    272.  
    273.         int b = fc + random.nextInt(bc - fc);
    274.  
    275.         return new Color(r, g, b);
    276.  
    277.     }}

    5.3.2注册操作

    本程序设计的权限管理中，支持学生的注册账号功能。若点击注册，则进行注册的映射请求，输入对应信息，进行注册，所示选项全部为必填项，否则无法进行注册，两次输入密码会进行判断，不同则注册失败。输入的学号会事先判断是否已经存在，存在则返回已存在。

     

    图6-3注册界面

    注册部分代码

    1. Dao层：
    2.  
    3. @Insert("insert into student(stdid, stdname, stdpassword, stdclass) value(#{stdid}, #{stdname}, #{stdpassword},#{stdclass})")
    4.  
    5. public int insertStudent(Student student);//注册用户
    6.  
    7. @Select("SELECT COUNT(stdid) from student where stdid=#{stdid}")
    8.  
    9. public int findStudentExist(String stdid);//用户id查看是否已经存在
    10.  
    11. Controller层:
    12.  
    13.   //注册页面显示
    14.  
    15.     @RequestMapping("/register")
    16.  
    17.     public String registerUser() {
    18.  
    19.         return "register";
    20.  
    21.     }
    22.  
    23.     //注册功能实现
    24.  
    25.     @RequestMapping(value = "/registerStudent", method = RequestMethod.POST)
    26.  
    27.     public String registerUser(Student student, HttpServletRequest request) throws Exception {
    28.  
    29.         if (!studentService.findStudentExist(student.getStdid())) {
    30.  
    31.             request.setAttribute("error", "用户ID已经存在！");
    32.  
    33.             request.setAttribute("stdid", student.getStdid());
    34.  
    35.             request.setAttribute("stdname", student.getStdname());
    36.  
    37.             request.setAttribute("stdpassword", student.getStdpassword());
    38.  
    39.             request.setAttribute("stdclass", student.getStdclass());
    40.  
    41.             return "register";
    42.  
    43.         } else {
    44.  
    45.             studentService.register(student);
    46.  
    47.         }
    48.  
    49.         return "tips";}

    5.3.3后台选择操作

    学生登录完毕后，将会进入图6-3-1所示的学生界面，学生可以查看个人信息，查看选课信息以及退课，修改密码，查询课设信息以及选课，成绩查询和报告的上传，下载，预览和删除；教师登录完毕后，将会进入图6-3-2所示的教师界面，教师可以查看个人信息，查看自己的开课信息以及加课，修改密码，查询学生选择课程的信息以及给出学生成绩。

     

    图6-3-1 学生后台界面

     

    图6-3-2教师后台界面

    5.3.4个人中心界面

    点击个人中心的下拉框后，进入如图6-4-1的界面，通过session取出在登录时存入的姓名密码等信息，将查到的信息返回到前端界面进行展示。用户可以点击小眼睛查看自己的密码。

    关键代码：

    1. Dao层：
    2.  
    3. @Select("SELECT * FROM `student`where stdname =#{stdname}")
    4.  
    5. public Student findStudentByName(String stdname) throws IOException;//根据用户id查找用户
    6.  
    7. Controller层：
    8.     @RequestMapping("udentcenter")
    9.     public String center(HttpSession session) throws IOException {
    10.    String stdname = (String) session.getAttribute("studentname");
    11.    Student student = studentService.findStudentByName(stdname);
    12.    session.setAttribute("stu", student);
    13.    return "studentcenter";
    14. }

    图6-4学生个人中心界面

    5.3.5学生课设中心界面

    点击课设中心下拉框，请求映射到对应的地址，通过登录时存放的session，取出登录用户的id，调用service层函数，service层调用dao层的函数，操作数据库取出所需的值，并存放在list集合中，返回该页面。对于还没出成绩的课程，学生有权选择推掉这门课设。同时点击课设名可以查看课设的详细信息，点击组号可以查看小组的详细信息。

    主要代码：

    1. Dao层：
    2.  
    3. @Select("SELECTquesion.queid,quesion.quename,teacher.teaname,choque.gruid,choque.score from quesion,teacher,choque\n" +
    5.             "where quesion.queid = choque.queid  and teacher.teaid = quesion.teaid and choque.stdid = #{stdid}")
    6.  
    7. public List<ChooseCourseInfo> findChooseCourseInfo(String stdid);
    8.  
    9. @Select("SELECT queid,quename,quemess FROM quesion where queid = #{queid}")
    10.  
    11.     public Quesion showcourse(String queid);
    12.  
    13. @Select("SELECT `group`.grubody ,`group`.gruhead from `group` where gruid =#{gruid}")
    14.  
    15.     public Group showgroup(String gruid);
    16.  
    17. Controller层：
    18.  
    19. @RequestMapping("dcourse")
    20.     public String stdcourse(HttpSession session, Model model) throws IOException {
    21.         Student stu = (Student) session.getAttribute("stulogin");
    22.         List<CourseInfo> courseInfos = studentService.findCourseInfo(stu.getStdid());
    23.         model.addAttribute("courseinfos", courseInfos);
    24.         return "stdcourse";
    25.     }
    26.  
    27.  @RequestMapping("owcourse")
    28.     public String showcourse(String queid, Model model) throws IOException {
    29.  
    30.         Quesion quesion = studentService.showcourse(queid);
    31.         model.addAttribute("quesion", quesion);
    32.         return "showcourse";
    33.     }
    34.     @RequestMapping("owgroup")
    35.     public String showgroup(String gruid, Model model) throws IOException {
    36.         Group group = studentService.showgroup(gruid);
    37.         model.addAttribute("group", group);
    38.         return "showgroup";
    39.     }

     

    图6-5学生课设中心界面

    5.3.6教师课设中心界面

    点击课设中心下拉框，请求映射到对应的地址，通过登录时存放的session，取出登录用户的id，调用service层函数，service层调用dao层的函数，操作数据库取出所需的值，并存放在list集合中，返回该页面，教师还可以对已经添加的课设进行删除，也可以通过点击添加课程设计按钮，输入信息后，添加新的课程设计。

    主要代码：

    1. Dao层：
    2.  
    3.  @Select("select quesion.queid,quesion.quename,\n" +
    5. "(select COUNT(*) from choque where choque.queid = quesion.queid) as stucount, \n" +"(SELECT COUNT(*) FROM choque where choque.queid = quesion.queid and choque.score<60) as passfail\n" +"FROM quesion WHERE teaid = #{teaid}")
    6.  
    7. public List<TeacherCourse> findteachercourse(String teaid);
    8.  
    9.  @Insert("insert into quesion (queid, quename, quemess, teaid) VALUES (#{queid},#{quename},#{quemess},#{teaid}) ")
    10.  
    11.  @Delete("delete from quesion where queid= #{queid}")
    12.  
    13.     public void dlelete(String queid);
    14.  
    15.     public void insertteacourse(Quesion quesion);
    16.  
    17. Controller层：
    18.  
    19.  @GetMapping("/topasscourse")
    20.     public String topasscourse() {
    21.         return "teachercourse";}
    22.  
    23.     @GetMapping("owcourse")
    24.     @ResponseBody
    25.     public Map<String, Object> coursecenter(HttpSession session,HttpServletRequest request) throws IOException {
    26. Teacher teacher = (Teacher) session.getAttribute("tealogin");
    27. List<TeacherCourse> teacherCourses = teacherService.FindTeacherCourse(teacher.getTeaid());
    28.         Map<String, Object> res = new HashMap<>();
    29.         res.put("code", 0);
    30.         res.put("data", teacherCourses);
    31.         return res;}
    32.  
    33.  
    34.  
    35.   @RequestMapping("/toaddcourse")
    36.  
    37.     public String toaddcou() {
    38.  
    39.         return "addteacourse";
    40.  
    41.     }
    42.  
    43.     @RequestMapping("/addteachercourse")
    44.  
    45.     @ResponseBody
    46.  
    47.     public Map<String, String> addcourse(Model model, HttpServletRequest request, Quesion quesion, HttpSession session) throws IOException {
    48.  
    49.         Teacher teacher = (Teacher) session.getAttribute("tealogin");
    50.  
    51.         System.out.println(quesion);
    52.  
    53.         Map<String, String> res = new HashMap<>();
    54.  
    55.         if (!teacherService.findqueexist(quesion.getQueid())) {
    56.  
    57.  
    58.  
    59.             res.put("code","200");
    60.  
    61.             res.put("msg", "课号已存在，不能重复添加");
    62.  
    63.         }
    64.  
    65.         else
    66.  
    67.             {
    68.  
    69.                 quesion.setTeaid(teacher.getTeaid());
    70.  
    71.                 teacherService.insertteacourse(quesion);
    72.  
    73.                 res.put("code", "0");
    74.  
    75.                 res.put("msg", "添加成功");
    76.  
    77.             }
    78.  
    79.         return res;
    80.  
    81. }
    82.  
    83.  @RequestMapping("/delcourse")
    84.  
    85.  
    86.  
    87.     public String delcourse(String gruid) throws IOException {
    88.  
    89.  
    90.  
    91.         studentService.delcourse(gruid);
    92.  
    93.  
    94.  
    95.         return "redirect:coursecenter"; }

     

    图6-6学生课设中心界面

    5.3.7修改密码界面

    点击修改密码下拉框，请求映射到对应的地址，通过登录时存放的session，取出登录用户的id，调用service层函数，service层调用dao层的函数，通过传入的参数进行对学生信息的更新，页面部分，系统会对输入的信息进行判断，包括原密码和新密码，判断原密码是否正确，判断两次输入的密码是否一致。

    关键代码：

    1. Dao层
    2.  
    3. @Update("UPDATE student set stdpassword = #{stdpassword} where stdid = #{stdid}")
    4.  
    5.  
    6.  
    7.     public int updatestudent(Student student);
    8.  
    9. Controller层
    10.  
    11.  @RequestMapping("/pass")
    12.  
    13.     public String pass() {
    14.  
    15.         return "studentpass";
    16.  
    17.     }
    18.  
    19.     @RequestMapping("/topass")
    20.  
    21.     public String topass(String stdpassword, HttpSession session) throws IOException {
    22.  
    23.         Student stu = (Student) session.getAttribute("stulogin");
    24.  
    25.  
    26.  
    27.         String stdid = stu.getStdid();
    28.  
    29.         System.out.println(stdid + " " + stdpassword);
    30.  
    31.         Student studd = new Student();
    32.  
    33.         studd.setStdid(stdid);
    34.  
    35.         studd.setStdpassword(stdpassword);
    36.  
    37.         studentService.updateStudent(studd);
    38.  
    39.         return "redirect:tologin";}

     

    图6-7管理员修改界面

    5.3.8选课查询界面

    点击选课查询下拉框，请求映射到对应的地址，通过映射到JSP界面后，JSP界面通过Ajax异步请求，访问映射地址，通过通过自定义的Json类将数据通过Json数据格式返回到JSP界面，以leyui渲染的数据表格形式展现出来。用户可以对查出来的课设信息进行选择，填写同组成员信息后，将该课程设计加入到自己的课设中心。系统还会判断收入的组号是不是已经存在，存在则返回改界面。

    主要代码：

    1. Dao层：
    2.  
    3.  @Select("select * from quesion limit #{page},#{size}")
    4.  
    5. public List<Quesion> FindQuesionByPage(Map<String, Object> params);//分页查询用户
    6.  
    7.  @Select("select count(gruid) from  `group` where gruid =#{gruid}")
    8.  
    9.     public int findGroupExist(String gruid);
    10.  
    11.  @Insert("insert into `group`(gruid, grubody, gruhead) VALUES (#{gruid},#{grubody},#{gruhead})")
    12.  
    13.     public int addgroup(Group group);
    14.  
    15.  
    16.  
    17.     @Insert("insert into choque(stdid, queid, gruid) VALUES (#{stdid},#{queid},#{gruid})")
    18.  
    19.     public int addchoque(Choque choque);
    20.  
    21.     @Select("SELECT COUNT(*) FROM quesion")
    22.  
    23. public int count() throws SQLException;//查询用户总数
    24.  
    25. Controller层：
    26.  
    27.  @RequestMapping(value = "/findquesionPage", method = RequestMethod.GET)
    28.  
    29.     public void findStudentPage(Quesion quesion, HttpServletRequest request, HttpServletResponse response) throws Exception {
    30.  
    31.         request.setCharacterEncoding("utf-8");
    32.  
    33.  
    34.  
    35.         response.setContentType("application/json;charset=UTF-8");//设置编码，防止json中文乱码
    36.  
    37.  
    38.  
    39.         int index = 1;
    40.  
    41.         String sindex = request.getParameter("page");
    42.  
    43.         if (sindex != null && !"".equals(sindex)) {
    44.  
    45.             index = Integer.parseInt(sindex);
    46.  
    47.         }
    48.  
    49.         int size = 5;
    50.  
    51.         String ssize = request.getParameter("limit");
    52.  
    53.         if (ssize != null && !"".equals(ssize)) {
    54.  
    55.             size = Integer.parseInt(ssize);
    56.  
    57.         }
    58.  
    59.         PageBean<Quesion> pageBean = new PageBean<Quesion>();
    60.  
    61.         pageBean.setLimit(size);
    62.  
    63.         pageBean.setPage(index);
    64.  
    65.  
    66.  
    67.         System.out.println(pageBean.getLimit());
    68.  
    69.  
    70.  
    71.         try {
    72.  
    73.             pageBean = studentService.FindQuesionByPage(index, size);
    74.  
    75.         } catch (IOException | SQLException e) {
    76.  
    77.             e.printStackTrace();
    78.  
    79.         }
    80.  
    81.         JsonResult<Quesion> jr = new JsonResult<Quesion>("0", "", String.valueOf(pageBean.getTotalCount()), pageBean.getList());//交互json格式所需的对象
    82.  
    83.         String jsonStr = JSON.toJSONString(jr);//将JsonResult对象转换为json串
    84.  
    85.         PrintWriter out = response.getWriter();
    86.  
    87.         out.print(jsonStr);
    88.  
    89.         out.close();}
    90.  
    91.  @RequestMapping("/toaddcourse")
    92.  
    93.     public String addcoursejsp(String queid, Model model, HttpSession session) throws IOException {
    94.  
    95.         Student stud = (Student) session.getAttribute("stulogin");
    96.  
    97.         model.addAttribute("stqueid", queid);
    98.  
    99.         model.addAttribute("ststdid", stud.getStdid());
    100.  
    101.         return "addcourses";
    102.  
    103.     }
    104.  
    105.     @RequestMapping("/addinfo")
    106.  
    107.     public String addgroup(Model model, HttpServletRequest request, Group group, HttpSession session) throws IOException {
    108.  
    109.         String stdid = request.getParameter("stdid");
    110.  
    111.         String queid = request.getParameter("queid");
    112.  
    113.         System.out.println(stdid +" " + queid);
    114.  
    115.         if (!studentService.findGroupExist(group.getGruid())) {
    116.  
    117.             Student stud = (Student) session.getAttribute("stulogin");
    118.  
    119.             model.addAttribute("stqueid", queid);
    120.  
    121.             model.addAttribute("ststdid", stud.getStdid());
    122.  
    123.             request.setAttribute("gruid", "该组号已经存在");
    124.  
    125.             request.setAttribute("grubody", group.getGrubody());
    126.  
    127.             request.setAttribute("gruhead", group.getGruhead());
    128.  
    129.             return "addcourses";
    130.  
    131.         } else {
    132.  
    133.             Choque choque = new Choque();
    134.  
    135.             choque.setStdid(stdid);
    136.  
    137.             choque.setGruid(group.getGruid());
    138.  
    139.             choque.setQueid(queid);
    140.  
    141.             studentService.addgroup(group);
    142.  
    143.             studentService.addchoque(choque);
    144.  
    145.             return "tips";
    146.  
    147.         }}

     

    图6-8-1 学生查看课设信息界面

     

    图6-8-2学生填写同组信息添加课设界面

    5.3.9成绩查询界面

    点击成绩查询下拉框，请求映射到对应的地址，获取session中的用户id后，调用service层的函数，在调用dao层的函数，通过数据库查到的信息，封装在一个list集合中返回到jsp界面。

    主要代码：

    1. Dao层：
    2.  
    3.  @Select("SELECT quesion.queid,quesion.quename,teaname,score from quesion,teacher,choque \n" +
    5.             "where quesion.queid=choque.queid and quesion.teaid = teacher.teaid and choque.stdid = #{stdid}")
    6.  
    7. public List<CourseInfo> findCourseInfo(String stdid);
    8.  
    9.  
    10.  
    11. Controller层：
    12.  
    13.   @RequestMapping("dcourse")
    14.     public String stdcourse(HttpSession session, Model model) throws IOException {
    15.         Student stu = (Student) session.getAttribute("stulogin");
    16.  
    17.         List<CourseInfo> courseInfos = studentService.findCourseInfo(stu.getStdid());
    18.         model.addAttribute("courseinfos", courseInfos);
    19.         return "stdcourse";
    20.     }

    图6-9成绩查询界面

     

    5.3.10文件上传操作

    用户点击文件上传按钮后，请求映射到对应的地址，通过异步Ajax请求，通过session中的id值，调用service层和dao层函数，查询该用户上传的全部文件，封账成一个list集合，最后封装成Map映射，返回的jsp界面，通过layui table对于表格的渲染，展示数据。

    主要代码：

    1. Dao层：
    2.  
    3.  @Select("SELECT * FROM `files` where files.stdid= #{stdid} order by files.stdid limit #{begin}, #{offset}")
    4.  
    5.     public List<UserFile> queryByUserId (@Param("stdid") String stdid , @Param("begin") Integer begin , @Param("offset") Integer offset);
    6.  
    7.  
    8.  
    9.     @Select("SELECT COUNT(files.stdid) FROM files where files.stdid = #{stdid}")
    10.  
    11.     public int queryFileCounts(String stdid);
    12.  
    13.  
    14.  
    15.     @Insert("insert into files(filename, ext, path, size, type, downcount, uploadtime, stdid)\n" +
    17.             " VALUES (#{filename},#{ext},#{path},#{size},#{type},#{downcount},#{uploadtime},#{stdid});")
    18.  
    19.     public  void savefile(UserFile userFile);
    20.  
    21.  
    22.  
    23.     @Delete(" delete from files where fileid=#{fileid}")
    24.  
    25.     public void delete(Integer fileid);
    26.  
    27.     @Select("select * FROM files where fileid =#{fileid}")
    28.  
    29.     public UserFile queryByUserFileId(Integer fileid);
    30.  
    31.     @Update("update files set downcount = #{downcount} where fileid = #{fileid}")
    32.  
    33.     public int updateflie(UserFile userFile);
    34.  
    35. Controller层：
    36.  
    37.  // 展示所有的文件
    38.  
    39.     @GetMapping("/index")
    40.  
    41.     public String fileIndex() {
    42.  
    43.         return "filelist";
    44.  
    45.     }
    46.  
    47.     @PostMapping("showfiles")
    48.  
    49.     @ResponseBody
    50.  
    51.     public Map<String, Object> queryAllFile(HttpSession session, HttpServletRequest request) {
    52.  
    53.         int page = Integer.parseInt(request.getParameter("page"));
    54.  
    55.         int limit = Integer.parseInt(request.getParameter("limit"));
    56.  
    57.         Student student = (Student) session.getAttribute("stulogin");
    58.  
    59.         List<UserFile> userFiles = userFileService.queryByUserId(student.getStdid(), page, limit);
    60.  
    61.         Map<String, Object> res = new HashMap<>();
    62.  
    63.         res.put("code", 0);
    64.  
    65.         res.put("count", userFileService.queryFileCounts(student.getStdid()));
    66.  
    67.         res.put("data", userFiles);
    68.  
    69.         return res;
    70.  
    71.     }
    72.  
    73.     // 上传文件到数据库
    74.  
    75.     @PostMapping("upload")
    76.  
    77.     @ResponseBody
    78.  
    79.     public Map<String, String> uploadFile(@RequestParam("file") MultipartFile file, HttpSession session) {
    80.  
    81.         System.out.println("uploadFile trigger");
    82.  
    83.  
    84.  
    85.         Map<String, String> res = new HashMap<>();
    86.  
    87.         try {
    88.  
    89.             // 获取上传用户的Id
    90.  
    91.             Student student = (Student) session.getAttribute("stulogin");
    92.  
    93.             // 获取文件的原始名称
    94.  
    95.             String fileName = file.getOriginalFilename();
    96.  
    97.             // 获取文件的后缀
    98.  
    99.             String extension = FilenameUtils.getExtension(file.getOriginalFilename());
    100.  
    101.             // 获取文件的大小
    102.  
    103.             long size = file.getSize();
    104.  
    105.             // 获取文件的类型
    106.  
    107.             String type = file.getContentType();
    108.  
    109.             // 根据日期动态的生成目录
    110.  
    111.             String localContainer = "/fileContainer";
    112.  
    113.             String uploadPath = ResourceUtils.getURL("classpath").getPath() + localContainer;
    114.  
    115.             String dateFormat = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
    116.  
    117.             File dateDirPath = new File(uploadPath + File.separator + dateFormat);
    118.  
    119.             if (!dateDirPath.exists()) {
    120.  
    121.                 dateDirPath.mkdirs();
    122.  
    123.             }
    124.  
    125.             // 处理文件上传
    126.  
    127.             file.transferTo(new File(dateDirPath, fileName));
    128.  
    129.             // 将文件信息存入数据库中
    130.  
    131.             UserFile userFile = new UserFile();
    132.  
    133.             userFile.setFilename(fileName);
    134.  
    135.             userFile.setExt('.' + extension);
    136.  
    137.             userFile.setPath(Paths.get(localContainer, dateFormat, fileName).toString());
    138.  
    139.             userFile.setSize(size);
    140.  
    141.             userFile.setType(type);
    142.  
    143.             userFile.setStdid(student.getStdid());
    144.  
    145.             userFileService.save(userFile);
    146.  
    147.             res.put("code", "0");
    148.  
    149.             res.put("msg", "上传成功");
    150.  
    151.             res.put("url", "index");
    152.  
    153.         } catch (IOException e) {
    154.  
    155.             e.printStackTrace();
    156.  
    157.             res.put("code", "-1");
    158.  
    159.             res.put("msg", "上传失败");
    160.  
    161.             res.put("url", "index");
    162.  
    163.         }
    164.  
    165.         return res;
    166.  
    167.     }
    168.  
    169.     @GetMapping("delete")
    170.  
    171.     @ResponseBody
    172.  
    173.     public Map<String, Object> delete(Integer fileid) {//@PathVariable:接收请求路径中占位符的值
    174.  
    175.         Map<String, Object> map = new HashMap<>();
    176.  
    177.         try {
    178.  
    179.             UserFile fileInfo = userFileService.queryByUserFileId(fileid);
    180.  
    181.             final String realPath = ResourceUtils.getURL("classpath").getPath() + fileInfo.getPath();
    182.  
    183.             File file = new File(realPath);
    184.  
    185.             if (file.exists()) {
    186.  
    187.                 file.delete();  //立即删除
    188.  
    189.             }
    190.  
    191.             userFileService.delete(fileid);
    192.  
    193.             map.put("code", 0);
    194.  
    195.             map.put("msg", "删除成功！");
    196.  
    197.         } catch (FileNotFoundException e) {
    198.  
    199.             e.printStackTrace();
    200.  
    201.             map.put("code", -1);
    202.  
    203.             map.put("msg", "删除成功！");
    204.  
    205.         }
    206.  
    207.         return map;
    208.  
    209.     }
    210.  
    211.     public void getFile(String openStyle, Integer fileid, HttpServletResponse response) throws IOException {
    212.  
    213.         UserFile file = userFileService.queryByUserFileId(fileid);
    214.  
    215.         if(openStyle.equals("inline"))
    216.  
    217.         {
    218.  
    219.             // 获取文件信息
    220.  
    221.             final String realPath = ResourceUtils.getURL("classpath").getPath() + file.getPath();
    222.  
    223.             // 获取文件输入流
    224.  
    225.             FileInputStream is = new FileInputStream(new File(realPath));
    226.  
    227.             // 附件下载
    228.  
    229.             response.setHeader("content-disposition", openStyle+";filename=" + URLEncoder.encode(file.getFilename(), "UTF-8"));
    230.  
    231.             // 获取响应response输出流
    232.  
    233.             ServletOutputStream os = response.getOutputStream();
    234.  
    235.             // 文件拷贝
    236.  
    237.             IOUtils.copy(is, os);
    238.  
    239.             IOUtils.closeQuietly(is);
    240.  
    241.             IOUtils.closeQuietly(os);
    242.  
    243.         }
    244.  
    245.         // 更新下载次数
    246.  
    247.         if(openStyle.equals("attachment")){
    248.  
    249.             file.setDowncount(file.getDowncount() + 1);
    250.  
    251.             userFileService.update(file);
    252.  
    253.         }
    254.  
    255.     }
    256.  
    257.     @GetMapping("preview")
    258.  
    259.     public void preview(Integer fileid, HttpServletResponse response) throws IOException {
    260.  
    261.         String openStyle = "inline";
    262.  
    263.         getFile(openStyle,fileid,response);
    264.  
    265.     }
    266.  
    267.     @GetMapping("download")
    268.  
    269.     public void download( Integer fileid, HttpServletResponse response){
    270.  
    271.         String openStyle = "attachment";
    272.  
    273.         try{
    274.  
    275.             getFile(openStyle,fileid,response);
    276.  
    277.         } catch (IOException e) {
    278.  
    279.             e.printStackTrace();
    280.  
    281.         }}

     

    图6-10-1文件界面

     

    图6-10-2文件上传界面

     

    图6-10-3文件预览界面

    5.3.10教师端信息查询

    老师点击信息查询后，在session中获取老师的信息，传入controller层中，调用service和dao层函数，将得到的结果以封装到list集合，将集合和一些其他信息一同封装到map集合中，通过json串的形式一同传回jsp界面，通过leyui table表格渲染展示。教师也可以对选择了该课设的学生给出成绩，也可以修改成绩，方法类似，这里不再赘述。

    主要代码：

    1. Dao层：
    2.  
    3.  @Select("SELECT student.stdid,student.stdname,quesion.queid,quesion.quename,choque.score\n" +
    5.             "FROM student,choque,quesion\n" +
    7.             "WHERE student.stdid = choque.stdid AND choque.queid = quesion.queid AND quesion.teaid = #{teaid}")
    8.  
    9.     public List<Studentlist> showstudent(String teaid);
    10.  
    11.     @Update("UPDATE choque SET score = #{score} WHERE stdid = #{stdid} AND queid = #{queid}")
    12.  
    13.     public void upscore(Studentlist studentlist);
    14.  
    15. Controller层：
    16.  
    17.  @RequestMapping("owstudents")
    18.     @ResponseBody
    19.     public Map<String, Object> showstudent(HttpSession session, Model model) throws IOException {
    20.         Teacher teacher = (Teacher) session.getAttribute("tealogin");
    21.         List<Studentlist> studentlists = teacherService.showstudent(teacher.getTeaid());
    22.         Map<String, Object> res = new HashMap<>();
    23.         res.put("code", 0);
    24.         res.put("data", studentlists);
    25.         return res; }
    26.     @RequestMapping("/addscore")
    27.     @ResponseBody
    28.     public Map<String, Object> addscore(HttpSession session, Studentlist studentlist) throws IOException {
    29.         teacherService.addscore(studentlist);
    30.         Map<String, Object> res = new HashMap<>();
    31.         res.put("code", 0);
    32.         res.put("msg", "添加成功！");
    33.         return res;}

     

    图6-11教师端信息查询界面

     

    图6-12教师端条件查询界面

    5.3.11拦截器操作

    登录拦截器，默认拦截/student 路径下的所有请求，若session中存在student，则放行，如不存在则跳转到登录界面。

    1. public class LoginConfig implements WebMvcConfigurer {
    2.     @Override
    3.     public void addInterceptors(InterceptorRegistry registry) {
    4.         //注册TestInterceptor拦截器
    5.         InterceptorRegistration registration = registry.addInterceptor(new LoginInterceptor());
    6.         registration.addPathPatterns("/student/*");
    7.         registration.excludePathPatterns(
    8.                 "udent/tologin",
    9.                 "udent/register",
    10.                 "udent/registerStudent",
    11.                 "udent/login",
    12.                 "udent/code",
    13.                 "/css/**",
    14.                 "/images/**",
    15.                 "/imagess/**",
    16.                 "/js/**",
    17.                 "/lib/**" );}}
    18.     @Override
    19. public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    20.      System.out.println("====================拦截前=================");
    21. HttpSession session = request.getSession();
    22. Student user = (Student) session.getAttribute("stulogin");
    23. if (user != null) {
    24. System.out.println("====================用户已登录================="+user.toString());
    25. return true;
    26.  
    27. }
    28. if (!request.getContextPath().equals(request.getContextPath() + "student/tologin")) {
    29.             response.sendRedirect(request.getContextPath() + "udent/tologin");
    30.  
    31. }
    32.  return false;

    项目完整源码+说明书+软件说明+数据库表设计 ：

    点他：🍞正在为您运送作品详情

  • 相关阅读:
    Linux常用命令学习3
    优先队列(priority_queue)用法详解
    判断期末挂科问题
    调优zuul1.x（基于arthas）
    vue 01 创建一个简单vue页面
    Spring学习笔记—JDK动态代理
    计算机网络：3数据链路层
    LeetCode 热题 1. 两数之和 2. 两数相加 3. 无重复字符的最长子串 4. 寻找两个正序数组的中位数 5. 最长回文子串
    修改node_modules中安装的依赖（如第三方ui组件样式）并在下次安装时保留
    Android 12(S) 图像显示系统 - SurfaceFlinger GPU合成/CLIENT合成方式 - 随笔1
  • 原文地址：https://blog.csdn.net/qq_47982709/article/details/125469037