Java项目：ssh实验室预约管理系统

最新推荐文章于 2023-12-15 14:21:50 发布

夜未央5788

最新推荐文章于 2023-12-15 14:21:50 发布

阅读量203

点赞数

CC 4.0 BY-SA版权

分类专栏： SSH 文章标签： java jvm servlet

本文链接：https://blog.youkuaiyun.com/hanyunlong1989/article/details/127208873

SSH 专栏收录该内容

114 篇文章

订阅专栏

该系统支持管理员、教师和学生三类用户进行实验室预约管理。管理员可管理用户和实验室信息，发布通知；教师能预约实验室，发布任务；学生则可预约实验室并上传实验报告。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

作者主页：夜未央5788

简介：Java领域优质创作者、Java项目、学习资料、技术互助

文末获取源码

实验室预约管理系统

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。
2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA;
3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可
4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS；
5.数据库：MySql 5.7版本；
6.是否Maven项目: 否；

技术栈：

1. 后端：Spring,springMvc,Structs,Hibernate
2. 前端：JSP+css+javascript+AJax

运行说明：

1. 使用Navicat或者其它工具，在MySQL数据库中创建数据库，数据库名称建议为laboratory(可自定义),导入lrms.sql；
2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;
若为maven项目，导入成功后请执行maven clean;maven install命令，然后运行；
3. 将项目中ApplicationContext.xml配置文件中的数据库配置改为自己的配置;
4. 运行项目，在浏览器中输入http://localhost:8080/ 登录

详细介绍

本系统的用户可以分为三种：管理员、教师、学生。以下针对三种用户分别描述其功能需求。
## 1.管理员功能需求描述
以下是管理员的功能需求：

（1）登录：管理员在登录界面输入自己的账号密码(默认是：gly123)后，即可登录系统进行相关的操作。

（2）管理用户：管理员可以管理用户信息。查看用户、删除用户。

（3）重置密码

（4）发布公告：发布重要通知,用户登录系统之后即可看到公告列表。

（5）管理实验室：管理员可以管理实验室信息。新增、修改、删除（包括名称、地点、设备台数(即总人数)等）。

备注：由于显示默认的排期表需要，id为1的实验室永久不可删除。

（6）查看实验室预约情况：管理员可以查看所有预约信息如实验室是否被预约，被谁预约，预约时间，预约人数等。

（7）高级搜索：管理员输入搜索关键字（如实验室地点，预约区间，预约用户），即可查看详细的预约情况。

（8）查看排期表：选择某个实验室，可以查看其未来15天每天仍可被预约的人数。

（9）退出登录
## 2.教师功能需求描述
以下是教师的功能需求：
备注：该系统用户不可以注册，只能由运维人员在数据库中添加用户，这样可以避免校外人士注册该系统造成不必要的资源浪费。
教师无需注册，系统默认与其他教学系统的数据库连接，默认用户名为教职工号，密码为“js123456”，教师第一次登陆之后重置密码可以保证用户权限。

（1）登录：教师在初始界面输入职工号，密码，即可登录预约系统进行后续操作

（2）重置密码

（3）查看公告：登陆成功后在系统主界面可以查看管理员发布的所有公告，公告列按照创建时间倒序排列。

（4）查看个人信息：教师可以查看个人信息（用户名、学院、专业等）

（5）查看实验室列表：教师可以查看实验室的详细信息

（6）预约：分为个人预约和课堂预约

个人预约：教师选择实验室，选择日期，选择时间区间，选择人数即可。此时最多可以预约10个位置,且该实验室剩余的位置还可以被其他学生预约,但是不能被课堂预约。

课堂预约：教师选择预约日期段，选择每周几，选择预约时间段、指定课堂、输入相应的描述信息即可完成预约。此时无论实验室是否被预约满，该时间段都不可以被再预约。

（7）查看排期表：选择某个实验室，可以查看其未来15天每天仍可被预约的人数。

（8）高级搜索：教师输入搜索关键字（如实验室地点，预约区间，选择预约类别，选择课堂），即可查看详细的预约情况。

