基于javaweb+mysql的校园社团管理系统(java+Jdbc+Servlet+jsp+mysql)

m0_71463355

已于 2023-08-03 20:38:44 修改

阅读量206

点赞数

文章标签： java mysql intellij-idea

于 2022-05-28 11:40:37 首次发布

本文链接：https://blog.csdn.net/m0_71463355/article/details/125016449

版权

一、项目运行

环境配置：
Jdk1.8 + Tomcat8.5 + mysql + Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）

项目技术：
Jdbc+ Servlert + jsp+ css + JavaScript + JQuery + Ajax 等等请添加图片描述

适用

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

                if (student != null) {
                    try {
                        studentService.delete(Long.valueOf(id));
                        operaterLogService.add("删除学生，id为：" + id);
                    }catch (Exception e){
                        return Result.error(CodeMsg.ADMIN_STUDENT_DELETE_ERROR);
                    }
                }
            }
        }
        return Result.success(true);
    }
}
后台用户管理控制器：
/**
 * 后台用户管理控制器
 */
@RequestMapping("/admin/user")
@Component
public class UserController {
    @Autowired
    private UserService userService;

     */
    @ResponseBody
    @RequestMapping(value = "/edit",method = RequestMethod.POST)
    public Result<Boolean> edit(Role role, HttpServletRequest request){
        CodeMsg validate = ValidateEntityUtil.validate(role);
        if(validate.getCode()!=CodeMsg.SUCCESS.getCode()){
            return  Result.error(validate);
        }
        Role existRole = roleService.find(role.getId());
        if(existRole==null){
            return  Result.error(CodeMsg.ADMIN_ROLE_NO_EXIST);
        }
        existRole.setName(role.getName());
        existRole.setRemark(role.getRemark());
        existRole.setStatus(role.getStatus());
        existRole.setAuthorities(role.getAuthorities());
        if(roleService.save(existRole)==null){
            return  Result.error(CodeMsg.ADMIN_ROLE_EDIT_ERROR);
        }
        log.info("编辑角色["+role+"]");
        operaterLogService.add("编辑角色["+role.getName()+"]");
        return Result.success(true);
    }
    @ResponseBody
    @RequestMapping(value = "/delete",method = RequestMethod.POST)
    public Result<Boolean> delete(@RequestParam(name = "id",required = true) Long id,HttpServletRequest request){

    public Result<Boolean> add(Role role, HttpServletRequest request){
        CodeMsg validate = ValidateEntityUtil.validate(role);
        if(validate.getCode()!=CodeMsg.SUCCESS.getCode()){
            return  Result.error(validate);
        }
        if(roleService.save(role)==null){
            return  Result.error(CodeMsg.ADMIN_ROLE_ADD_ERROR);
        }
        log.info("添加角色["+role+"]");
        operaterLogService.add("添加角色["+role.getName()+"]");
        return Result.success(true);
    }
    /**
     * 角色编辑页面
     * @param id
     * @param model
     * @return
     */

        if(studentService.findById(id)!=null){
            model.addAttribute("student",studentService.findById(id));
        }
        return "/admin/student/edit";
    }
    /**
     * 编辑后台学生信息
     * @param student
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/edit", method = RequestMethod.POST)
    public Result<Boolean> edit(Student student, HttpServletRequest request) {

        //用统一验证实体方法验证是否合法
        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(user.getId()==null||user.getId().longValue()<=0){
            return Result.error(CodeMsg.ADMIN_USER_NO_EXIST);
        }
        //判断数据库user表有没有这个用户名
        if(userService.isExistUsername(user.getUsername(),user.getId().longValue())){
                return Result.error(CodeMsg.ADMIN_USER_NAME_EXIST);
        }
        //将提交的用户信息指定字段复制到已存在的user对象中
        User findbyId = userService.find(user.getId());
        //把source原来的字段复制到目标对象当中ignoreProperties表示忽略哪些字段 该方法会覆盖新字段内容
        BeanUtils.copyProperties(user,findbyId,"id","createTime","updateTime");
        //到这说明一切通过 开始进行数据库编辑
        if(userService.save(findbyId)==null){
            return Result.error(CodeMsg.ADMIN_USER_EDIT_ERROR);
        }

     */
    @RequestMapping("/list")
    public String list(Model model, User user, PageBean<User> pageBean){
        model.addAttribute("usernmae",user.getUsername());
        model.addAttribute("pageBean",userService.findList(user,pageBean));
        model.addAttribute("title","用户列表");
        return "admin/user/list";
    }
    /**
     * 用户添加页面
     * @param model
     * @param
     * @return

     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/edit",method = RequestMethod.POST)
    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);
        }
        if(user.getId()==null||user.getId().longValue()<=0){
            return Result.error(CodeMsg.ADMIN_USER_NO_EXIST);
        }
        //判断数据库user表有没有这个用户名
        if(userService.isExistUsername(user.getUsername(),user.getId().longValue())){
                return Result.error(CodeMsg.ADMIN_USER_NAME_EXIST);
        }
        //将提交的用户信息指定字段复制到已存在的user对象中

        if(studentService.findByLoginName(student.getLoginName())!=null){
            return Result.error(CodeMsg.ADMIN_STUDENT_ISEXIST_ERROR);
        }
        if(studentService.save(student)==null){
            return Result.error(CodeMsg.ADMIN_STUDENT_ADD_ERROR);
        }
        return Result.success(true);
    }
    /**
     * 编辑学生页面
     * @param model
     * @param id
     * @return

        model.addAttribute("title","用户列表");
        return "admin/user/list";
    }
    /**
     * 用户添加页面
     * @param model
     * @param
     * @return
     */
    @RequestMapping(value = "/add",method = RequestMethod.GET)
    public String add(Model model){
        List<Role> all = roleService.findAll();
        model.addAttribute("roles",all);
        return "admin/user/add";
    }
    @ResponseBody

