SpringBoot+Vue实现前后端分离的实习管理系统

发布时间：2022-09-19 05:30

文末获取源码

开发语言：Java
开发工具：IDEA /Eclipse
数据库：MYSQL5.7/8.0
应用服务：Tomcat7/Tomcat8
是否Maven项目：是
后端框架：SpringBoot
前端框架：vue+element等
JDK版本：jdk1.8
项目架构：B/S架构

前言介绍

本次设计任务是要设计一个实习管理系统，通过这个系统能够满足实习管理及用户的管理功能。系统的主要功能包括首页，个人中心，班级管理，学生管理，教师管理，实习单位管理，实习作业管理，教师评分管理，单位成绩管理，系统管理等。

管理员可以根据系统给定的账号进行登录，登录后可以进入实习管理系统对所有模块进行管理。包括查看和修改自己的个人信息以及登录密码。

该系统为每一个用户都分配了一个用户账号，用户通过账号的登录可以在系统中查看实习管理信息及对个人信息进行修改等功能。

总体设计

根据实习管理系统的功能需求，进行系统设计。

前台功能：用户进入系统可以实现首页，系统公告，个人中心，后台管理等功能进行操作；

后台由管理员，实习单位，教师和学生，主要功能包括首页，个人中心，班级管理，学生管理，教师管理，实习单位管理，实习作业管理，教师评分管理，单位成绩管理，系统管理等功能；

系统对这些功能进行整合，产生的功能结构图如下：

SpringBoot+Vue实现前后端分离的实习管理系统_第1张图片

前台功能模块 

实习管理系统，用户进入到系统首页，可以查看首页，系统公告，个人中心，后台管理等内容进行操作，如图

SpringBoot+Vue实现前后端分离的实习管理系统_第2张图片

学生注册

在学生注册页面中输入学生学号，学生姓名，密码，确认密码，年级，联系电话，院系，专业等内容进行用户注册操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第3张图片

个人中心

在个人中心页面中输入学生学号，学生姓名，密码，年级，班级，性别，联系电话，院系，专业等内容进行更新信息，如图 

  SpringBoot+Vue实现前后端分离的实习管理系统_第4张图片

后台功能模块 

后台用户登录，通过填写注册时输入的用户名、密码、选择角色等信息进行登录操作，如图

SpringBoot+Vue实现前后端分离的实习管理系统_第5张图片 

管理员功能

管理员登录进入实习管理系统可以查看首页，个人中心，班级管理，学生管理，教师管理，实习单位管理，实习作业管理，教师评分管理，单位成绩管理，系统管理等功能进行详细操作，如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第6张图片 

班级管理

在班级管理页面中可以查看索引，班级等内容，并进行详情，修改和删除操作；如图

SpringBoot+Vue实现前后端分离的实习管理系统_第7张图片 

学生管理

在学生管理页面中可以查看索引，学生学号，学生姓名，年级，班级，性别，联系电话，院系，专业等内容，并进行详情，修改和删除操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第8张图片

教师管理

在教师管理页面中可以查看索引，教师工号，教师姓名，性别，职称，联系电话等内容，并进行详情，修改或删除操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第9张图片

实习单位管理

在实习单位管理页面中可以查看索引，单位名称，单位性质，地址，负责人，联系电话，邮箱，单位地址等内容，并进行详情，修改和删除操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第10张图片

教师评分管理

在教师评分管理页面中可以查看索引，单位名称，单位地址，教师工号，教师姓名，学生学号，学生姓名，实习评分，批改时间等内容，并进行详情，修改和删除操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第11张图片

教师功能 

教师登录进入实习管理系统可以查看首页，个人中心，实习作业管理，教师评分管理等功能进行详细操作，如图

SpringBoot+Vue实现前后端分离的实习管理系统_第12张图片

个人中心

在个人中心页面通过填写教师工号，教师姓名，性别，职称，联系电话等内容进行个人信息修改操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第13张图片

实习作业管理

