系统设计

主要功能点

​ 高校实习管理系统主要解决各大高校学生暑假实习/寒假实习等过程管理难的问题，提升学校、老师和学生、企业之间的联系，避免学生因实习任务而感到为难，解决学校和老师无法实时感知到学生的实习情况，无法了解到学生的实习过程，无法对实习结果进行评分等问题，提升企业和学校的沟通，及时发现学生存在的问题，优化实习安排，更好的帮助学生尽快的融入社会。

​ 高校实习管理系统的主要需求是提供给学生以及老师管理学生实习过程的系统，方便师生管理自己的实习计划，目前系统分为 教师、企业以及学生三种角色，以及固定的管理员角色。 其中教师负责制定和发布学习计划，发布学习任务或者管理学生的日记等，评价学生的实习情况以及查看统计分析。 企业负责根据教师发布的学习计划，提供相应的实习岗位供学生选择，也可以对学生的岗位实习情况进行评价。 学生负责选择适合自己的学习计划以及学习岗位，并按时填写完成情况和周报等。 管理员角色负责管理用户信息、角色信息、角色权限、学生管理，教师信息管理、企业信息管理等等。

主要功能如下：

1. 企业角色功能模块

   • 注册：注册企业账户

• 登录：登录企业账户
  • 查看实习计划：查看教师发布的实习计划
• 实习岗位管理：对实习岗位进行新增，修改，删除，查询操作。
  • 实习任务管理：对实习任务进行新增，修改，删除，查询操作。
• 任务完成情况管理：可以查看任务完成情况，并予以评价。

2. 教师角色功能模块

   • 注册：注册教师账户
   • 登录：登录教师账户
   • 实习计划管理：对实习计划进行新增，修改，删除，查询操作。
   • 查看实习岗位：查看企业发布的实习岗位。
   • 查看任务完成情况：查看学生的任务完成情况。
   • 实习评价：对各个学生的实习情况予以评价。

3. 学生角色功能模块

   • 注册：注册教师账户

   • 登录：登录教师账户

   • 查看实习计划：查看教师发布的实习计划并选择加入。

   • 查看实习岗位：查看企业发布的实习岗位并选择加入。

   • 我参加的实习计划：查看我选择加入的实习计划。

   • 我的实习岗位：查看我选择加入的实习岗位。

   • 任务管理：查看企业针对岗位发布的实习任务并填写任务完成情况。

4. 管理员角色功能模块

   • 学院管理：维护学院的信息
   • 专业管理：维护专业的信息
   • 学生管理：维护学生的信息
   • 统计分析
     • 学生人数分布
     • 学生专业分布
     • 学生实习计划分布
     • 学生实习岗位分布

拟解决的主要问题

1. 前端展示分类合理，内容实用，主题突出；后台服务设计思路清晰，通用性强。
2. 分类规则标准，数据接口设计通用。
3. 后台数据可以快速检索。进行查询、增加、删除、修改、统计等操作。
4. 系统安全包含用户安全，数据安全，验证技术可靠合理通用，对具体操作分角色分权限，保证数据的安全可靠。

技术实现

涉及的主要技术点