    private StudentService studentService ;
    @Autowired
    private OperaterLogService operaterLogService;
    /**
     * 学生管理列表
     * @param model
     * @return
     */
    @RequestMapping("/list")
    public String list(Model model, Student student, PageBean<Student> pageBean){
        model.addAttribute("pageBean",studentService.findList(student, pageBean));
        model.addAttribute("studentLoginName",student.getLoginName());
        model.addAttribute("title","学生列表");
        return "/admin/student/list";
    }
    /**
     * 后台学生添加页面

     * 分页搜索角色列表
     * @param model
     * @param role
     * @param pageBean
     * @return
     */
    @RequestMapping(value = "/list")
    public String list(Model model, Role role, PageBean<Role> pageBean){
        model.addAttribute("title","角色列表");
        model.addAttribute("name",role.getName());
        model.addAttribute("pageBean",roleService.findByName(role,pageBean));
        return "admin/role/list";
    }
    /**
     * 角色添加页面

        model.addAttribute("title","学生列表");
        return "/admin/student/list";
    }
    /**
     * 后台学生添加页面
     */
    @RequestMapping(value = "/add",method = RequestMethod.GET)
    public String add(){
        return "/admin/student/add";
    }
    /**
     * 后台学生添加信息操作
     */
    @ResponseBody
    @RequestMapping(value = "/add",method = RequestMethod.POST)
    public Result<Boolean> add(Model model,Student student){
        CodeMsg validate = ValidateEntityUtil.validate(student);
        if (validate.getCode() != CodeMsg.SUCCESS.getCode()) {
            return Result.error(validate);
        }
        if(studentService.findByLoginName(student.getLoginName())!=null){
            return Result.error(CodeMsg.ADMIN_STUDENT_ISEXIST_ERROR);
        }
        if(studentService.save(student)==null){
            return Result.error(CodeMsg.ADMIN_STUDENT_ADD_ERROR);

基于javaweb+mysql的ssm+maven图书租赁管理系统(java+ssm+jsp+bootstrap+echarts+mysql)

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

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

适用

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

功能说明

基于javaweb+mysql的SSM+Maven图书租赁管理系统(java+ssm+jsp+bootstrap+echarts+mysql)

图书租赁管理系统

项目介绍

图书租赁管理系统，该系统分为管理员与普通读者两种角色；管理员主要功能包括：图书管理：添加、修改、删除；图书分类管理：添加、修改、删除；借阅信息：还书；预定信息：确认借书；归还信息；统计管理：借书/归还、营业额、销量；普通读者主要功能包括：预定图书、待拿图书、借阅中、归还信息等；

客户端的充值，使用的支付宝沙箱测试化境

环境需要

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.是否Maven项目: 是；查看源码目录中是否包含pom.xml；若包含，则为maven项目，否则为非maven项目 6.数据库：MySql 8.0版本； 7.lombok插件安装：本项目需要安装lombok插件，否则运行会有异常；

技术栈

后端：Spring SpringMVC MyBatis 2. 前端：JSP+bootstrap+jQuery+echarts

使用说明

使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件； 2. 使用IDEA/Eclipse/MyEclipse导入项目，Eclipse/MyEclipse导入时，若为maven项目请选择maven;若为maven项目，导入成功后请执行maven clean;maven install命令，配置tomcat，然后运行； 3. 将项目中db.properties配置文件中的数据库配置改为自己的配置;
运行项目，输入localhost:8080/bm/

					break;
				}
			}
		} catch (UnsupportedEncodingException e) {
			logger.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	/**
	 * 得到Cookie的值,
	 * 
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
		Cookie[] cookieList = request.getCookies();
		if (cookieList == null || cookieName == null){
			return null;			
		}
		String retValue = null;
		try {
			for (int i = 0; i < cookieList.length; i++) {
				if (cookieList[i].getName().equals(cookieName)) {
					retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
					break;
				}
			}
		} catch (UnsupportedEncodingException e) {
			logger.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	/**
	 * 设置Cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
	 */
	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue) {
		setCookie(request, response, cookieName, cookieValue, -1,"/");
	}

	/**
	 * 设置Cookie的值 在指定时间内生效,但不编码
	 */
	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage) {
		setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
	}

	/**
	 * 设置Cookie的值 不设置生效时间,但编码

        //发送的邮箱内容
        String emailMsg = mailTemplate.getTemplate()
                .replace("{borrowBooksTime}",DateUtils.dateFormat("yyyy年MM月dd日",borrowBook.getBbTime()))
                .replace("{dueTime}",DateUtils.dateFormat("yyyy年MM月dd日",borrowBook.getDueTime()))
                .replace("{bookName}",borrowBook.getBName())
                .replace("{userName}",borrowBook.getRName())
                .replace("{remainingDay}",borrowBook.getRemainingDays()+"")
                .replace("{systemUrl}",aDocument);
        //发送邮箱提醒
        try {
            mailUtils.sendRemind(reader.getEmail(),emailMsg);
        } catch (MessagingException e) {    //发送邮箱还书提醒失败！
            e.printStackTrace();
            throw new LyException(ExceptionEnum.SEND_REMIND_FAIL);
        }
    }
}

@RequestMapping("reader/reserveBorrow")
@RestController
public class RReserveBorrowBooksController {

    @Autowired
    private ReserveBorrowBooksService reserveBookService;

    @Autowired

        MailTemplate mailTemplate = null;
        //实际借书天数（现在的时间-租借的时间）
        int readyDay =  DateUtils.differenceDay(new Date(),borrowBook.getBbTime());
        //最大借书天数 = 应该还书的时间-租借的时间
        int maxDay = DateUtils.differenceDay(borrowBook.getDueTime(),borrowBook.getBbTime());
        //逾期天数 = 实际借书天数 - 最大借书天数
        int overDay = readyDay - maxDay;
        //用户是否逾期
        if(overDay <=0 ){ //还未逾期
            //查询未逾期模板
            mailTemplate = templateMapper.selectByPrimaryKey(1);
            borrowBook.setRemainingDays(maxDay-readyDay);
        }else{
            mailTemplate = templateMapper.selectByPrimaryKey(2);
            borrowBook.setRemainingDays(overDay);
        }

        String path = request.getContextPath();
        String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
        String url = basePath;

        String aDocument = "<a href=\""+url+"\">"+url+"</a>";
        //发送的邮箱内容
        String emailMsg = mailTemplate.getTemplate()
                .replace("{borrowBooksTime}",DateUtils.dateFormat("yyyy年MM月dd日",borrowBook.getBbTime()))
                .replace("{dueTime}",DateUtils.dateFormat("yyyy年MM月dd日",borrowBook.getDueTime()))
                .replace("{bookName}",borrowBook.getBName())
                .replace("{userName}",borrowBook.getRName())
                .replace("{remainingDay}",borrowBook.getRemainingDays()+"")
                .replace("{systemUrl}",aDocument);
        //发送邮箱提醒
        try {
            mailUtils.sendRemind(reader.getEmail(),emailMsg);
        } catch (MessagingException e) {    //发送邮箱还书提醒失败！
            e.printStackTrace();
            throw new LyException(ExceptionEnum.SEND_REMIND_FAIL);
        }
    }
}

    @Autowired
    private Jedis jedis;

    @Autowired
    private BMSystemProperties bmProperties;

    @Autowired
    private MailUtils mailUtils;

    //根据id查询读者信息
    public Reader queryById(Integer rId) {
        return readerMapper.selectByPrimaryKey(rId);
    }

    //判断账户名是否存在
    public void accountNameExist(String accountName) {
        if (!CollectionUtils.isEmpty(readerMapper.select(new Reader(accountName)))) {    //账户名已存在
            throw new LyException(ExceptionEnum.READER_ACCOUNT_NAME_EXIST);
        }
    }

    //用户注册
    public void saveReader(Reader reader) {
        //根据用户的账户名获取邮箱的验证码
        String verifyCode = jedis.get(reader.getAccount());
        if (StringUtils.isBlank(verifyCode)) {    //验证码已失效，或邮箱地址错误！
            throw new LyException(ExceptionEnum.VERIFY_EXPIRY_OR_EMAIL_ERROR);
        }
        if (!reader.getVerifyCode().equals(verifyCode)) { //邮箱验证码不匹配
            throw new LyException(ExceptionEnum.VERIFY_CODE_NOT_MATCHING);
        }
        reader.builderReader();
        readerMapper.insert(reader);
    }

    //发送邮箱验证码
    public void verifyMailCode(String account, String email) {
        //获取4位数的验证码
        String verifyCode = new Random().nextInt(9999) + "";
        //将验证码根据 account存入redis中
        jedis.set(account, verifyCode);
        //设置验证码有效期
        jedis.expire(account, bmProperties.getEmailVerifyCodeMinute()*60);
        //发送邮箱验证码
        Integer validMinute = bmProperties.getEmailVerifyCodeMinute();
        String emailMsg = bmProperties.getMailReaderRegisterContentModel();
        emailMsg = emailMsg.replace("{emailVerifyCode}", verifyCode).replace("{emailVerifyCodeMinute}", validMinute + "");
        try {
            mailUtils.sendRegisterVerifyCode(email, emailMsg);
        } catch (MessagingException e) {

        return reserveBorrowBooks.getRbbId();
    }

    //读者 修改剩余天数
    @Transactional
    public void modifyRemainingDays(Integer rbbId, Integer remainingDays) {
        //预定天数不能大于 {{maxBorrowBooksDay}} 最大结束天数
        if(remainingDays >= bmProperties.getMaxBorrowBooksDay()){
            //抱歉，最大借书天数为{maxBorrowBooksDay}天！
            ExceptionEnum em = ExceptionEnum.GREATER_THAN_MAX_BORROW_BOOKS_DAY;
            em.setMsg(em.getMsg().replace("{maxBorrowBooksDay}",bmProperties.getMaxBorrowBooksDay()+""));
            throw new LyException(em);
        }
        //根据id查询 预约图书表中的数据
        ReserveBorrowBooks reserveBorrowBooks = reserveBookMapper.selectByPrimaryKey(rbbId);
        if(reserveBorrowBooks == null){ //预定记录不存在，您的书籍已经成功领取！
            log.error("预约图书表修改剩余天数，失败");
            throw new LyException(ExceptionEnum.BOOK_GET_DOWN);
        }
        //查询图书是否存在
        Books books = bookMapper.selectByPrimaryKey(reserveBorrowBooks.getBId());
        if(books == null){
            throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
        }
        //修改图书数据
        if(remainingDays > 0){
            reserveBorrowBooks.setRemainingDays(remainingDays);
            //修改预约表中的数据
          reserveBookMapper.updateByPrimaryKey(reserveBorrowBooks);
        }
    }

    //读者 删除预定
    @Transactional
    public void deleteReserve(List<Integer> rbbIds) {
        for (Integer rbbId : rbbIds) {
            //根据id查询 预约图书表中的数据
            ReserveBorrowBooks reserveBorrowBooks = reserveBookMapper.selectByPrimaryKey(rbbId);
            if(reserveBorrowBooks == null){ //图书预定不存在，您的书籍已经成功领取！
                log.error("删除预定失败！");
                throw new LyException(ExceptionEnum.BOOK_GET_DOWN);
            }
            //查询图书信息
            Books books = bookMapper.selectByPrimaryKey(reserveBorrowBooks.getBId());
            if(books == null){  //判断是否存在
                throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
            }
            //删除数据
            reserveBookMapper.deleteByPrimaryKey(rbbId);
        }
    }
}

          reserveBookMapper.updateByPrimaryKey(reserveBorrowBooks);
        }
    }

    //读者 删除预定
    @Transactional
    public void deleteReserve(List<Integer> rbbIds) {
        for (Integer rbbId : rbbIds) {
            //根据id查询 预约图书表中的数据
            ReserveBorrowBooks reserveBorrowBooks = reserveBookMapper.selectByPrimaryKey(rbbId);
            if(reserveBorrowBooks == null){ //图书预定不存在，您的书籍已经成功领取！
                log.error("删除预定失败！");
                throw new LyException(ExceptionEnum.BOOK_GET_DOWN);
            }
            //查询图书信息
            Books books = bookMapper.selectByPrimaryKey(reserveBorrowBooks.getBId());
            if(books == null){  //判断是否存在
                throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
            }
            //删除数据
            reserveBookMapper.deleteByPrimaryKey(rbbId);
        }
    }
}

/**
 * 
 * Cookie 工具类
 *
 */