在实习作业管理页面中可以查看索引，实习岗位，单位名称，单位地址，学生学号，学生姓名，班级，专业，院系，教师工号，教师姓名，实习时间，实习报告等内容，并进行详情或教师评分操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第14张图片

学生功能 

学生登录进入实习管理系统可以查看首页，个人中心，实习作业管理，教师评分管理单位成绩管理等功能进行详细操作，如图

SpringBoot+Vue实现前后端分离的实习管理系统_第15张图片

实习作业管理

在实习作业管理页面中可以查看索引，实习岗位，单位名称，单位地址，学生学号，学生姓名，班级，专业，院系，教师工号，教师姓名，实习时间，实习报告等内容，并进行详情，修改或删除操作；如图

SpringBoot+Vue实现前后端分离的实习管理系统_第16张图片 

单位成绩管理

在单位成绩管理页面中可以查看索引，学生学号，学生姓名，工作态度，任务完成率，工作积极性，考核结果，单位名称，提交时间等内容，并进行详情操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第17张图片

实习单位功能 

实习单位登录进入实习管理系统可以查看首页，个人中心，实习作业管理，单位成绩管理等功能进行详细操作，如图SpringBoot+Vue实现前后端分离的实习管理系统_第18张图片

个人中心

在个人中心页面通过填写单位名称，单位性质，地址，负责人，联系电话，邮箱，单位地址等内容进行个人信息修改操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第19张图片

实习作业管理

在实习作业管理页面中可以查看索引，实习岗位，单位名称，单位地址，学生学号，学生姓名，班级，专业，院系，教师工号，教师姓名，实习时间，实习报告等内容，并进行详情或单位成绩操作；如图 

SpringBoot+Vue实现前后端分离的实习管理系统_第20张图片

部分核心代码: 

教师

/**
 * 教师
 * 后端接口
 * @author 
 * @email 
 * @date 2022-02-22 12:29:31
 */
@RestController
@RequestMapping("/jiaoshi")
public class JiaoshiController {
    @Autowired
    private JiaoshiService jiaoshiService;


    
	@Autowired
	private TokenService tokenService;
	
	/**
	 * 登录
	 */
	@IgnoreAuth
	@RequestMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		JiaoshiEntity user = jiaoshiService.selectOne(new EntityWrapper().eq("jiaoshigonghao", username));
		if(user==null || !user.getMima().equals(password)) {
			return R.error("账号或密码不正确");
		}
		