1. 基于SSM思想实现的SpringBoot框架，用于提供web服务，SpringBoot是在SpringMvc的基础上提出了约定大于配置的思想，以约定的形式省去了SpringMvc的许多配置项，这些配置项可以以约定好的名称以类似插件的方式接入到系统中。
2. MyBatis框架，MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。
3. Mysql数据库，MySQL 是最流行的关系型数据库管理系统，在 WEB 应用方面 MySQL 是最好的 RDBMS(Relational Database Management System：关系数据库管理系统)应用软件之一
4. Shiro框架，Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
5. Redis缓存数据库，Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储数据库，并提供多种语言的 API。Redis 通常被称为数据结构服务器，因为值（value）可以是字符串(String)、哈希(Hash)、列表(list)、集合(sets)和有序集合(sorted sets)等类型。
6. Layui框架，一个优秀的前端UI框架，可以帮你快速建立增删改查等基础前端架构，https://layuion.com/
7. Jquery，Jquery是一个快速、简洁的JavaScript框架，是继Prototype之后又一个优秀的JavaScript代码库（框架）于2006年1月由[John Resig](https://baike.baidu.com/item/John Resig/6336344)发布。jQuery设计的宗旨是“write Less，Do More”，即倡导写更少的代码，做更多的事情。它封装JavaScript常用的功能代码，提供一种简便的JavaScript设计模式，优化HTML文档操作、事件处理、动画设计和Ajax交互。
8. ECharts，ECharts是一款基于JavaScript的数据可视化图表库，提供直观，生动，可交互，可个性化定制的数据可视化图表。ECharts最初由百度团队开源，并于2018年初捐赠给Apache基金会，成为ASF孵化级项目

设计思路

本系统按照角色划分为管理员、学生、教师、企业，教师角色负责管理实习计划，企业负责管理实习岗位，学生角色可以选择实习计划、实习岗位等加入，并且填写相关的任务反馈，管理员角色负责查看整体的统计分析，对整体学生的实习过程进行管理。

代码实现

本系统采用Java语言编写，主要是基于Mvc的架构模式实现，按照模块可以划分为控制层、服务层、持久层三大块

1. 控制层

   控制层主要是基于Springboot提供Web接口，本系统所有数据接口均采用JSON的方式进行数据交互，页面映射采用ModelAndView的方式处理，只映射页面不传递数据，命名方式也是按照业务划分的，比如实习计划管理对应的控制层代码文件命名为PlanController

   控制层代码如下所示，控制层会按照统一的状态码返回信息，遵循Http状态码的规则，默认200为正常请求，异常请求会返回msg作为提示信息。部分代码实现如下所示

   package com.crk.shixiguanli.controller;
   
   import com.crk.shixiguanli.entity.Plan;
   import com.crk.shixiguanli.entity.User;
   import com.crk.shixiguanli.service.PlanService;
   import com.crk.shixiguanli.util.LayUiTableJson;
   import com.crk.shixiguanli.util.Page;
   import com.crk.shixiguanli.util.ResponseResult;
   import org.apache.shiro.SecurityUtils;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RequestParam;
   import org.springframework.web.bind.annotation.RestController;
   import org.springframework.web.servlet.ModelAndView;
   
   import java.util.List;
   
   /**
    * Description:
    *
    * @author:
    * Date: 2020-04-26
    * Time: 16:32
    */
   @RestController
   @RequestMapping("plan")
   public class PlanController {
       @Autowired
       PlanService planService;
   
       /**
        * 列表页
        * @return
        */
       @RequestMapping("manage")
       public ModelAndView manage(){
           ModelAndView modelAndView = new ModelAndView("/workspace/plan/planList.html");
           return modelAndView;
       }
   
       @RequestMapping("show")
       public ModelAndView show(){
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           ModelAndView modelAndView = new ModelAndView("/workspace/plan/planShow.html");
           modelAndView.addObject("userType",userinfo.getUserType());
           return modelAndView;
       }
   
       /**
        * 详情页
        * @return
        */
       @GetMapping("detail")
       public ModelAndView detail(){
           ModelAndView modelAndView = new ModelAndView("/workspace/plan/planAdd.html");
           return modelAndView;
       }
   
       /**
        * 详情页
        * @return
        */
       @GetMapping("detailShow")
       public ModelAndView detailShow(){
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           ModelAndView modelAndView = new ModelAndView("/workspace/plan/planAddShow.html");
           modelAndView.addObject("userType",userinfo.getUserType());
           return modelAndView;
       }
   
   
       @GetMapping("detailStudent")
       public ModelAndView detailStudent(){
           ModelAndView modelAndView = new ModelAndView("/workspace/plan/planDetailStudent.html");
           return modelAndView;
       }
   
       /**
        * 详情页
        * @return
        */
       @GetMapping("myPlan")
       public ModelAndView myPlan(){
           ModelAndView modelAndView = new ModelAndView("/workspace/plan/myPlan.html");
           return modelAndView;
       }
   
       @GetMapping("studentComplete")
       public ModelAndView stduentComplete(){
           ModelAndView modelAndView = new ModelAndView("/workspace/plan/studentComplete.html");
           return modelAndView;
       }
   
   
       @GetMapping("statics")
       public ModelAndView statics(){
           ModelAndView modelAndView = new ModelAndView("/workspace/statics.html");
           return modelAndView;
       }
   
   
   
       /**
        * 分页查询
        * @param page
        * @param limit
        * @return
        */
       @GetMapping("queryPage")
       public LayUiTableJson queryPage(@RequestParam(defaultValue = "1") int page
               , @RequestParam(defaultValue = "10") int limit){
           Page pageInfo = new Page();
           pageInfo.setCurrentPage(page);
           pageInfo.setSize(limit);
           ResponseResult ResponseResult = planService.queryPage(pageInfo);
           LayUiTableJson layUiTableJson = new LayUiTableJson(0,null,pageInfo.getAllRow(),(List)ResponseResult.getData());
           return layUiTableJson;
       }
   
       @GetMapping("queryStudentDetail")
       public LayUiTableJson queryStudentDetail(String planName,String studentName,@RequestParam(defaultValue = "1") int page
               , @RequestParam(defaultValue = "10") int limit){
           Page pageInfo = new Page();
           pageInfo.setCurrentPage(page);
           pageInfo.setSize(limit);
           ResponseResult ResponseResult = planService.queryStudentDetail(planName,studentName,pageInfo);
           LayUiTableJson layUiTableJson = new LayUiTableJson(0,null,pageInfo.getAllRow(),(List)ResponseResult.getData());
           return layUiTableJson;
       }
   
       @GetMapping("queryStudentComplete")
       public ResponseResult queryStudentComplete(@RequestParam("studentId") int studentId){
           return planService.queryStudentComplete(studentId);
       }
   
       @GetMapping("getStudentComplete")
       public ResponseResult getStudentComplete(@RequestParam("id") int id){
           return planService.getStudentComplete(id);
       }
   
   
   
   
       /**
        * 查询所有
        * @return
        */
       @RequestMapping("queryAll")
       public ResponseResult queryAll(){
           return planService.queryAll();
       }
   
       /**
        * 查询单个
        * @param id
        * @return
        */
       @RequestMapping("getOneShow")
       public ResponseResult getOneShow(@RequestParam("id") Integer id){
           return planService.getOneShow(id);
       }
   
       /**
        * 查询单个
        * @param id
        * @return
        */
       @RequestMapping("getOne")
       public ResponseResult getOne(@RequestParam("id") Integer id){
           return planService.getOne(id);
       }
   
   
       /**
        * 查询单个
        * @return
        */
       @RequestMapping("getMyPlan")
       public ResponseResult getMyPlan(){
           return planService.getMyPlan();
       }
   
   
       /**
        * 加入计划
        * @param id
        * @return
        */
       @RequestMapping("joinPlan")
       public ResponseResult joinPlan(@RequestParam("id") Integer id){
           return planService.joinPlan(id);
       }
   
       /**
        * 保存数据
        * @param job
        * @return
        */
       @RequestMapping("save")
       public ResponseResult save(Plan job){
           return planService.save(job);
       }
   
       /**
        * 删除数据
        * @param id
        * @return
        */
       @RequestMapping("delete")
       public ResponseResult delete(@RequestParam("id") Integer id){
           return planService.delete(id);
       }
   
       @RequestMapping("queryPlanList")
       public ResponseResult queryPlanList(){
           return planService.queryPlanList();
       }
   
   
   
       @RequestMapping("evaluate")
       public ResponseResult evaluate(@RequestParam("id") int id,@RequestParam("evaluate") String evaluate,@RequestParam("score") String score){
           return planService.evaluate(id,evaluate,score);
       }
   
       @RequestMapping("getCount")
       public ResponseResult getCount(){
           return planService.getCount();
       }
   
       @RequestMapping("getStudentProfessionalMap")
       public ResponseResult getStudentProfessionalMap(){
           return planService.getStudentProfessionalMap();
       }
   
       @RequestMapping("getStudentPlanMap")
       public ResponseResult getStudentPlanMap(){
           return planService.getStudentPlanMap();
       }
   
       @RequestMapping("getStudentJobMap")
       public ResponseResult getStudentJobMap(){
           return planService.getStudentJobMap();
       }
   
   
   }
   
   

2. 服务层

   服务层提供具体业务功能的实现，比如学院管理，查询学院信息进行分页处理时，可能要先查询总数，然后按照总数和每页数量进行分页查询所需的数据，在服务层会对控制层的请求和操作数据库的多次动作进行包装，例如查询出某条数据，但该数据中信息需要进行编码-显示名称的转化时（如数据库存储的性别数据是0和1，页面上显示需要展示成男和女），命名方式也是按照业务划分的，服务层部分代码如下所示

   package com.crk.shixiguanli.service.impl;
   
   import com.crk.shixiguanli.dao.*;
   import com.crk.shixiguanli.entity.*;
   import com.crk.shixiguanli.service.PlanService;
   import com.crk.shixiguanli.util.Page;
   import com.crk.shixiguanli.util.ResponseResult;
   import org.apache.shiro.SecurityUtils;
   import org.omg.CORBA.OBJ_ADAPTER;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   
   import java.text.SimpleDateFormat;
   import java.util.ArrayList;
   import java.util.Date;
   import java.util.HashMap;
   import java.util.List;
   
   
   /**
    * Description:
    *
    * @author:
    * Date: 2020-04-26
    * Time: 17:42
    */
   @Service
   public class PlanServiceImpl implements PlanService {
       @Autowired
       PlanDao planDao;
       @Autowired
       StudentDao studentDao;
       @Autowired
       PlanStudentDao planStudentDao;
       @Autowired
       UserDao userDao;
       @Autowired
       ProfessionalDao professionalDao;
       @Autowired
       TaskCompleteDao taskCompleteDao;
       @Autowired
       JobStudentDao jobStudentDao;
   
   
   //    private final static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
       /**
        * 分页查询
        *
        * @param page
        * @return
        */
       @Override
       public ResponseResult queryPage(Page page) {
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           Integer count = planDao.countByCondition(userinfo.getId());
           page.setAllRow(count);
           List<Plan> planList  = planDao.selectByCondition(userinfo.getId(),page.getStart(), page.getSize());
           return getPlanVo(planList);
       }
   
       /**
        * 分页查询
        *
        * @param page
        * @return
        */
       @Override
       public ResponseResult queryStudentDetail(String planName,String studentName,Page page) {
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           Integer count = planStudentDao.countByCondition(userinfo.getId(),planName,studentName);
           page.setAllRow(count);
           List<PlanStudentVo> planStudentVoList  = planStudentDao.selectByCondition(userinfo.getId(),planName,studentName,page.getStart(), page.getSize());
           return ResponseResult.success(planStudentVoList);
       }
   
       @Override
       public ResponseResult queryStudentComplete(Integer studentId) {
           TaskCompleteVo taskCompleteVo = taskCompleteDao.queryStudentComplete(studentId);
           return ResponseResult.success(taskCompleteVo);
       }
   
       /**
        * 查询所有
        *
        * @return
        */
       @Override
       public ResponseResult queryAll() {
           List<Plan> planList = planDao.selectAll();
           return getPlanVo(planList);
       }
   
       /**
        * 查询单个
        *
        * @param id
        * @return
        */
       @Override
       public ResponseResult getOne(Integer id) {
           Plan plan = planDao.selectByPrimaryKey(id);
           return ResponseResult.success(plan);
       }
   
       @Override
       public ResponseResult getStudentComplete(Integer id) {
           PlanStudent planStudent = planStudentDao.selectByPrimaryKey(id);
           PlanStudentVo planStudentVo = new PlanStudentVo();
           planStudentVo.setId(planStudent.getId());
           planStudentVo.setEvaluate(planStudent.getEvaluate());
           planStudentVo.setScore(planStudent.getScore());
           Plan plan = planDao.selectByPrimaryKey(planStudent.getPlanId());
           planStudentVo.setPlanName(plan.getPlanName());
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           planStudentVo.setUserType(userinfo.getUserType());
           return ResponseResult.success(planStudentVo);
       }
   
       @Override
       public ResponseResult getMyPlan() {
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           PlanStudent planStudent = planStudentDao.selectByStudent(userinfo.getId());
           if (null == planStudent){
               return ResponseResult.success(null);
           }
           Plan plan = planDao.selectByPrimaryKey(planStudent.getPlanId());
           PlanVo planVo = new PlanVo();
           planVo.setId(plan.getId());
           planVo.setPlanName(plan.getPlanName());
           planVo.setStartTime(plan.getStartTime());
           planVo.setEndTime(plan.getEndTime());
           planVo.setUserName(userDao.selectByPrimaryKey(plan.getUpdater()).getUserName());
           planVo.setUpdateTime(plan.getUpdateTime());
           planVo.setPlanDesc(plan.getPlanDesc());
           planVo.setEvaluationCriterion(plan.getEvaluationCriterion());
           int compareTo = new Date().compareTo(plan.getEndTime());
           if(compareTo == 1){
               planVo.setStatusStr("已过期");
           }else{
               planVo.setStatusStr("进行中");
           }
           String joinPeople = plan.getJoinPeople();
           if (joinPeople.equals("-1")){
               planVo.setJoinPeopleStr("所有专业");
           }else{
               String[] split = joinPeople.split(",");
               List<String> stringBuffer = new ArrayList<>();
               for (String s : split) {
                   String name = professionalDao.selectByCode(s);
                   stringBuffer.add(name);
               }
               planVo.setJoinPeopleStr(String.join(",", stringBuffer));
           }
   
           planVo.setUserType(userinfo.getUserType());
   
           planVo.setHasJoin(true);
   
           planVo.setEvaluate(planStudent.getEvaluate());
           planVo.setScore(planStudent.getScore());
   
           return ResponseResult.success(planVo);
       }
   
       /**
        * 加入计划
        *
        * @param id
        * @return
        */
       @Override
       public ResponseResult joinPlan(Integer id) {
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           PlanStudent planStudent = new PlanStudent();
           planStudent.setStudentId(userinfo.getId());
           planStudent.setPlanId(id);
           planStudent.setStatus(1);
           int insert = planStudentDao.insert(planStudent);
           if (insert >0){
               return ResponseResult.success();
           }else{
               return ResponseResult.fail();
           }
       }
   
       /**
        * 查询单个
        *
        * @param id
        * @return
        */
       @Override
       public ResponseResult getOneShow(Integer id) {
           Plan plan = planDao.selectByPrimaryKey(id);
           PlanVo planVo = new PlanVo();
           planVo.setId(plan.getId());
           planVo.setPlanName(plan.getPlanName());
           planVo.setStartTime(plan.getStartTime());
           planVo.setEndTime(plan.getEndTime());
           planVo.setUserName(userDao.selectByPrimaryKey(plan.getUpdater()).getUserName());
           planVo.setUpdateTime(plan.getUpdateTime());
           planVo.setPlanDesc(plan.getPlanDesc());
           planVo.setEvaluationCriterion(plan.getEvaluationCriterion());
           int compareTo = new Date().compareTo(plan.getEndTime());
           if(compareTo == 1){
               planVo.setStatusStr("已过期");
           }else{
               planVo.setStatusStr("进行中");
           }
           String joinPeople = plan.getJoinPeople();
           if (joinPeople.equals("-1")){
               planVo.setJoinPeopleStr("所有专业");
           }else{
               String[] split = joinPeople.split(",");
               List<String> stringBuffer = new ArrayList<>();
               for (String s : split) {
                   String name = professionalDao.selectByCode(s);
                   stringBuffer.add(name);
               }
               planVo.setJoinPeopleStr(String.join(",", stringBuffer));
           }
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           planVo.setUserType(userinfo.getUserType());
           PlanStudent planStudent = planStudentDao.selectByStudent(userinfo.getId());
           if (planStudent !=null){
               planVo.setHasJoin(true);
           }else{
               planVo.setHasJoin(false);
           }
           return ResponseResult.success(planVo);
       }
   
       /**
        * 保存数据
        *
        * @param plan
        * @return
        */
       @Override
       public ResponseResult save(Plan plan) {
           if (plan.getId() == null){
               User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
               plan.setCreateTime(new Date());
               plan.setCreator(userinfo.getId());
               plan.setUpdateTime(new Date());
               plan.setUpdater(userinfo.getId());
               plan.setStatus(1);
               int insert = planDao.insert(plan);
               if (insert<=0){
                   return ResponseResult.fail();
               }
               return ResponseResult.success();
           }else{
               User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
               plan.setUpdateTime(new Date());
               plan.setUpdater(userinfo.getId());
               int updateByPrimaryKey = planDao.updateByPrimaryKey(plan);
               if (updateByPrimaryKey<=0){
                   return ResponseResult.fail();
               }
               return ResponseResult.success();
           }
       }
   
       /**
        * 删除
        *
        * @param id
        * @return
        */
       @Override
       public ResponseResult delete(Integer id) {
           int i = planDao.deleteByPrimaryKey(id);
           if (i<=0){
               return ResponseResult.fail();
           }
           return ResponseResult.success();
       }
   
       /**
        * 查询计划列表-学生页面
        *
        * @return
        */
       @Override
       public ResponseResult queryPlanList() {
           User userinfo = (User) SecurityUtils.getSubject().getPrincipal();
           Student studentByIdCard = studentDao.getStudentByIdCard(userinfo.getIdCard());
           List<Plan> planList = planDao.selectByProfession(studentByIdCard.getProfessional());
           return getPlanVo(planList);
       }
   
   
       private ResponseResult getPlanVo(List<Plan> planList){
           List<PlanVo> result = new ArrayList<>();
           for (Plan plan : planList) {
               PlanVo planVo = new PlanVo();
               planVo.setId(plan.getId());
               planVo.setPlanName(plan.getPlanName());
               planVo.setStartTime(plan.getStartTime());
               planVo.setEndTime(plan.getEndTime());
               planVo.setUserName(userDao.selectByPrimaryKey(plan.getUpdater()).getUserName());
               planVo.setUpdateTime(plan.getUpdateTime());
               planVo.setPlanDesc(plan.getPlanDesc());
               planVo.setEvaluationCriterion(plan.getEvaluationCriterion());
               int compareTo = new Date().compareTo(plan.getEndTime());
               if(compareTo == 1){
                   planVo.setStatusStr("已过期");
               }else{
                   planVo.setStatusStr("进行中");
               }
               String joinPeople = plan.getJoinPeople();
               if (joinPeople.equals("-1")){
                   planVo.setJoinPeopleStr("所有专业");
               }else{
                   String[] split = joinPeople.split(",");
                   List<String> stringBuffer = new ArrayList<>();
                   for (String s : split) {
                       String name = professionalDao.selectByCode(s);
                       stringBuffer.add(name);
                   }
                   planVo.setJoinPeopleStr(String.join(",", stringBuffer));
               }
               result.add(planVo);
           }
           return ResponseResult.success(result);
       }
   
       @Override
       public ResponseResult evaluate(int id, String evaluate, String score) {
           planStudentDao.evaluate(id,evaluate,score);
           return ResponseResult.success();
       }
   
       /**
        * 统计数量
        *
        * @return
        */
       @Override
       public ResponseResult getCount() {
   //        系统已录入的学生数量
           int studentCount = studentDao.getCount();
   //        已注册的学生数量
           int studentUserCount =  userDao.getCount("student");
   //        已注册的教师数
           int teacherUserCount =  userDao.getCount("teacher");
   //        已注册的公司数
           int companyUserCount =  userDao.getCount("company");
   //        已参加实习计划的学生数
           int planStudentCount = planStudentDao.getCount();
   //        已参加实习岗位的学生数
           int jobStudentCount = jobStudentDao.getCount();
           HashMap<String,Object> count = new HashMap<>();
           count.put("studentUserCount",studentUserCount);
           count.put("teacherUserCount",teacherUserCount);
           count.put("companyUserCount",companyUserCount);
           count.put("studentCount",studentCount);
           count.put("planStudentCount",planStudentCount);
           count.put("jobStudentCount",jobStudentCount);
           return ResponseResult.success(count);
       }
   
       @Override
       public ResponseResult getStudentProfessionalMap() {
           HashMap<String,Object> data = new HashMap<>();
           List<HashMap<String,Object>> map = planDao.getStudentProfessionalMap();
           List<String> legend = new ArrayList<>();
           for (HashMap<String, Object> stringObjectHashMap : map) {
               legend.add(stringObjectHashMap.get("name").toString());
           }
           data.put("legend",legend);
           data.put("result",map);
           return ResponseResult.success(data);
       }
   
       @Override
       public ResponseResult getStudentPlanMap() {
           HashMap<String,Object> data = new HashMap<>();
           List<HashMap<String,Object>> map = planDao.getStudentPlanMap();
           List<String> legend = new ArrayList<>();
           for (HashMap<String, Object> stringObjectHashMap : map) {
               legend.add(stringObjectHashMap.get("name").toString());
           }
           data.put("legend",legend);
           data.put("result",map);
           return ResponseResult.success(data);
       }
   
       @Override
       public ResponseResult getStudentJobMap() {
           HashMap<String,Object> data = new HashMap<>();
           List<HashMap<String,Object>> map = planDao.getStudentJobMap();
           List<String> legend = new ArrayList<>();
           for (HashMap<String, Object> stringObjectHashMap : map) {
               legend.add(stringObjectHashMap.get("name").toString());
           }
           data.put("legend",legend);
           data.put("result",map);
           return ResponseResult.success(data);
       }
   }
   
   

3. 持久层

   持久层负责与数据库交互，mybatis正是在这一层发挥其作用，通过其ORM框架的能力连接起java代码和数据库SQL执行，示例代码如下

   package com.crk.shixiguanli.dao;
   
   import com.crk.shixiguanli.entity.Plan;
   import org.apache.ibatis.annotations.Param;
   import org.springframework.stereotype.Repository;
   
   import java.util.HashMap;
   import java.util.List;
   
   @Repository
   public interface PlanDao {
       /**
        * This method was generated by MyBatis Generator.
        * This method corresponds to the database table plan
        *
        * @mbg.generated
        */
       int deleteByPrimaryKey(Integer id);
   
       /**
        * This method was generated by MyBatis Generator.
        * This method corresponds to the database table plan
        *
        * @mbg.generated
        */
       int insert(Plan record);
   
       /**
        * This method was generated by MyBatis Generator.
        * This method corresponds to the database table plan
        *
        * @mbg.generated
        */
       Plan selectByPrimaryKey(Integer id);
   
       /**
        * This method was generated by MyBatis Generator.
        * This method corresponds to the database table plan
        *
        * @mbg.generated
        */
       List<Plan> selectAll();
   
       /**
        * This method was generated by MyBatis Generator.
        * This method corresponds to the database table plan
        *
        * @mbg.generated
        */
       int updateByPrimaryKey(Plan record);
   
       int countByCondition(@Param("creator") int creator);
   
       List<Plan> selectByCondition(@Param("creator") int creator, @Param("start") int start, @Param("end") int end);
   
   
       /**
        * 根据专业查询计划
        * @param professional
        * @return
        */
       List<Plan> selectByProfession(@Param("professional") String professional);
   
   
       List<HashMap<String,Object>>  getStudentProfessionalMap();
   
       List<HashMap<String,Object>>  getStudentPlanMap();
   
   
       List<HashMap<String,Object>>  getStudentJobMap();
   }
   

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.crk.shixiguanli.dao.PlanDao">
     <resultMap id="BaseResultMap" type="com.crk.shixiguanli.entity.Plan">
       <!--
         WARNING - @mbg.generated
         This element is automatically generated by MyBatis Generator, do not modify.
       -->
       <id column="id" jdbcType="INTEGER" property="id" />
       <result column="plan_name" jdbcType="VARCHAR" property="planName" />
       <result column="plan_desc" jdbcType="VARCHAR" property="planDesc" />
       <result column="join_people" jdbcType="VARCHAR" property="joinPeople" />
       <result column="evaluation_criterion" jdbcType="VARCHAR" property="evaluationCriterion" />
       <result column="start_time" jdbcType="TIMESTAMP" property="startTime" />
       <result column="end_time" jdbcType="TIMESTAMP" property="endTime" />
       <result column="status" jdbcType="INTEGER" property="status" />
       <result column="creator" jdbcType="INTEGER" property="creator" />
       <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
       <result column="updater" jdbcType="INTEGER" property="updater" />
       <result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
     </resultMap>
     <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
       <!--
         WARNING - @mbg.generated
         This element is automatically generated by MyBatis Generator, do not modify.
       -->
       delete from plan
       where id = #{id,jdbcType=INTEGER}
     </delete>
     <insert id="insert" parameterType="com.crk.shixiguanli.entity.Plan">
       <!--
         WARNING - @mbg.generated
         This element is automatically generated by MyBatis Generator, do not modify.
       -->
       <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
         SELECT LAST_INSERT_ID()
       </selectKey>
       insert into plan (plan_name, plan_desc,
         join_people, evaluation_criterion, start_time, 
         end_time, `status`, creator, 
         create_time, updater, update_time
         )
       values (#{planName,jdbcType=VARCHAR}, #{planDesc,jdbcType=VARCHAR},
         #{joinPeople,jdbcType=VARCHAR}, #{evaluationCriterion,jdbcType=VARCHAR}, #{startTime,jdbcType=TIMESTAMP}, 
         #{endTime,jdbcType=TIMESTAMP}, #{status,jdbcType=INTEGER}, #{creator,jdbcType=INTEGER}, 
         #{createTime,jdbcType=TIMESTAMP}, #{updater,jdbcType=INTEGER}, #{updateTime,jdbcType=TIMESTAMP}
         )
     </insert>
     <update id="updateByPrimaryKey" parameterType="com.crk.shixiguanli.entity.Plan">
       <!--
         WARNING - @mbg.generated
         This element is automatically generated by MyBatis Generator, do not modify.
       -->
       update plan
       set plan_name = #{planName,jdbcType=VARCHAR},
         plan_desc = #{planDesc,jdbcType=VARCHAR},
         join_people = #{joinPeople,jdbcType=VARCHAR},
         evaluation_criterion = #{evaluationCriterion,jdbcType=VARCHAR},
         start_time = #{startTime,jdbcType=TIMESTAMP},
         end_time = #{endTime,jdbcType=TIMESTAMP},
         updater = #{updater,jdbcType=INTEGER},
         update_time = #{updateTime,jdbcType=TIMESTAMP}
       where id = #{id,jdbcType=INTEGER}
     </update>
     <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
       <!--
         WARNING - @mbg.generated
         This element is automatically generated by MyBatis Generator, do not modify.
       -->
       select id, plan_name, plan_desc, join_people, evaluation_criterion, start_time,
       end_time, `status`, creator, create_time, updater, update_time
       from plan
       where id = #{id,jdbcType=INTEGER}
     </select>
     <select id="selectAll" resultMap="BaseResultMap">
       <!--
         WARNING - @mbg.generated
         This element is automatically generated by MyBatis Generator, do not modify.
       -->
       select id, plan_name, plan_desc, join_people, evaluation_criterion, start_time,
       end_time,
       case when end_time &gt; now() then 2
       else status end as status
       , creator, create_time, updater, update_time
       from plan
       order by update_time desc
     </select>
   
   
     <select id="countByCondition" resultType="java.lang.Integer">
       select count(*) from plan where 1=1
       <if test="creator != null and creator != ''">
         and creator = #{creator}
       </if>
     </select>
   
   
     <select id="selectByCondition" resultMap="BaseResultMap">
       select * from plan
       where 1=1
       <if test="creator != null and creator != ''">
         and creator = #{creator}
       </if>
       order by update_time desc
       limit #{start},#{end}
     </select>
   
   
     <select id="countByStudent" resultType="java.lang.Integer">
         select count(p.*) from plan p left join plan_student s on p.id = s.plan_id
         where s.student_id = #{studentId}
     </select>
   
     <select id="selectByProfession" resultMap="BaseResultMap">
         select p.id, p.plan_name, p.plan_desc, p.join_people, p.evaluation_criterion, p.start_time,
                p.end_time,case when end_time &gt; now() then 2
                         else status end as status from plan p
         where (p.join_people = -1 or p.join_people like concat('%',#{professional},'%'))
         order by p.update_time desc
         limit #{start},#{end}
     </select>
   
   
     <select id="getStudentProfessionalMap" resultType="java.util.HashMap">
         select any_value(professional) as name, count(id) as value from student group by professional
     </select>
   
     <select id="getStudentPlanMap" resultType="java.util.HashMap">
         select '已参与实习' as name,count(s.id) as value from student s left join sys_user su on s.id_card = su.id_card
          left join plan_student p on p.student_id = su.id where  p.id is not null
         union
         select '未参与实习' as name,count(s.id) as value from student s left join sys_user su on s.id_card = su.id_card
          left join plan_student p on p.student_id = su.id  where p.id is  null
     </select>
   
     <select id="getStudentJobMap" resultType="java.util.HashMap">
         select '已加入岗位' as name,count(s.id) as value from student s left join sys_user su on s.id_card = su.id_card
          left join job_student p on p.student_id = su.id
         where p.id is not null
         union
         select '未加入岗位' as name,count(s.id) as value from student s left join sys_user su on s.id_card = su.id_card
          left join job_student p on p.student_id = su.id
         where p.id is  null
     </select>
   
   </mapper>
   

操作指引

1. 管理员操作

   • 管理员使用默认的管理员账号密码登录系统（admin/12345）

   

   • 录入学院信息

   

   • 录入专业信息

   

   • 录入学生信息

     

   • 统计分析

   

   

2. 学生操作

   • 学生注册

   

   • 学生登录

   

   • 查看实习计划列表并选择加入

   

   • 我的实习计划

   

   • 查看实习岗位列表并选择加入

   

   • 我参加的实习岗位

   

   • 其他功能

   

3. 教师操作

   • 教师注册

     

   • 教师登陆

   

   • 查看实习岗位列表

     

   • 发布实习计划

   

   • 实习评价

   

4. 企业操作

   • 企业注册

   

   • 企业登陆

   

   • 查看实习计划列表

   

   • 发布实习岗位

   

   • 发布岗位任务
   • 评价岗位任务完成情况

   

演示视频

演示视频下载地址

作者唯一联系方式