public final class CookieUtils {

	protected static final Logger logger = LoggerFactory.getLogger(CookieUtils.class);

	/**
	 * 得到Cookie的值, 不编码
	 * 
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName) {

	 * 设置Cookie的值，并使其在指定时间内生效
	 * 
	 * @param cookieMaxage
	 *            cookie生效的最大秒数
	 */
	private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, boolean isEncode,String path) {
		try {
			if (cookieValue == null) {
				cookieValue = "";
			} else if (isEncode) {
				cookieValue = URLEncoder.encode(cookieValue, "utf-8");
			}
			Cookie cookie = new Cookie(cookieName, cookieValue);
			if (cookieMaxage > 0)
				cookie.setMaxAge(cookieMaxage);
			if (null != request)// 设置域名的cookie
				cookie.setDomain(getDomainName(request));
			cookie.setPath(path);
			response.addCookie(cookie);
		} catch (Exception e) {
			logger.error("Cookie Encode Error.", e);
		}
	}

	/**
	 * 设置Cookie的值，并使其在指定时间内生效
	 * 
	 * @param cookieMaxage
	 *            cookie生效的最大秒数
	 */
	private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, String encodeString,String path) {
		try {
			if (cookieValue == null) {
				cookieValue = "";
			} else {
				cookieValue = URLEncoder.encode(cookieValue, encodeString);
			}
			Cookie cookie = new Cookie(cookieName, cookieValue);
			if (cookieMaxage > 0)
				cookie.setMaxAge(cookieMaxage);
			if (null != request)// 设置域名的cookie

        if(books.getInLibraryTotal() <= 0){ //抱歉，该图书已全部借出！
            throw new LyException(ExceptionEnum.SORRY_BOOK_BORROW_ALL);
        }
        if(books.getInLibraryTotal() <= books.getReserveNum()){ //抱歉，图书预定人数已满！  在馆数（总数-借出数） == 预定数（预定表中数量）
            throw new LyException(ExceptionEnum.RESERVE_BOOK_FULL);
        }
        //预定天数不能大于 {{maxBorrowBooksDay}} 最大结束天数
        if(rentDay >= bmProperties.getMaxBorrowBooksDay()){
            //抱歉，最大借书天数为{maxBorrowBooksDay}天！
            ExceptionEnum em = ExceptionEnum.GREATER_THAN_MAX_BORROW_BOOKS_DAY;
            em.setMsg(em.getMsg().replace("{maxBorrowBooksDay}",bmProperties.getMaxBorrowBooksDay()+""));
            throw new LyException(em);
        }
        //账户至少有 多少钱才能预定图书
        if(reader.getBalance()/100.0 < bmProperties.getBorrowBooksAccountLest()){
            //抱歉，账户余额少于{balanceLess}元不能借书，请您点击右上角头像选择充值!
            ExceptionEnum em = ExceptionEnum.ACCOUNT_BALANCE_LESS;
            em.setMsg(em.getMsg().replace("{balanceLess}",bmProperties.getBorrowBooksAccountLest()+""));
            throw new LyException(em);
        }
        //封装 预定借书表
        ReserveBorrowBooks reserveBorrowBooks = new ReserveBorrowBooks();
        reserveBorrowBooks.setRId(reader.getRId());
        reserveBorrowBooks.setBId(books.getBId());
        reserveBorrowBooks.setOrderTime(new Timestamp(new Date().getTime()));
        reserveBorrowBooks.setRemainingDays(rentDay);
        //将 该图书记录 插入 预定借阅表中
        reserveBookMapper.insert(reserveBorrowBooks);
        //返回插入的id
        return reserveBorrowBooks.getRbbId();
    }

    //读者 修改剩余天数
    @Transactional
    public void modifyRemainingDays(Integer rbbId, Integer remainingDays) {
        //预定天数不能大于 {{maxBorrowBooksDay}} 最大结束天数
        if(remainingDays >= bmProperties.getMaxBorrowBooksDay()){
            //抱歉，最大借书天数为{maxBorrowBooksDay}天！
            ExceptionEnum em = ExceptionEnum.GREATER_THAN_MAX_BORROW_BOOKS_DAY;
            em.setMsg(em.getMsg().replace("{maxBorrowBooksDay}",bmProperties.getMaxBorrowBooksDay()+""));
            throw new LyException(em);
        }
        //根据id查询 预约图书表中的数据
        ReserveBorrowBooks reserveBorrowBooks = reserveBookMapper.selectByPrimaryKey(rbbId);
        if(reserveBorrowBooks == null){ //预定记录不存在，您的书籍已经成功领取！
            log.error("预约图书表修改剩余天数，失败");
            throw new LyException(ExceptionEnum.BOOK_GET_DOWN);

    //借书 一个
    @PostMapping("/{resId}")
    public ResponseEntity<Void> saveReserve(@PathVariable("resId") Integer resId){
        reserveBookService.saveReserves(Arrays.asList(resId));
        return ResponseEntity.status(HttpStatus.CREATED).build();
    }

    //借书 多个
    @PostMapping
    public ResponseEntity<Void> saveReserves(@RequestBody List<Integer> resIds){
        reserveBookService.saveReserves(resIds);
        return ResponseEntity.status(HttpStatus.CREATED).build();
    }

}

@RequestMapping("reader/giveBack")
@RestController
public class RGiveBackController {

    @Autowired
    private GiveBackBookService giveBackBookService;

    @Autowired
    private BMSystemProperties bmProperties;

    //分页查询 并可以带查询参数
    @GetMapping("/{page}/{size}")
    public ResponseEntity<Page<GiveBackBooks>> giveBackBook(@PathVariable("page") Integer page,
                                                            @PathVariable("size") Integer size,
                                                            GiveBackBooks reserveGiveBack,
                                                            HttpSession session){
        Reader reader = (Reader) session.getAttribute(bmProperties.getReaderSessionName());
        reserveGiveBack.setRName(reader.getRName());

    }

    //读者修改 借阅天数
    @PutMapping("/{rbbId}/{remainingDays}")
    public ResponseEntity<Void> modifyRemainingDays(@PathVariable("rbbId") Integer rbbId,
                                                    @PathVariable("remainingDays") Integer remainingDays){
        reserveBookService.modifyRemainingDays(rbbId,remainingDays);
        return ResponseEntity.ok().build();
    }

    //读者取消预定 多个
    @DeleteMapping
    public ResponseEntity<Void> deleteReserves(@RequestBody List<Integer> rbbIds){
        reserveBookService.deleteReserve(rbbIds);
        return ResponseEntity.ok().build();
    }

    //读者删除 预定
    @DeleteMapping("/{rbbId}")
    public ResponseEntity<Void> deleteReserve(@PathVariable("rbbId") Integer rbbId){
        reserveBookService.deleteReserve(Arrays.asList(rbbId));
        return ResponseEntity.ok().build();
    }

    //读者 预定图书
    @PostMapping("/{bId}/{RentDay}")
    public ResponseEntity<Integer> reserveBooks(@PathVariable("bId") Integer bId,
                                             @PathVariable("RentDay") Integer rentDay,
                                             HttpSession session){
        return ResponseEntity.ok().body(reserveBookService.reserveBook(bId, rentDay, session));
    }

}

@RequestMapping("/manager/books")
@RestController()
public class MBookController {

			logger.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	/**
	 * 设置Cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
	 */
	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue) {
		setCookie(request, response, cookieName, cookieValue, -1,"/");
	}

	/**
	 * 设置Cookie的值 在指定时间内生效,但不编码
	 */
	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage) {
		setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
	}

	/**
	 * 设置Cookie的值 不设置生效时间,但编码
	 */
	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, boolean isEncode) {
		setCookie(request, response, cookieName, cookieValue, -1, isEncode);
	}

	/**
	 * 设置Cookie的值 在指定时间内生效, 编码参数
	 */
	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
		doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode,"/");
	}

	/**
	 * 设置Cookie的值 在指定时间内生效, 编码参数(指定编码)
	 */
	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
		doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString,"/");
	}

	/**


    @Autowired
    private ManagerMapper managerMapper;

    @Autowired
    private BMSystemProperties bmProperties;

    //用户登录
    public String login(LoginVo loginVo, HttpServletResponse response, HttpServletRequest request) {
        //判断用户的类型
        String type = loginVo.getType();
        String url;
        if(type.equals("读者")){
            url = loginReader(loginVo,response,request);
        }else{  //管理员
            url = loginManager(loginVo,request);
        }
        return url;
    }

    //用户登录
    @Transactional
    public String loginReader(LoginVo loginVo, HttpServletResponse response,HttpServletRequest request){
        //根据用户名和密码查询
        Example example = new Example(Reader.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("account",loginVo.getAccount())
                .andEqualTo("password",loginVo.getPassword());
        example.or().andEqualTo("email",loginVo.getAccount())
                .andEqualTo("password",loginVo.getPassword());
        List<Reader> readers = readerMapper.selectByExample(example);
        if(CollectionUtils.isEmpty(readers)){   //不存在该用户，账号或密码错误！
            throw new LyException(ExceptionEnum.LOGIN_ACCOUNT_OR_PASSWORD);
        }
        //获取数据库中的读者信息
        Reader reader = readers.get(0);
        //判断是否有自动登录
        if(loginVo.getAutoLogin()){ //有自动登录
            Integer day = bmProperties.getReaderAutoLoginDay()*60*24;
            String path = request.getContextPath()+"/pages/reader/";
            //根据 账户名
            Cookie cookie = new Cookie(bmProperties.getAutoCookieName(),reader.getAccount());
            //设置路径
            cookie.setPath(path);
            //bm/login/autoLogin
            //设置有效期
            cookie.setMaxAge(day);
            //设置用户端存储
            response.addCookie(cookie);
        }
        //将用户的登录信息保存到 session 中
        saveReaderToSession(request,reader);

            CookieUtils.deleteCookie(request,response, bmProperties.getAutoCookieName(),request.getContextPath()+ bmProperties.getCookiePath());   //用户端删除该cookie
            return false;
        }
        //将用户信息存入session中
        saveReaderToSession(request,readers.get(0));
        return true;
    }

    //将用户的信息保存到 session 中 并设置最后的登录时间
    private void saveReaderToSession(HttpServletRequest request,Reader reader){
        //将用户的登录信息保存到 session 中
        HttpSession session = request.getSession();
        session.setAttribute(bmProperties.getReaderSessionName(),reader);
    }
}

@Service
public class MailTemplateService {

    @Autowired
    private MailTemplateMapper templateMapper;

    @Autowired
    private BorrowBookMapper borrowBookMapper;

    @Autowired
    private ReaderMapper readerMapper;

    @Autowired
    private MailUtils mailUtils;

    @Autowired

        Reader reader = readerMapper.selectByPrimaryKey(rId);
        if(reader == null){ //用户不存在
            throw new LyException(ExceptionEnum.SERVICE_BUSY);
        }
        MailTemplate mailTemplate = null;
        //实际借书天数（现在的时间-租借的时间）
        int readyDay =  DateUtils.differenceDay(new Date(),borrowBook.getBbTime());
        //最大借书天数 = 应该还书的时间-租借的时间
        int maxDay = DateUtils.differenceDay(borrowBook.getDueTime(),borrowBook.getBbTime());
        //逾期天数 = 实际借书天数 - 最大借书天数
        int overDay = readyDay - maxDay;
        //用户是否逾期
        if(overDay <=0 ){ //还未逾期
            //查询未逾期模板
            mailTemplate = templateMapper.selectByPrimaryKey(1);
            borrowBook.setRemainingDays(maxDay-readyDay);
        }else{
            mailTemplate = templateMapper.selectByPrimaryKey(2);
            borrowBook.setRemainingDays(overDay);
        }

        String path = request.getContextPath();
        String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
        String url = basePath;

        String aDocument = "<a href=\""+url+"\">"+url+"</a>";
        //发送的邮箱内容
        String emailMsg = mailTemplate.getTemplate()
                .replace("{borrowBooksTime}",DateUtils.dateFormat("yyyy年MM月dd日",borrowBook.getBbTime()))
                .replace("{dueTime}",DateUtils.dateFormat("yyyy年MM月dd日",borrowBook.getDueTime()))
                .replace("{bookName}",borrowBook.getBName())
                .replace("{userName}",borrowBook.getRName())
                .replace("{remainingDay}",borrowBook.getRemainingDays()+"")
                .replace("{systemUrl}",aDocument);
        //发送邮箱提醒
        try {
            mailUtils.sendRemind(reader.getEmail(),emailMsg);
        } catch (MessagingException e) {    //发送邮箱还书提醒失败！
            e.printStackTrace();
            throw new LyException(ExceptionEnum.SEND_REMIND_FAIL);
        }
    }
}


@RequestMapping("/login")
@Controller
public class LoginController {

    @Autowired
    private LoginService loginService;

    //用户登录
    @PostMapping
    @ResponseBody
    public String login(@RequestBody LoginVo loginVo, HttpServletResponse response,
                                      HttpServletRequest request){
        String url = loginService.login(loginVo,response,request);
        return url;
    }

    //读者自动登录
    @GetMapping("/autoLogin")
    public String autoLoginReader(HttpServletResponse response,HttpServletRequest request){
        Boolean flag = loginService.autoLoginReader(response, request);
        String url = "";
        if(flag){   //登录成功
            url = "/pages/reader/bookDatalist.jsp";
        }else{  //登陆失败
            url = "/pages/login.jsp";
        }
        return "redirect:"+ url;
    }

            log.error("预约图书表修改剩余天数，失败");
            throw new LyException(ExceptionEnum.BOOK_GET_DOWN);
        }
        //查询图书是否存在
        Books books = bookMapper.selectByPrimaryKey(reserveBorrowBooks.getBId());
        if(books == null){
            throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
        }
        //修改图书数据
        if(remainingDays > 0){
            reserveBorrowBooks.setRemainingDays(remainingDays);
            //修改预约表中的数据
          reserveBookMapper.updateByPrimaryKey(reserveBorrowBooks);
        }
    }

    //读者 删除预定
    @Transactional
    public void deleteReserve(List<Integer> rbbIds) {
        for (Integer rbbId : rbbIds) {
            //根据id查询 预约图书表中的数据
            ReserveBorrowBooks reserveBorrowBooks = reserveBookMapper.selectByPrimaryKey(rbbId);
            if(reserveBorrowBooks == null){ //图书预定不存在，您的书籍已经成功领取！
                log.error("删除预定失败！");
                throw new LyException(ExceptionEnum.BOOK_GET_DOWN);
            }
            //查询图书信息
            Books books = bookMapper.selectByPrimaryKey(reserveBorrowBooks.getBId());
            if(books == null){  //判断是否存在
                throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
            }
            //删除数据
            reserveBookMapper.deleteByPrimaryKey(rbbId);
        }
    }
}

/**
 *

    }

}

@RequestMapping("reader/giveBack")
@RestController
public class RGiveBackController {

    @Autowired
    private GiveBackBookService giveBackBookService;

    @Autowired
    private BMSystemProperties bmProperties;

    //分页查询 并可以带查询参数
    @GetMapping("/{page}/{size}")
    public ResponseEntity<Page<GiveBackBooks>> giveBackBook(@PathVariable("page") Integer page,
                                                            @PathVariable("size") Integer size,
                                                            GiveBackBooks reserveGiveBack,
                                                            HttpSession session){
        Reader reader = (Reader) session.getAttribute(bmProperties.getReaderSessionName());
        reserveGiveBack.setRName(reader.getRName());
        return ResponseEntity.ok(giveBackBookService.giveBackBook(page,size, reserveGiveBack,true));
    }

}

m0_71463355

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
基于javaweb+mysql的校园社团管理系统(java+Jdbc+Servlet+jsp+mysql)

一、项目运行环境配置：Jdk1.8 + Tomcat8.5 + mysql + Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）项目技术：Jdbc+ Servlert + jsp+ css + JavaScript + JQuery + Ajax 等等适用课程设计，大作业，毕业设计，项目练习，学习演示等 if (student != null) { try {
复制链接

扫一扫