		String token = tokenService.generateToken(user.getId(), username,"jiaoshi",  "管理员" );
		return R.ok().put("token", token);
	}
	
	/**
     * 注册
     */
	@IgnoreAuth
    @RequestMapping("/register")
    public R register(@RequestBody JiaoshiEntity jiaoshi){
    	//ValidatorUtils.validateEntity(jiaoshi);
    	JiaoshiEntity user = jiaoshiService.selectOne(new EntityWrapper().eq("jiaoshigonghao", jiaoshi.getJiaoshigonghao()));
		if(user!=null) {
			return R.error("注册用户已存在");
		}
		Long uId = new Date().getTime();
		jiaoshi.setId(uId);
        jiaoshiService.insert(jiaoshi);
        return R.ok();
    }

	
	/**
	 * 退出
	 */
	@RequestMapping("/logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}
	
	/**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
    	Long id = (Long)request.getSession().getAttribute("userId");
        JiaoshiEntity user = jiaoshiService.selectById(id);
        return R.ok().put("data", user);
    }
    
    /**
     * 密码重置
     */
    @IgnoreAuth
	@RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
    	JiaoshiEntity user = jiaoshiService.selectOne(new EntityWrapper().eq("jiaoshigonghao", username));
    	if(user==null) {
    		return R.error("账号不存在");
    	}
        user.setMima("123456");
        jiaoshiService.updateById(user);
        return R.ok("密码已重置为：123456");
    }


    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map params,JiaoshiEntity jiaoshi,
		HttpServletRequest request){
        EntityWrapper ew = new EntityWrapper();
		PageUtils page = jiaoshiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jiaoshi), params), params));

        return R.ok().put("data", page);
    }
    
    /**
     * 前端列表
     */
	@IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map params,JiaoshiEntity jiaoshi, 
		HttpServletRequest request){
        EntityWrapper ew = new EntityWrapper();
		PageUtils page = jiaoshiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, jiaoshi), params), params));
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/lists")
    public R list( JiaoshiEntity jiaoshi){
       	EntityWrapper ew = new EntityWrapper();
      	ew.allEq(MPUtil.allEQMapPre( jiaoshi, "jiaoshi")); 
        return R.ok().put("data", jiaoshiService.selectListView(ew));
    }

	 /**
     * 查询
     */
    @RequestMapping("/query")
    public R query(JiaoshiEntity jiaoshi){
        EntityWrapper< JiaoshiEntity> ew = new EntityWrapper< JiaoshiEntity>();
 		ew.allEq(MPUtil.allEQMapPre( jiaoshi, "jiaoshi")); 
		JiaoshiView jiaoshiView =  jiaoshiService.selectView(ew);
		return R.ok("查询教师成功").put("data", jiaoshiView);
    }
	
    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        JiaoshiEntity jiaoshi = jiaoshiService.selectById(id);
        return R.ok().put("data", jiaoshi);
    }

    /**
     * 前端详情
     */
	@IgnoreAuth
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id){
        JiaoshiEntity jiaoshi = jiaoshiService.selectById(id);
        return R.ok().put("data", jiaoshi);
    }
    



    /**
     * 后端保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody JiaoshiEntity jiaoshi, HttpServletRequest request){
    	jiaoshi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(jiaoshi);
    	JiaoshiEntity user = jiaoshiService.selectOne(new EntityWrapper().eq("jiaoshigonghao", jiaoshi.getJiaoshigonghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}
		jiaoshi.setId(new Date().getTime());
        jiaoshiService.insert(jiaoshi);
        return R.ok();
    }
    
    /**
     * 前端保存
     */
    @RequestMapping("/add")
    public R add(@RequestBody JiaoshiEntity jiaoshi, HttpServletRequest request){
    	jiaoshi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
    	//ValidatorUtils.validateEntity(jiaoshi);
    	JiaoshiEntity user = jiaoshiService.selectOne(new EntityWrapper().eq("jiaoshigonghao", jiaoshi.getJiaoshigonghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}
		jiaoshi.setId(new Date().getTime());
        jiaoshiService.insert(jiaoshi);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody JiaoshiEntity jiaoshi, HttpServletRequest request){
        //ValidatorUtils.validateEntity(jiaoshi);
        jiaoshiService.updateById(jiaoshi);//全部更新
        return R.ok();
    }
    

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        jiaoshiService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    
    /**
     * 提醒接口
     */
	@RequestMapping("/remind/{columnName}/{type}")
	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
						 @PathVariable("type") String type,@RequestParam Map map) {
		map.put("column", columnName);
		map.put("type", type);
		
		if(type.equals("2")) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Calendar c = Calendar.getInstance();
			Date remindStartDate = null;
			Date remindEndDate = null;
			if(map.get("remindstart")!=null) {
				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
				c.setTime(new Date()); 
				c.add(Calendar.DAY_OF_MONTH,remindStart);
				remindStartDate = c.getTime();
				map.put("remindstart", sdf.format(remindStartDate));
			}
			if(map.get("remindend")!=null) {
				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
				c.setTime(new Date());
				c.add(Calendar.DAY_OF_MONTH,remindEnd);
				remindEndDate = c.getTime();
				map.put("remindend", sdf.format(remindEndDate));
			}
		}
		
		Wrapper wrapper = new EntityWrapper();
		if(map.get("remindstart")!=null) {
			wrapper.ge(columnName, map.get("remindstart"));
		}
		if(map.get("remindend")!=null) {
			wrapper.le(columnName, map.get("remindend"));
		}


		int count = jiaoshiService.selectCount(wrapper);
		return R.ok().put("count", count);
	}
	







}

上传文件

/**
 * 上传文件映射表
 */