（9）管理预约信息：教师可以查看自己预约的信息、可取消预约前提是预约日期是当天之后。
注：已经超出预约时间的预约信息不能删除

（10）管理课堂信息：教师可以新增、修改、删除课堂信息。
注：该课堂若已经存在，不可再次添加。

（11）导入导出学生名册：教师可以针对某一课堂导入导出学生名册，但是要按照固定的excel模板。

（12）发布课堂任务：教师可以针对某一课堂发布任务，该课堂的学生可以看到该课堂作业通知信息

（13）上传文件：教师可以上传实验资料等

（14）查看学生作业：教师可以下载或者在线预览学生实验报告

（15）评分和评价

（16）退出登录
## 3.学生功能需求描述
学生的功能需求主要包括以下几种：
备注：学生无需注册，系统默认与其他教学系统的数据库连接，默认用户名为学号，密码为“xs123456”，学生第一次登陆之后重置密码即可以保证用户权限。

（1）登录

（2）重置密码：当学生忘记密码或者想要重置密码，可以重置自己的密码。

（3）查看公告：登陆成功后在系统主界面可以查看管理员发布的所有公告，公告列按照创建时间倒序排列。

（4）查看个人信息：学生可以查看个人信息（用户名、学院、专业等）

（5）查看实验室列表：学生可以查看实验室的详细信息

（6）预约：默认是个人预约，学生不能进行课堂预约
个人预约：学生选择实验室，选择日期，时间区间，选择人数即可。此时最多可以预约10个位置,且该实验室剩余的位置还可以被其他学生预约,但是不能被课堂预约。

（7）查看排期表：选择某个实验室，可以查看其未来15天每天仍可被预约的人数。

（8）管理预约信息：学生可以查看自己预约的信息、可取消预约前提是预约日期是当天之后。
注：已经超出预约时间的预约信息不能删除
学生还可以查看所在课堂的预约信息，只能看到课堂名称、预约日期、预约区间，此时不能取消预约，只能由该课堂的教师取消预约。

（9）高级搜索：学生输入搜索关键字（如实验室地点，预约区间，选择课堂），即可查看详细的预约情况。

（10）查看课堂任务：若学生的课程A预约了实验室，则教师A发布课堂任务后，学生可以看到任务，若没有预约则看不到公告

（11）上传实验报告：前提是课程A已预约实验室，可以上传文件并且可以写说明

（12）下载实验报告：可以下载以及上传的实验报告

（13）查看分数：每次上传作业之后，可以看到教师的评语和分数以及期末总的实验分数

（14）退出登录

运行截图

相关代码

CourseController

package controller;

import java.text.ParseException;
import java.util.List;

import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import other.ExecResult;
import entity.Course;
import service.CourseService;

@Controller
public class CourseController {
	@Autowired
	private CourseService courseService;

	@RequestMapping("courseList")
	public ModelAndView getAllCourse(int user_id){
		ModelAndView view=new ModelAndView("courseList");
		List<Course> courseList=courseService.getAllCourse(user_id);
		view.addObject("courseList",courseList);
		return view;
	}
	
	@RequestMapping("addCourse")
	@ResponseBody
	public ExecResult addCourse(Course course,HttpSession session) throws ParseException{
		ExecResult er=new ExecResult();
		int result=courseService.addCourse(course);
		if(result==3){
			er.setMsg("您已经有该课程，请勿重复添加！");
			er.setSuccess(false);
		}
		else{
			if(result>0){
				er.setMsg("添加成功");
				er.setSuccess(true);
			}
			else{
				er.setMsg("添加失败");
				er.setSuccess(false);
			}
		}
		return er;
		}
	
	
	@RequestMapping("getCourseById")
	public ModelAndView getCourseById(int course_id,HttpSession session){
		ModelAndView view=new ModelAndView("updateCourse");
		Course course=courseService.getCourseById(course_id);
		view.addObject("course",course);
		return view;
	}
	
