基于javaweb+mysql的校园社团门户管理系统(java+SSM+JSP+mysql)

m0_71463355

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

阅读量228

点赞数

文章标签： java mysql intellij-idea

于 2022-05-28 11:41:21 首次发布

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

版权

系统主要实现的功能分前台用户和后台管理：
前台功能主要有：账号登录、添加关注模块，新闻快讯、通知公告、校历、求职招聘、学科资源信息展现等。
后台管理功能有：后台管理员角色管理、权限管理、社团管理、老师管理、用户管理、公告管理、新闻管理、校园风采管理、求职招聘管理、校历管理、学科资源管理等，老师。系统功能非常丰富完善。
运行环境：jdk1.8、eclipse/idea、Mysql5.7、Navicat/Sqlyog、Maven3.5/3.6 请添加图片描述

适用

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

	 * 添加执行
	 * @return
	 */
	@RequestMapping(value = "/exAdd.do")
	public String exAdd(Role role, Model model, HttpServletRequest request, HttpServletResponse response) {
		role.setIsDelete(0);
		roleService.insert(role);
		return "redirect:/role/findByObj.do";
	}
	/**
	 * 跳至修改页面
	 * @return
	 */
	@RequestMapping(value = "/update.do")
	public String update(Integer id,Model model) {
		Role role = roleService.load(id);
		model.addAttribute("obj",role);
		return "role/update";
	}
	
	
	/**
	 * 跳至修改页面
	 * @return
	 */
	@RequestMapping(value = "/updateRole.do")

  
        System.out.println("开始");  
        String path = request.getSession().getServletContext().getRealPath("/upload");  
        String fileName = file.getOriginalFilename();  
        System.out.println(path);  
        File targetFile = new File(path, fileName);  
        if(!targetFile.exists()){  
            targetFile.mkdirs();  
        }  
        //保存  
        try {  
            file.transferTo(targetFile);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
  
        return "";  
    }  
	
	
	/**
	 * springMvc多文件上传
	 * @param files
	 * @param id
	 * @return

		
	}
	@RequestMapping(value = "/welcome.do")
	public String welcome(){
		return "login/welcome";
		
	}
	@RequestMapping(value = "/toLogin.do")
	public String findByObj(String userName,String passWord,Integer type, Model model, HttpServletRequest request, HttpServletResponse response,HttpSession session) {
		 
		
 		if(type == null){
			return "login/login";
		}
		//type == 管理员 2 社团 3 教师 4用户
		session.removeAttribute("isManage");
		session.removeAttribute("user");
		session.removeAttribute("userId");
		//private Integer type;// 1老师 2 社团3.用户 
		if(type == 1){
			Manage manage = new Manage();
			manage.setUserName(userName);
			manage.setPassWord(passWord);
			Manage man = manageService.loadBySqlId("login", manage);
			if(!isEmpty(man)){
				request.getSession().setAttribute("isManage", 1);

			user.setType(3);
			User use = userService.loadBySqlId("login",user);
			if(!isEmpty(use)){
				
				request.getSession().setAttribute("user", use);
				request.getSession().setAttribute("userId", use.getId());
			}
		}
		return "login/index";
	}
	private void roleAct(Model model, User user) {
		if(!isEmpty(user.getRole())){
			List<Action> actions = new ArrayList<Action>();
			List<RoleAction> roleActions = user.getRole().getRoleActions();

	@RequestMapping(value = "/add.do")
	public String add(Integer type) {
		if(type == 1){
			return "user/add1";
		}
		if(type == 2){
			return "user/add2";
		}
		if(type == 3){
			return "user/add3";
		}
		return "user/add";
	}
	
	/**
	 * 添加执行
	 * @return
	 */
	@RequestMapping(value = "/exAdd.do")

        if(!isEmpty(role.getName())){
        	params.put("name", role.getName());
		}
        if(!isEmpty(role.getIsDelete())){
        	params.put("isDelete", role.getIsDelete());
		}
		//分页查询
		Pager<Role> pagers = roleService.findByMap(params);
		JSONObject jsonObject = JsonUtil2.getJsonObject();
		jsonObject.put("pagers", pagers);
		jsonObject.put("obj", role);
		return jsonObject.toString();
	}
	
	
	/**
	 * ajax 添加
	 * @param 
	 * @return

		return jsonObject.toString();
	}
	/**
	 * 单文件上传
	 * @param file
	 * @param request
	 * @param model
	 * @return
	 */
    @RequestMapping(value = "/saveFile")  
    public String saveFile(@RequestParam(value = "file", required = false) MultipartFile file, HttpServletRequest request, Model model) {  
  
        System.out.println("开始");  
        String path = request.getSession().getServletContext().getRealPath("/upload");  
        String fileName = file.getOriginalFilename();  
        System.out.println(path);  
        File targetFile = new File(path, fileName);  
        if(!targetFile.exists()){

	
	
}
用户管理控制层：
@Controller
@RequestMapping("/user")
public class UserController extends BaseController {
	
	/**
	 * 依赖注入 start dao/service/===
	 */
	@Autowired
	private UserService userService;
	@Autowired
	private RoleService roleService;
	// --------------------------------------- 华丽分割线 ------------------------------
	
	/**
	 * 分页查询 返回list对象(通过对象)
	 * 
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value = "/findByObj.do")
	public String findByObj(User user, Model model, HttpServletRequest request, HttpServletResponse response) {
		//分页查询

		
	}
	
	/**
	 * 添加修改
	 * @return
	 */
	@RequestMapping(value = "/exUpdate.do")
	public String exUpdate(User user, Model model, HttpServletRequest request, HttpServletResponse response) {
		userService.update(user);
		return "redirect:/user/findByMap.do?type="+user.getType();
	}
	
	/**
	 * 删除通过主键
	 * @return
	 */
	@RequestMapping(value = "/delete.do")
	public String delete(Integer id, Model model, HttpServletRequest request, HttpServletResponse response) {
		//真正删除
		//userService.deleteById(id);

        if(!isEmpty(user.getZy())){
        	params.put("zy", user.getZy());
		}
        if(!isEmpty(user.getNj())){
        	params.put("nj", user.getNj());
		}
        if(!isEmpty(user.getIsDelete())){
        	params.put("isDelete", user.getIsDelete());
		}
        if(!isEmpty(user.getType())){
        	params.put("type", user.getType());
		}
		//分页查询
		Pager<User> pagers = userService.findByMap(params);
		JSONObject jsonObject = JsonUtil2.getJsonObject();
		jsonObject.put("pagers", pagers);
		jsonObject.put("obj", user);
		return jsonObject.toString();
	}

基于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
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