基于javaweb+mysql的springboot+jpa图书馆座位占座预约管理系统(管理员、老师、学生)(java+springboot+jpa+freemarker+mysql)

基于javaweb+mysql的springboot+jpa图书馆座位占座预约管理系统(管理员、老师、学生)(java+springboot+jpa+freemarker+mysql)

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

管理员：学生管理、教师管理、阅览室类型管理、阅览室管理（座位生成等）、学生信用积分管理、座位预约统计管理等。

学生：登录、修改个人信息、阅览室查看、选座信息查看、选座、取消选座等。

教师：登录、阅览室管理、学生信用管理：可根据学生表现进行扣分、奖励等，扣分达到设定的值则无法进行选座。

技术框架

JSP JavaScript SpringBoot SpringDataJPA FreeMarker MySQL

基于javaweb+mysql的SpringBoot+JPA图书馆座位占座预约管理系统(管理员、老师、学生)(java+springboot+jpa+freemarker+mysql)

			e.printStackTrace();
		}
	}
}

/**
 * session统一操作工具类
 *
 */
public class SessionUtil {

	/**
	 * 获取请求request
	 * @return
	 */
	public static HttpServletRequest getRequest(){
		ServletRequestAttributes attributes =(ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
		return attributes == null ? null : attributes.getRequest();
	}
	
	/**
	 * 获取session
	 * @return
	 */
	public static HttpSession getSession(){
		HttpServletRequest request = getRequest();
		if(request != null){
			return request.getSession();
		}
		return null;
	}
	
	/**
	 * 获取指定键的值
	 * @param key
	 * @return
	 */
	public static Object get(String key){
		HttpSession session = getSession();
		if(session != null){

    /**
     * 添加班级页面
     * @param model
     * @return
     */
    @RequestMapping(value="/add",method= RequestMethod.GET)
    public String add(Model model){
        model.addAttribute("teachers",teacherService.findAll());
        model.addAttribute("clazz", clazzService.findAll());
        return "admin/clbum/add";
    }

    /**
     * 班级添加表单提交处理
     * @param clazz
     * @return
     */
    @RequestMapping(value="/add",method=RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> add(Clazz clazz){
        //用统一验证实体方法验证是否合法
        CodeMsg validate = ValidateEntityUtil.validate(clazz);
        if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
            return Result.error(validate);
        }
        if(clazz.getTeacher() == null || clazz.getTeacher().getTeacherSno() == null){
            return Result.error(CodeMsg.ADMIN_ClAZZ_EMPTY );
        }
        //判断班级名是否存在
        if(clazzService.isExistClaName(clazz.getClaname(), 0l)){
            return Result.error(CodeMsg.ADMIN_ClAZZNAME_EXIST);
        }
        //到这说明一切符合条件，进行数据库新增
        if(clazzService.save(clazz) == null){
            return Result.error(CodeMsg.ADMIN_ClAZZ_ADD_ERROR);
        }
        operaterLogService.add("添加班级，班级名：" + clazz.getClaname());
        return Result.success(true);
    }
    /**
     * 班级编辑页面
     * @param model
     * @return
     */
    @RequestMapping(value="/edit")
    public String edit(Model model,@RequestParam(name="id",required=true)Long id){
        model.addAttribute("teachers",teacherService.findAll());
        model.addAttribute("clazz",clazzService.find(id));
        return "admin/clbum/edit";
    }

    /**
     * 编辑班级信息表单提交处理
     * @param clazz

                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                return false;
            }
            //说明是普通的请求，可直接重定向到登录页面
            //用户还未登录或者session失效,重定向到登录页面
            try {
                response.sendRedirect("/system/login");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return false;
        }
        log.info("该请求符合登录要求，放行" + requestURI);
        if (!StringUtil.isAjax(request)) {
            //若不是ajax请求，则将菜单信息放入页面模板变量
            User user = (User) attribute;
            List<Menu> authorities = user.getRole().getAuthorities();
            request.setAttribute("userTopMenus", MenuUtil.getTopMenus(authorities));
            List<Menu> secondMenus = MenuUtil.getSecondMenus(user.getRole().getAuthorities());
            request.setAttribute("userSecondMenus", secondMenus);
            request.setAttribute("userThirdMenus", MenuUtil.getChildren(MenuUtil.getMenuIdByUrl(requestURI, secondMenus), authorities));
            request.setAttribute("siteName", "图书馆预约占座系统");
            request.setAttribute("siteUrl", "www.baidu.com");
        }
        return true;
    }
}

	
	/**
	 * 删除菜单信息
	 * @param request
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/delete",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> delete(@RequestParam(name="id",required=true)Long id){
		try {
			menuService.delete(id);
		} catch (Exception e) {
			return Result.error(CodeMsg.ADMIN_MENU_DELETE_ERROR);
		}
		//数据库添加操作成功,记录日志
		operaterLogService.add("删除菜单信息，菜单ID【" + id + "】");
		return Result.success(true);
	}
}

	
	/**
	 * 菜单编辑页面表单提交处理
	 * @param
	 * @param menu
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> edit(Menu menu){
		if(menu == null){
			Result.error(CodeMsg.DATA_ERROR);
		}
		if(menu.getId() == null){
			Result.error(CodeMsg.ADMIN_MENU_ID_EMPTY);
		}
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(menu);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(menu.getParent() != null){
			if(menu.getParent().getId() == null){
				menu.setParent(null);
			}
		}
		Menu existMenu = menuService.find(menu.getId());
		if(existMenu == null){
			Result.error(CodeMsg.ADMIN_MENU_ID_ERROR);
		}
		//表示验证都通过，开始添加数据库
		existMenu.setIcon(menu.getIcon());
		existMenu.setName(menu.getName());
		existMenu.setParent(menu.getParent());
		existMenu.setSort(menu.getSort());
		existMenu.setUrl(menu.getUrl());
		existMenu.setButton(menu.isButton());
		existMenu.setShow(menu.isShow());
		if(menuService.save(existMenu) == null){
			Result.error(CodeMsg.ADMIN_MENU_ADD_ERROR);
		}
		//数据库添加操作成功,记录日志
		operaterLogService.add("编辑菜单信息【" + existMenu + "】");
		return Result.success(true);
	}
	
	/**
	 * 删除菜单信息
	 * @param request
	 * @param id

/**
 * 系统验证码公用控制器
 *
 */
@Controller
@RequestMapping("/cpacha")
public class CpachaController {

	private Logger log = LoggerFactory.getLogger(CpachaController.class);
	
	/**
	 * 通用验证码生成器
	 * @param vcodeLength
	 * @param fontSize
	 * @param width
	 * @param height
	 * @param method
	 * @param request
	 * @param response
	 */
	@RequestMapping(value="/generate_cpacha",method=RequestMethod.GET)
	public void generateCpacha(
			@RequestParam(name="vl",defaultValue="4")Integer vcodeLength,//vcodeLength,验证码长度
			@RequestParam(name="fs",defaultValue="21")Integer fontSize,//fontSize,验证码字体大小
			@RequestParam(name="w",defaultValue="98")Integer width,//width,图片宽度
			@RequestParam(name="h",defaultValue="33")Integer height,//height,图片高度
			@RequestParam(name="method",defaultValue="admin_login")String method,//用来调用此方法的名称，以此名称为键，存入到session中
			HttpServletRequest request,
			HttpServletResponse response){
		CpachaUtil cpachaUtil = new CpachaUtil(vcodeLength,fontSize,width,height);
		String generatorVCode = cpachaUtil.generatorVCode();
		//将生成的验证码放入session，以供放后面程序的验证使用
		request.getSession().setAttribute(method, generatorVCode);
		log.info("验证码成功生成，method=" + method + ",value=" + generatorVCode);
		try {
			ImageIO.write(cpachaUtil.generatorRotateVCodeImage(generatorVCode, true), "gif", response.getOutputStream());
		} catch (IOException e) {
			// TODO Auto-generated catch block

	/**
	 * 获取当前登录的用户
	 * @return
	 */
	public static User getLoginedUser(){
		HttpSession session = getSession();
		if(session != null){
			Object attribute = session.getAttribute(SessionConstant.SESSION_USER_LOGIN_KEY);
			return attribute == null ? null : (User)attribute;
		}
		return null;
	}
}
/**
 * 图片统一查看控制器
 */

@RequestMapping("photo")
@Controller
public class PhotoController {

    @Autowired
    private ResourceLoader resourceLoader;

    /**
     * 系统统一的图片查看方法
     *
     * @param filename
     * @return
     */
    @RequestMapping(value = "/view")
    @ResponseBody
    public ResponseEntity<?> viewPhoto(@RequestParam(name = "filename", required = true) String filename) {
        Resource resource = resourceLoader.getResource("file:" + System.getProperties().get("user.dir") + "/src/main/resources/upload/" + filename);
        try {
            return ResponseEntity.ok(resource);
        } catch (Exception e) {
            return ResponseEntity.notFound().build();
        }
    }

/**
 * 登录拦截器
 *
 */
@Component
public class LoginInterceptor implements HandlerInterceptor {

    private Logger log = LoggerFactory.getLogger(LoginInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String requestURI = request.getRequestURI();
        HttpSession session = request.getSession();
        Object attribute = session.getAttribute(SessionConstant.SESSION_USER_LOGIN_KEY);
        if (attribute == null) {
            log.info("用户还未登录或者session失效,重定向到登录页面,当前URL=" + requestURI);
            //首先判断是否是ajax请求
            if (StringUtil.isAjax(request)) {
                //表示是ajax请求
                try {
                    response.setCharacterEncoding("UTF-8");
                    response.getWriter().write(JSON.toJSONString(CodeMsg.USER_SESSION_EXPIRED));
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                return false;
            }
            //说明是普通的请求，可直接重定向到登录页面
            //用户还未登录或者session失效,重定向到登录页面
            try {
                response.sendRedirect("/system/login");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return false;
        }
        log.info("该请求符合登录要求，放行" + requestURI);
        if (!StringUtil.isAjax(request)) {
            //若不是ajax请求，则将菜单信息放入页面模板变量

    @Autowired
    private SeatOrderService seatOrderService;

    @RequestMapping(value = "/list")
    public String list(Model model, ReadingRoom readingRoom, PageBean<SeatDTO> pageBean) {

        model.addAttribute("title", "座位管理");
        model.addAttribute("name", readingRoom.getName());
        model.addAttribute("pageBean", seatService.findList(readingRoom, pageBean));
        return "admin/seat/list";
    }

    /**
     * 跳转设置座位可用页面
     * @param model
     * @param id
     * @return
     */
    @RequestMapping(value = "/able", method = RequestMethod.GET)
    public String ableSeat(Model model,@RequestParam(name="id",required=true)Long id) {
        model.addAttribute("reading", readRoomService.findById(id));
        List<Seat> seats = seatService.findByReadingRoomId(id);
        model.addAttribute("seats", seats);
        return "admin/seat/able";
    }

    @RequestMapping(value = "/able", method = RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> ableSeat(@RequestParam(name = "id",required = true) Long id,
                                    @RequestParam(name = "status",required = true) int status) {

        Seat seat = seatService.find(id);
        if (Objects.isNull(seat)) {
            Result.error(CodeMsg.ADMIN_SEAT_NO_EXIST);
        }
        seat.setStatus(status);
        seatService.save(seat);

        return Result.success(true);
    }

    /**
     * 跳转选座页面

		model.addAttribute("title","菜单列表");
		model.addAttribute("topMenus",MenuUtil.getTopMenus(findAll));
		model.addAttribute("secondMenus",MenuUtil.getSecondMenus(findAll));
		model.addAttribute("thirdMenus",MenuUtil.getThirdMenus(findAll));
		return "admin/menu/list";
	}
	
	/**
	 * 菜单添加页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.GET)
	public String add(Model model){
		List<Menu> findAll = menuService.findAll();
		model.addAttribute("title","菜单列表");
		model.addAttribute("topMenus",MenuUtil.getTopMenus(findAll));
		model.addAttribute("secondMenus",MenuUtil.getSecondMenus(findAll));
		return "admin/menu/add";
	}
	
	/**
	 * 菜单添加提交表单处理
	 * @param menu
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> add(Menu menu){
		if(menu == null){
			Result.error(CodeMsg.DATA_ERROR);
		}
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(menu);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(menu.getParent() != null){
			if(menu.getParent().getId() == null){
				menu.setParent(null);
			}
		}
		//表示验证都通过，开始添加数据库
		if(menuService.save(menu) == null){
			Result.error(CodeMsg.ADMIN_MENU_ADD_ERROR);
		}

        if (day == currentDay) {
            if (pm == 1) {
                if (TimeEnum.AM.getCode() == timeCode) { //当前时间是下午 但是传过来的时间去预约上午的
                    return Result.error(CodeMsg.ADMIN_SEAT_ORDER_DATE_ERROR);
                }
            }
        } //判断预约时间是否正确

        List<Long> disableSeats = seatService.findDisableSeat(seat.getReadingRoom().getId(), DateUtil.millisecondToDate(date), timeCode);//拿到传过来的时间段内已占座的座位ID

        for (Long disableSeat : disableSeats) { //判断该座位是否被已预约
            if (disableSeat == seatId) {
                return Result.error(CodeMsg.ADMIN_SEAT_ORDER_ADD_EXIST);
            }
        }

        SeatOrder stuIsOrdered = seatService.stuIsOrdered(student.getId(), currentDay);
        if (Objects.nonNull(stuIsOrdered)) {
            return Result.error(CodeMsg.ADMIN_SEAT_ORDER_STUDENT_EXIST);
        }

        SeatOrder seatOrder = new SeatOrder();
        seatOrder.setReadingRoom(seat.getReadingRoom());
        seatOrder.setStudent(student);
        seatOrder.setSeat(seat);
        seatOrder.setSubscribeTime(DateUtil.millisecondToDate(date));
        seatOrder.setTimeCode(timeCode);

        seatOrderService.add(seatOrder);

        return Result.success(true);
    }

    @RequestMapping(value = "/add", method = RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> add(@RequestParam(name = "id", required = true) Long id) {

        ReadingRoom readingRoom = readRoomService.findById(id);

        if (seatService.isExistReadingRoomId(id)) {
            return Result.error(CodeMsg.ADMIN_SEAT_EXIST);
        }

        List<Seat> seats = new ArrayList<>();
        for (int x = 1; x <= readingRoom.getLie(); x++) {
            for (int y = 1; y <= readingRoom.getRow(); y++) {
                Seat seat = new Seat();
                seat.setReadingRoom(readingRoom);
                seat.setxAxis(x);
                seat.setyAxis(y);

	@ResponseBody
	public Result<Boolean> add(User user){
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(user);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(user.getRole() == null || user.getRole().getId() == null){
			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);
		}
		//判断用户名是否存在
		if(userService.isExistUsername(user.getUsername(), 0l)){
			return Result.error(CodeMsg.ADMIN_USERNAME_EXIST);
		}
		//到这说明一切符合条件，进行数据库新增
		if(userService.save(user) == null){
			return Result.error(CodeMsg.ADMIN_USE_ADD_ERROR);
		}
		operaterLogService.add("添加用户，用户名：" + user.getUsername());
		return Result.success(true);
	}
	
	/**
	 * 用户编辑页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.GET)
	public String edit(Model model,@RequestParam(name="id",required=true)Long id){
		model.addAttribute("roles", roleService.findAll());
		model.addAttribute("user", userService.find(id));
		return "admin/user/edit";
	}
	
	/**
	 * 编辑用户信息表单提交处理
	 * @param user
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)
	@ResponseBody

		boolean tag = true;
		final String pattern1 = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
		final Pattern pattern = Pattern.compile(pattern1);
		final Matcher mat = pattern.matcher(email);
		if (!mat.find()) {
			tag = false;
		}
		return tag;
	}

	/**
	 * 验证是否是手机号
	 * @param
	 * @return
	 */
	public static boolean  isMobile(String str) {
		Pattern p = null;
		Matcher m = null;
		boolean b = false;
		String s2="^[1](([3|5|8][\\d])|([4][5,6,7,8,9])|([6][5,6])|([7][3,4,5,6,7,8])|([9][8,9]))[\\d]{8}$";// 验证手机号
		if(StringUtils.isNotBlank(str)){
			p = Pattern.compile(s2);
			m = p.matcher(str);
			b = m.matches();
		}
		return b;
	}

}

/**
 * 权限统一管理拦截器
 *

        if (student.getUser()!=null){
            model.addAttribute("name", student.getUser().getNickName());
        }
        model.addAttribute("pageBean", studentService.findByName(student, pageBean));
        return "admin/student/list";
    }

    /**
     * 学生修改
     * @param model
     * @param id
     * @return
     */
    @RequestMapping(value="/edit",method=RequestMethod.GET)
    public String edit(Model model,@RequestParam(name="id")Long id){
        model.addAttribute("clazzs",clazzService.findAll());
        model.addAttribute("student", studentService.findByID(id));
        return "admin/student/edit";
    }

    /**
     * 学生添加页面
     * @param
     * @return
     */
    @RequestMapping(value="/add",method= RequestMethod.GET)
    public String add(Model model){
        model.addAttribute("clazzs",clazzService.findAll());
        return "admin/student/add";
    }

    @RequestMapping(value="delete",method= RequestMethod.POST)
    @ResponseBody
    public Result delete(long id){
        try {
            studentService.delete(id);
        } catch (Exception e) {

            return Result.error(CodeMsg.ADMIN_ROLE_DELETE_ERROR);
        }

        return Result.success(true);

         * 有id是修改需要判断
         * 无id是增加无需判断
         */
        if (teacher.getId() != null) {
            //用统一验证实体方法验证是否合法
            //到这说明一切符合条件，进行数据库保存
            Teacher byID = teacherService.findByID(teacher.getId());
            byID.setTeacherType(teacher.getTeacherType());
            User user = teacher.getUser();
            //讲提交的用户信息指定字段复制到已存在的user对象中,该方法会覆盖新字段内容
            BeanUtils.copyProperties(user, byID.getUser(), "id", "createTime", "updateTime", "password", "username", "role","status");
            teacherService.update(byID);
        } else {
            //学生学号
            teacherService.add(teacher);
        }
        return Result.success(true);
    }

}

/***
 * 阅读室类型管理控制层
 */
@Controller
@RequestMapping(value = "/readType")
public class ReadRoomTypeController {
    @Autowired
    private ReadRoomTypeService readRoomTypeService;

public class UserController {

	@Autowired
	private UserService userService;
	@Autowired
	private RoleService roleService;
	@Autowired
	private OperaterLogService operaterLogService;
	/**
	 * 用户列表页面
	 * @param model
	 * @param user
	 * @param pageBean
	 * @return
	 */
	@RequestMapping(value="/list")
	public String list(Model model,User user,PageBean<User> pageBean){
		model.addAttribute("title", "用户列表");
		model.addAttribute("nickName", user.getNickName());
		model.addAttribute("pageBean", userService.findList(user, pageBean));
		return "admin/user/list";
	}
	
	/**
	 * 新增用户页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.GET)
	public String add(Model model){
		model.addAttribute("roles", roleService.findAll());
		return "admin/user/add";
	}
	
	/**
	 * 用户添加表单提交处理
	 * @param user
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> add(User user){

	public Result<Boolean> add(User user){
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(user);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(user.getRole() == null || user.getRole().getId() == null){
			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);
		}
		//判断用户名是否存在
		if(userService.isExistUsername(user.getUsername(), 0l)){
			return Result.error(CodeMsg.ADMIN_USERNAME_EXIST);
		}
		//到这说明一切符合条件，进行数据库新增
		if(userService.save(user) == null){
			return Result.error(CodeMsg.ADMIN_USE_ADD_ERROR);
		}
		operaterLogService.add("添加用户，用户名：" + user.getUsername());
		return Result.success(true);
	}
	
	/**
	 * 用户编辑页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.GET)
	public String edit(Model model,@RequestParam(name="id",required=true)Long id){
		model.addAttribute("roles", roleService.findAll());
		model.addAttribute("user", userService.find(id));
		return "admin/user/edit";
	}
	
	/**
	 * 编辑用户信息表单提交处理
	 * @param user
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> edit(User user){
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(user);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(user.getRole() == null || user.getRole().getId() == null){
			return Result.error(CodeMsg.ADMIN_USER_ROLE_EMPTY);