	@RequestMapping("updateCourse")
	@ResponseBody
	public ExecResult updateCourse(Course course,HttpSession session){
		ExecResult er=new ExecResult();
		boolean isUpdate=courseService.updateCourse(course);
		if(isUpdate){
			er.setMsg("更新成功");
			er.setSuccess(true);
		}
		else{
			er.setMsg("更新失败");
			er.setSuccess(false);
		}
		return er;
	}
	
	@RequestMapping("deleteCourse")
	@ResponseBody
	public ExecResult deleteCourse(int course_id,HttpSession session){
		ExecResult er=new ExecResult();
		boolean isDel=courseService.deleteCourse(course_id);
		if(isDel){
			er.setMsg("删除成功");
			er.setSuccess(true);
		}
		else{
			er.setMsg("删除失败");
			er.setSuccess(false);
		}
		return er;
	}
}

LaboratoryController

package controller;


import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import other.ExecResult;
import entity.Laboratory;
import entity.User;
import service.LaboratoryService;

@Controller
public class LaboratoryController {
	
	@Autowired
	private LaboratoryService laboratoryService;

	@RequestMapping("addLab")
	@ResponseBody
	public ExecResult addLab(Laboratory laboratory,HttpSession session,HttpServletRequest request){
		ExecResult er=new ExecResult();
//		System.out.println("LaboratoryController - addLab");
//		System.out.println(request.getParameter("description"));
		int result=(int)laboratoryService.addLab(laboratory);
		if(result>0){
			er.setMsg("新增成功");
			er.setSuccess(true);
		}
		else{
			er.setMsg("新增失败");
			er.setSuccess(false);
		}
		return er;
	}	
	
	@RequestMapping("labList")
	public ModelAndView getAllLab(){
		ModelAndView view=new ModelAndView("labList");
		List<Laboratory> labList=laboratoryService.getAllLab();
		view.addObject("labList",labList);
		return view;
	}
	@RequestMapping("reserveLabList")
	public ModelAndView getreserveLabList(){
		ModelAndView view=new ModelAndView("reserveLabList");
		List<Laboratory> labList=laboratoryService.getAllLab();
		view.addObject("labList",labList);
		return view;
	}
	
	@RequestMapping("deleteLab")
	@ResponseBody
	public ExecResult deleteLab(Laboratory laboratory,HttpSession session){
		ExecResult er=new ExecResult();
		if(laboratory.getLab_id()==1){
			er.setMsg("该实验室被限制为永久不能删除！");
			er.setSuccess(false);
		}
		else{
			boolean isDel=laboratoryService.delLab(laboratory);
			if(isDel){
				er.setMsg("删除成功");
				er.setSuccess(true);
			}
			else{
				er.setMsg("删除失败");
				er.setSuccess(false);
			}
		}
		return er;
	}
	
	@RequestMapping("getLabById")
	public ModelAndView getLabById(Laboratory laboratory,HttpSession session){
		ModelAndView view=new ModelAndView("updateLab");
		Laboratory lab=laboratoryService.getLabById(laboratory);
		view.addObject("lab",lab);
		return view;
	}
	
	@RequestMapping("updateLab")
	@ResponseBody
	public ExecResult updateLab(Laboratory laboratory,HttpSession session){
		ExecResult er=new ExecResult();
		boolean isUpdate=laboratoryService.updateLab(laboratory);
		if(isUpdate){
			er.setMsg("更新成功");
			er.setSuccess(true);
		}
		else{
			er.setMsg("更新失败");
			er.setSuccess(false);
		}
		return er;
	}
	
	
	/*@RequestMapping("updateLab")
	@ResponseBody
	public ExecResult updateLab(User user,HttpSession session){
		ExecResult er=new ExecResult();
		boolean isupdate=userService.update(user);
		if(isupdate){
			er.setMsg("恭喜亲，你是第一个密码修改成功的人哟！");
			er.setSuccess(true);
		}
		else{
			er.setMsg("修改失败，亲，不要伤心，下次还可以修改");
			er.setSuccess(false);
		}
		return er;
	}*/
	
}

ReserveController