@RestController
@RequestMapping("file")
@SuppressWarnings({"unchecked","rawtypes"})
public class FileController{
	@Autowired
    private ConfigService configService;
	/**
	 * 上传文件
	 */
	@RequestMapping("/upload")
	public R upload(@RequestParam("file") MultipartFile file,String type) throws Exception {
		if (file.isEmpty()) {
			throw new EIException("上传文件不能为空");
		}
		String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
		File path = new File(ResourceUtils.getURL("classpath:static").getPath());
		if(!path.exists()) {
		    path = new File("");
		}
		File upload = new File(path.getAbsolutePath(),"/upload/");
		if(!upload.exists()) {
		    upload.mkdirs();
		}
		String fileName = new Date().getTime()+"."+fileExt;
		File dest = new File(upload.getAbsolutePath()+"/"+fileName);
		file.transferTo(dest);
		/**
  		 * 如果使用idea或者eclipse重启项目，发现之前上传的图片或者文件丢失，将下面一行代码注释打开
   		 * 请将以下的"D:\\springbootq33sd\\src\\main\\resources\\static\\upload"替换成你本地项目的upload路径，
 		 * 并且项目路径不能存在中文、空格等特殊字符
 		 */
//		FileUtils.copyFile(dest, new File("D:\\springbootq33sd\\src\\main\\resources\\static\\upload"+"/"+fileName)); /**修改了路径以后请将该行最前面的//注释去掉**/
		if(StringUtils.isNotBlank(type) && type.equals("1")) {
			ConfigEntity configEntity = configService.selectOne(new EntityWrapper().eq("name", "faceFile"));
			if(configEntity==null) {
				configEntity = new ConfigEntity();
				configEntity.setName("faceFile");
				configEntity.setValue(fileName);
			} else {
				configEntity.setValue(fileName);
			}
			configService.insertOrUpdate(configEntity);
		}
		return R.ok().put("file", fileName);
	}
	
	/**
	 * 下载文件
	 */
	@IgnoreAuth
	@RequestMapping("/download")
	public ResponseEntity download(@RequestParam String fileName) {
		try {
			File path = new File(ResourceUtils.getURL("classpath:static").getPath());
			if(!path.exists()) {
			    path = new File("");
			}
			File upload = new File(path.getAbsolutePath(),"/upload/");
			if(!upload.exists()) {
			    upload.mkdirs();
			}
			File file = new File(upload.getAbsolutePath()+"/"+fileName);
			if(file.exists()){
				/*if(!fileService.canRead(file, SessionManager.getSessionUser())){
					getResponse().sendError(403);
				}*/
				HttpHeaders headers = new HttpHeaders();
			    headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);    
			    headers.setContentDispositionFormData("attachment", fileName);    
			    return new ResponseEntity(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
	}
	
}

相关推荐

C++高并发内存池的实现

局域网攻击与网络设备安全配置

爬虫（9） - Scrapy框架(1) | Scrapy 异步网络爬虫框架

735. 行星碰撞 : 简单栈模拟运用题

Java数据结构之线段树的原理与实现

高并发系统中库存热点的解决方案

姿态估计mmpose一手体验 Ⅰ - 安装它！

SpringCloud使用集中配置组件Config规避信息泄露

OpenSSL SSL_read: Connection was reset, errno 10054

详解Java泛型中类型擦除问题的解决方法

Mysql体系化探讨令人头疼的JOIN运算

Elasticsearch深度应用（上） - 女友在高考 - 博客园

springcloud微服务(三十六)-sentinel基础知识

物联网跟人的神经网络相似通过各种信息传感设备

Python自动化办公：将文本文档内容批量分类导入Excel表格

Springboot自动配置与@Configuration配置类详解

python-opencv之人脸检测

用 async/await 来处理异步

Note -「因数的欧拉函数求和」

MATLAB图像基本变换实验报告,MATLAB图像增强与变换处理实验报告

ItVuer - 免责声明 - 关于我们 - 联系我们

本网站信息来源于互联网，如有侵权请联系：561261067@qq.com

桂ICP备16001015号