package controller;




import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import other.ExecResult;
import entity.Announcement;
import entity.Course;
import entity.Laboratory;
import entity.Reservation;
import entity.Term;
import entity.lab_reservation;
import entity.lab_schedule;
import entity.user_lab_reservation;
import service.LaboratoryService;
import service.ReserveLaboratoryService;
import service.UserService;

import org.apache.commons.lang.StringUtils;

@Controller
public class ReserveController {
	
	@Autowired
	private ReserveLaboratoryService reserveLaboratoryService;
	@Autowired
	private LaboratoryService laboratoryService;
	@Autowired
	private UserService userService;

	@RequestMapping("getLabReserveById")
	public ModelAndView getLabReserveById(HttpServletRequest request,HttpSession session){
		ModelAndView view=new ModelAndView("reservation");
		int lab_id=Integer.parseInt(request.getParameter("lab_id"));
		int user_id=Integer.parseInt(request.getParameter("user_id"));
		List<lab_reservation> lab_reservation_list=reserveLaboratoryService.getLab_reservations(lab_id);
		view.addObject("lab_reservation_list",lab_reservation_list);
		view.addObject("lab_id", lab_id);
		
		List<Term> termList=userService.getTermList();
		view.addObject("termList",termList);
		
		List<Course> courseList=userService.getCourseList(user_id);
		view.addObject("courseList",courseList);
		
		return view;
	}
	
	@RequestMapping("reserveLab")
	@ResponseBody
	public ExecResult reserveLab(HttpSession session,HttpServletRequest request) throws ParseException{
		ExecResult er=new ExecResult();
		System.out.println("LaboratoryController - addLab");
		Reservation reservation=new Reservation();
		
		if(StringUtils.isNotBlank(request.getParameter("course_id"))){
			reservation.setCourse_id(Integer.parseInt(request.getParameter("course_id")));
		}
		if(StringUtils.isNotBlank(request.getParameter("lab_id"))){
			reservation.setLab_id(Integer.parseInt(request.getParameter("lab_id")));
		}
		if(StringUtils.isNotBlank(request.getParameter("user_id"))){
			reservation.setUser_id(Integer.parseInt(request.getParameter("user_id")));
		}
		if(StringUtils.isNotBlank(request.getParameter("reserve_type"))){
			reservation.setReserve_type(Integer.parseInt(request.getParameter("reserve_type")));
		}
		if(StringUtils.isNotBlank(request.getParameter("time_interval"))){
			reservation.setTime_interval(Integer.parseInt(request.getParameter("time_interval")));
		}
		if(StringUtils.isNotBlank(request.getParameter("weekday"))){
			reservation.setWeekday(Integer.parseInt(request.getParameter("weekday")));
		}
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
	    Date create_time = sdf.parse(request.getParameter("create_time"));
	    reservation.setCreate_time(create_time);
	    
	    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");  
	    if(Integer.parseInt(request.getParameter("reserve_type"))==1){
		    if(StringUtils.isNotBlank(request.getParameter("person_number"))){
				reservation.setPerson_number(Integer.parseInt(request.getParameter("person_number")));
			}
		    Date reserve_date =(Date)sdf1.parse(request.getParameter("reserve_date"));
		    reservation.setReserve_date(reserve_date);
	    }
	    else{
	    	if(StringUtils.isNotBlank(request.getParameter("person_number2"))){
				reservation.setPerson_number(Integer.parseInt(request.getParameter("person_number2")));
			}
		    Date reserve_date = sdf1.parse(request.getParameter("reserve_date2"));
		    reservation.setReserve_date(reserve_date);
	    }
		
		if(StringUtils.isNotBlank(request.getParameter("modify_time"))){
			Date modify_time = sdf.parse(request.getParameter("modify_time"));
			reservation.setModify_time(modify_time);
		}
		if(StringUtils.isNotBlank(request.getParameter("courseName"))){
			reservation.setCourseName(request.getParameter("courseName"));
		}
		if(StringUtils.isNotBlank(request.getParameter("description"))){
			reservation.setDescription(request.getParameter("description"));
		}
		
		int result=(int)reserveLaboratoryService.reserveLab(reservation);
		if(result>0){
			er.setMsg("恭喜您，预约成功");
			er.setSuccess(true);
		}
		else{
			er.setMsg("实验室可供预约人数不够");
			er.setSuccess(false);
		}
		return er;
	}	
	
	@RequestMapping("schedule_table")
	public ModelAndView schedule_table(HttpServletRequest request,HttpSession session){
		ModelAndView view=new ModelAndView("schedule_table");
		int lab_id=Integer.parseInt(request.getParameter("lab_id"));
		List<lab_schedule> list=reserveLaboratoryService.getSchedule_table(lab_id);
		List<Laboratory> labList=laboratoryService.getAllLab();
		view.addObject("labList",labList);
		view.addObject("list",list);
		return view;
	}
	
	//显示某个用户所有预约信息列表
	@RequestMapping("reservationByUser")
	public ModelAndView reservationByUser(HttpServletRequest request,HttpSession session){
		ModelAndView view=new ModelAndView("manage_reservation_info");
		int user_id=Integer.parseInt(request.getParameter("user_id"));
		int user_type=Integer.parseInt(request.getParameter("user_type"));
		List<lab_reservation> list=reserveLaboratoryService.reservationByUser(user_id);
		view.addObject("list",list);
		
		if(user_type==2){//获得属于该学生所在课堂的预约信息
			List<lab_reservation> list2=reserveLaboratoryService.ReservationTeacherForStudent(user_id);
			view.addObject("list2",list2);
		}
		return view;
	}
	
	/*//显示某个用户某条预约信息，并显示在update_reservation页面中
	@RequestMapping("single_reservation_info")
	public ModelAndView single_reservation_info(HttpServletRequest request,HttpSession session){
		ModelAndView view=new ModelAndView("update_reservation");
		int reserve_id=Integer.parseInt(request.getParameter("reserve_id"));
		lab_reservation lab_reservation=reserveLaboratoryService.single_reservation_info(reserve_id);
		view.addObject("lab_reservation",lab_reservation);
		return view;
	}*/
	
	
	@RequestMapping("deleteReservation")
	@ResponseBody
	public ExecResult deleteReservation(HttpSession session,HttpServletRequest request) {
		ExecResult er=new ExecResult();
		int reserve_id=Integer.parseInt(request.getParameter("reserve_id"));
		int result=(int)reserveLaboratoryService.deleteReservation(reserve_id);
		if(result>0){
			er.setMsg("恭喜您，成功取消预约");
			er.setSuccess(true);
		}
		else{
			er.setMsg("取消预约失败");
			er.setSuccess(false);
		}
		return er;
	}
	
	//课堂预约
	@RequestMapping("reserveLab2")
	@ResponseBody
	public ExecResult reserveLab2(HttpSession session,HttpServletRequest request) throws ParseException{
		ExecResult er=new ExecResult();
		int result=0;
		Reservation reservation=new Reservation();
		if(StringUtils.isNotBlank(request.getParameter("lab_id"))){
			reservation.setLab_id(Integer.parseInt(request.getParameter("lab_id")));
		}
		if(StringUtils.isNotBlank(request.getParameter("user_id"))){
			reservation.setUser_id(Integer.parseInt(request.getParameter("user_id")));
		}
		if(StringUtils.isNotBlank(request.getParameter("reserve_type"))){
			reservation.setReserve_type(Integer.parseInt(request.getParameter("reserve_type")));
		}
		if(StringUtils.isNotBlank(request.getParameter("course_id"))){
			reservation.setCourse_id(Integer.parseInt(request.getParameter("course_id")));
		}
		if(StringUtils.isNotBlank(request.getParameter("time_interval"))){
			reservation.setTime_interval(Integer.parseInt(request.getParameter("time_interval")));
		}
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
	    Date create_time = sdf.parse(request.getParameter("create_time"));
	    reservation.setCreate_time(create_time);
	    if(StringUtils.isNotBlank(request.getParameter("modify_time"))){
			Date modify_time = sdf.parse(request.getParameter("modify_time"));
			reservation.setModify_time(modify_time);
		}
	    if(StringUtils.isNotBlank(request.getParameter("description"))){
			reservation.setDescription(request.getParameter("description"));
	    }
	    
	    if(StringUtils.isNotBlank(request.getParameter("from"))&&StringUtils.isNotBlank(request.getParameter("end"))){
			String from=request.getParameter("from");
			String end=request.getParameter("end");
			int year1=Integer.parseInt(from.substring(0, 4));
			int month1=Integer.parseInt(from.substring(5, 7));
			int day1=Integer.parseInt(from.substring(8, 10));
			int year2=Integer.parseInt(end.substring(0, 4));
			int month2=Integer.parseInt(end.substring(5, 7));
			int day2=Integer.parseInt(end.substring(8, 10));
			if(StringUtils.isNotBlank(request.getParameter("weekday"))){
				int weekday=Integer.parseInt(request.getParameter("weekday"));
				Calendar calendar = new GregorianCalendar();//定义一个日历，变量作为年初
			   	Calendar calendarEnd = new GregorianCalendar();//定义一个日历，变量作为年末
			    calendar.set(Calendar.YEAR, year1);
			   	calendar.set(Calendar.MONTH, month1-1);
			   	calendar.set(Calendar.DAY_OF_MONTH, day1-1);//设置年初的日期为1月1日
			   	calendarEnd.set(Calendar.YEAR, year2);
			   	calendarEnd.set(Calendar.MONTH, month2-1);
			   	calendarEnd.set(Calendar.DAY_OF_MONTH, day2-1);//设置年末的日期为12月31日
			   	   
			   	SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
			   	while(calendar.getTime().getTime()<=calendarEnd.getTime().getTime()){//用日期区间循环
				   	if(calendar.get(Calendar.DAY_OF_WEEK)==weekday+1){//判断如果为weekday时
				   		String date1=sf.format(calendar.getTime());
				   		Date date2=sf.parse(date1);
				   		reservation.setReserve_date(date2);
				   		reservation.setWeekday(weekday);
				   		result=reserveLaboratoryService.reserveLab(reservation);
				   	}
				   	calendar.add(Calendar.DAY_OF_MONTH, 1);//日期+1
			   	}
			}
		}
		if(result>0){
			er.setMsg("恭喜您，预约成功");
			er.setSuccess(true);
		}
		else{
			er.setMsg("实验室可供预约人数不够，请调整预约区间或课堂");
			er.setSuccess(false);
		}
		return er;
	}
	
	//高级搜索，根据用户、预约类别、预约期间等模糊搜索
	@RequestMapping("selectReservation")
	public ModelAndView selectReservation(HttpServletRequest request,HttpSession session){
		ModelAndView view=new ModelAndView("selectReservation");
		int user_type=0; 
		String user_name=null;
		int reserve_type=0;
		String from=null;
		String end=null;
		int user_id=Integer.parseInt(request.getParameter("user_id"));
		if(StringUtils.isNotBlank(request.getParameter("user_type"))){
			user_type=Integer.parseInt(request.getParameter("user_type"));
		}
		if(StringUtils.isNotBlank(request.getParameter("user_name"))){
			user_name=request.getParameter("user_name");
		}
		if(StringUtils.isNotBlank(request.getParameter("reserve_type"))){
			reserve_type=Integer.parseInt(request.getParameter("reserve_type"));
		}
		if(StringUtils.isNotBlank(request.getParameter("from"))){
			from=request.getParameter("from");
		}
		if(StringUtils.isNotBlank(request.getParameter("end"))){
			end=request.getParameter("end");
		}
		System.out.println("bjhed");
		List<user_lab_reservation> list=reserveLaboratoryService.selectReservation(user_id,user_type,user_name,reserve_type,from,end);
		view.addObject("list1",list);
		return view;
	}
	
}

如果也想学习本系统，下面领取。关注并回复：006ssh