基于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/
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,"/");
}
/**
* 删除Cookie带cookie域名
*/
public static void deleteCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,String path) {
doSetCookie(request, response, cookieName, "", -1, false,path);
}
/**
* 设置Cookie的值，并使其在指定时间内生效
*
* @param cookieMaxage
* cookie生效的最大秒数
public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
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)) {
if (isDecoder) {
retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
} else {
retValue = cookieList[i].getValue();
}
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;
}
@Service
@Slf4j
public class ReaderService {
@Autowired
private ReaderMapper readerMapper;
@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) {
return ResponseEntity.ok().build();
}
//发送邮箱验证码
@PostMapping("/verifyMailCode/{account}/{email}")
@ResponseBody
public ResponseEntity<Void> verifyMailCode(@PathVariable("account") String account,
@PathVariable("email") String email){
readerService.verifyMailCode(account,email);
return ResponseEntity.ok().build();
}
}
package com.bookManagerment.interceptor;
public class UserLoginInterceptor implements HandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
System.out.println("UserLoginInterceptor");
// 判断session
HttpSession session = request.getSession();
// 从session中取出用户身份信息
Reader userInfo = (Reader)session.getAttribute("readerInfo");
// session存在时，放行
if (userInfo!=null) {
return true;
}
// 执行这里表示用户身份需要认证，跳转登陆页面
response.sendRedirect("/pages/login.jsp");
return false;
}
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
@Autowired
private BookMapper bookMapper;
@Autowired
private BMSystemProperties bmProperties;
@Autowired
private ReaderMapper readerMapper;
public Page<ReserveBorrowBooks> reserveBookByPage(Integer page, Integer size,
ReserveBorrowBooks reserveBorrowBook) {
boolean search = false;
if(!StringUtils.isEmpty(reserveBorrowBook.getBName()) ||
!StringUtils.isEmpty(reserveBorrowBook.getNumber()) ||
!StringUtils.isEmpty(reserveBorrowBook.getRName()) ) {
search = true;
}
List<ReserveBorrowBooks> reserveBorrowBooks = reserveBookMapper.queryReserveBorrowBooks(reserveBorrowBook);
if(CollectionUtils.isEmpty(reserveBorrowBooks)){
if(search){ //未搜索到符合条件的预借书记录
throw new LyException(ExceptionEnum.SEARCH_RESERVE_BOOK_NOT_FOUND);
}else{ //记录为空
throw new LyException(ExceptionEnum.RESERVE_BOOK_NOT_FOUND);
}
}
return new Page<ReserveBorrowBooks>(new PageInfo(reserveBorrowBooks));
}
//保存多个 借书记录 (借书)
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
public void saveReserves(List<Integer> resIds) {
for (Integer resId : resIds) {
//根据在 reserveBorrowBooks 表中查询数据
ReserveBorrowBooks reserveBorrowBooks = reserveBookMapper.selectByPrimaryKey(resId);
if(reserveBorrowBooks == null){ //预借书记录未找到！
throw new LyException(ExceptionEnum.RESERVE_NOT_FOUND);
}
//账户至少有 多少钱才能预定图书
Reader reader = readerMapper.selectByPrimaryKey(reserveBorrowBooks.getRId());
if(reader.getBalance()/100.0 < bmProperties.getBorrowBooksAccountLest()){
//抱歉，{r_name}用户，账户余额少于{balanceLess}元不能借书，请先充值!
ExceptionEnum em = ExceptionEnum.APPOINT_ACCOUNT_BALANCE_LESS;
em.setMsg(em.getMsg().replace("{balanceLess}",bmProperties.getBorrowBooksAccountLest()+"")
.replace("{r_name}",reader.getRName()));
public ResponseEntity<Void> modifyBookType(@RequestBody BookType bookType){
bookTypeService.modifyBookType(bookType);
return ResponseEntity.ok().build();
}
}
package com.bookManagerment.controller.mannager;
@RequestMapping("manager/reserveBorrow")
@RestController
public class MReserveBorrowBooksController {
@Autowired
private ReserveBorrowBooksService reserveBookService;
//分页查询 并可以带查询参数
@GetMapping("/{page}/{size}")
public ResponseEntity<Page<ReserveBorrowBooks>> borrowBookByPage(@PathVariable("page") Integer page,
@PathVariable("size") Integer size,
ReserveBorrowBooks reserveBorrowBooks){
return ResponseEntity.ok(reserveBookService.reserveBookByPage(page,size, reserveBorrowBooks));
}
//借书 一个
@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();
}
}
package com.bookManagerment.controller.reader;
Reader reader = (Reader) session.getAttribute(bmProperties.getReaderSessionName());
reader = readerMapper.selectByPrimaryKey(reader.getRId());
//根据 bId查询图书信息
Books books = bookMapper.selectByPrimaryKey(bId);
if(books == null){ //抱歉，该图书信息已失效，请刷新页面!
throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
}
//是否是开启状态
if(books.getStatus() == false){ //抱歉，该图书信息正在维护中，暂时不可借阅该图书，请您刷新页面！
throw new LyException(ExceptionEnum.BOOK_STATUS_FALSE);
}
//在馆数
books.setInLibraryTotal(books.getTotal()-borrowBookMapper.selectCount(new BorrowBooks(books.getBId())));
//预定数
books.setReserveNum(reserveBookMapper.selectCount(new ReserveBorrowBooks(books.getBId())));
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}天！
retValue = cookieList[i].getValue();
}
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);
}
}
//读者 预定借书
@Transactional
public Integer reserveBook(Integer bId, Integer rentDay, HttpSession session){
//读者信息
Reader reader = (Reader) session.getAttribute(bmProperties.getReaderSessionName());
reader = readerMapper.selectByPrimaryKey(reader.getRId());
//根据 bId查询图书信息
Books books = bookMapper.selectByPrimaryKey(bId);
if(books == null){ //抱歉，该图书信息已失效，请刷新页面!
throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
}
//是否是开启状态
if(books.getStatus() == false){ //抱歉，该图书信息正在维护中，暂时不可借阅该图书，请您刷新页面！
throw new LyException(ExceptionEnum.BOOK_STATUS_FALSE);
}
//在馆数
books.setInLibraryTotal(books.getTotal()-borrowBookMapper.selectCount(new BorrowBooks(books.getBId())));
//预定数
books.setReserveNum(reserveBookMapper.selectCount(new ReserveBorrowBooks(books.getBId())));
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);
Reader reader = readerMapper.selectByPrimaryKey(Integer.parseInt(map.get("rId")));
//存入session
request.getSession().setAttribute(bmProperties.getReaderSessionName(),reader);
//redis中删除订单
jedis.expire(out_trade_no,-1);
}
}
//——请在这里编写您的程序（以上代码仅作参考）——
}catch (Exception e){
e.printStackTrace();
}
}
//异步通知
@Transactional
public void notify(HttpServletRequest request, HttpServletResponse response) {
response.setContentType("text/html;charset=UTF-8");
try {
//获取支付宝POST过来反馈信息
Map<String, String> params = getParams(request.getParameterMap());
boolean signVerified = AlipaySignature.rsaCheckV1(params, AlipayConfig.alipay_public_key, AlipayConfig.charset, AlipayConfig.sign_type); //调用SDK验证签名
if (signVerified) {//验证成功
//商户订单号
String out_trade_no = new String(request.getParameter("out_trade_no").getBytes("ISO-8859-1"), "UTF-8");
//交易状态
String trade_status = new String(request.getParameter("trade_status").getBytes("ISO-8859-1"), "UTF-8");
//交易金额
Double total_amount = Double.parseDouble(new String(request.getParameter("total_amount").getBytes("ISO-8859-1"), "UTF-8"));
if (trade_status.equals("TRADE_FINISHED")) {
} else if (trade_status.equals("TRADE_SUCCESS")) {
//获取订单信息
Map<String, String> map = jedis.hgetAll(out_trade_no);
if(!CollectionUtils.isEmpty(map)){ //订单未失效
if(map.get("status").equals("false")){ //订单未支付
//根据rId查询用户信息
Reader reader = readerMapper.selectByPrimaryKey(Integer.valueOf(map.get("rId")));
if(reader!=null){ //用户信息存在
//增加账户金额
reader.setBalance(reader.getBalance()+(int)(total_amount*100));
//持久化数据
readerMapper.updateByPrimaryKey(reader);
//设置订单已支付
map.replace("status","true");
//redis中设置订单已支付
jedis.hmset(out_trade_no,map);
}
}
}
}
} else {//验证失败
}
} catch (Exception e) {
String account = CookieUtils.getCookieValue(request, bmProperties.getAutoCookieName());
if(StringUtils.isBlank(account)){ //空字符串 删除该cookie
CookieUtils.deleteCookie(request,response, bmProperties.getAutoCookieName(),request.getContextPath()+ bmProperties.getCookiePath()); //用户端删除该cookie
return false;
}
//查询账户是否存在
List<Reader> readers = readerMapper.select(new Reader(account));
if(CollectionUtils.isEmpty(readers)){ //未查询到 登录失败 用户账户不存在
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);
}
}
package com.bookManagerment.service;
@Service
public class MailTemplateService {
@Autowired
private MailTemplateMapper templateMapper;
@Autowired
private BorrowBookMapper borrowBookMapper;
@Autowired
@RequestMapping("register")
@RestController
public class RegisterController {
@Autowired
private ReaderService readerService;
//用户名是否存在
@PostMapping("/account/{accountName}")
@ResponseBody
public ResponseEntity<Void> accountName(@PathVariable("accountName") String accountName){
readerService.accountNameExist(accountName);
return ResponseEntity.ok().build();
}
//用户注册
@PostMapping
@ResponseBody
public ResponseEntity<Void> registerReader(@RequestBody Reader reader){
reader.builderReader();
readerService.saveReader(reader);
return ResponseEntity.ok().build();
}
//发送邮箱验证码
@PostMapping("/verifyMailCode/{account}/{email}")
@ResponseBody
public ResponseEntity<Void> verifyMailCode(@PathVariable("account") String account,
@PathVariable("email") String email){
readerService.verifyMailCode(account,email);
return ResponseEntity.ok().build();
}
}
package com.bookManagerment.interceptor;
}
//修改图书
@PutMapping
public ResponseEntity<Void> modifyBook(@RequestBody Books books){
bookService.modifyBook(books);
return ResponseEntity.ok().build();
}
//修改图书的状态
@PutMapping("/{bId}/{status}")
public ResponseEntity<Void> modifyBookStatus(@PathVariable("bId") Integer bId,
@PathVariable("status") Boolean status){
bookService.modifyBookStatus(bId,status);
return ResponseEntity.ok().build();
}
//修改图书的总数量
@PutMapping("/total/{bId}/{total}")
public ResponseEntity<Void> modifyBookTotal(@PathVariable("bId") Integer bId,
@PathVariable("total") Integer total){
bookService.modifyBookTotal(bId,total);
return ResponseEntity.ok().build();
}
// //删除图书 多个
@DeleteMapping
public ResponseEntity<Void> deleteBookBybIds(@RequestBody List<Integer> ids){
bookService.deleteBookBybIds(ids);
return ResponseEntity.ok().build();
}
//删除图书 一个
@DeleteMapping("/{bId}")
public ResponseEntity<Void> deleteBookBybId(@PathVariable("bId") Integer bId){
bookService.deleteBookBybIds(Arrays.asList(bId));
return ResponseEntity.ok().build();
}
}
package com.bookManagerment.controller.mannager;
bookService.modifyBookStatus(bId,status);
return ResponseEntity.ok().build();
}
//修改图书的总数量
@PutMapping("/total/{bId}/{total}")
public ResponseEntity<Void> modifyBookTotal(@PathVariable("bId") Integer bId,
@PathVariable("total") Integer total){
bookService.modifyBookTotal(bId,total);
return ResponseEntity.ok().build();
}
// //删除图书 多个
@DeleteMapping
public ResponseEntity<Void> deleteBookBybIds(@RequestBody List<Integer> ids){
bookService.deleteBookBybIds(ids);
return ResponseEntity.ok().build();
}
//删除图书 一个
@DeleteMapping("/{bId}")
public ResponseEntity<Void> deleteBookBybId(@PathVariable("bId") Integer bId){
bookService.deleteBookBybIds(Arrays.asList(bId));
return ResponseEntity.ok().build();
}
}
package com.bookManagerment.controller.mannager;
@RequestMapping("/manager/mail")
@RestController
@RequestMapping("/all")
public ResponseEntity<List<BookType>> bookTypeListAll(){
return ResponseEntity.ok(bookTypeService.bookTypeListAll());
}
//添加图书分类
@PostMapping("/{tName}")
public ResponseEntity<Void> addBookType(@PathVariable("tName") String tName){
bookTypeService.addBookType(tName);
return ResponseEntity.status(HttpStatus.CREATED).build();
}
//删除多个图书分类
@DeleteMapping
public ResponseEntity<Void> deleteBookTypes(@RequestBody List<Integer> ids ){
bookTypeService.deleteBookTypes(ids);
return ResponseEntity.ok().build();
}
//删除一个图书分类
@DeleteMapping("/{btId}")
public ResponseEntity<Void> deleteBookType(@PathVariable("btId") Integer btId ){
bookTypeService.deleteBookTypes(Arrays.asList(btId));
return ResponseEntity.ok().build();
}
//修改一个图书分类
@PutMapping
public ResponseEntity<Void> modifyBookType(@RequestBody BookType bookType){
bookTypeService.modifyBookType(bookType);
return ResponseEntity.ok().build();
}
}
package com.bookManagerment.controller.mannager;
@RequestMapping("manager/reserveBorrow")
@RestController
//将用户的登录信息保存到 session 中
saveReaderToSession(request,reader);
return "pages/reader/bookDatalist.jsp";
}
//管理员登录
public String loginManager(LoginVo loginVo,HttpServletRequest request){
//根据用户名和密码到管理员表中查询
Example example = new Example(Manager.class);
Example.Criteria criteria = example.createCriteria();
criteria.andEqualTo("account",loginVo.getAccount());
criteria.andEqualTo("password",loginVo.getPassword());
List<Manager> managers = managerMapper.selectByExample(example);
if(CollectionUtils.isEmpty(managers)){
throw new LyException(ExceptionEnum.LOGIN_ACCOUNT_OR_PASSWORD);
}
//设置session
HttpSession session = request.getSession();
session.setAttribute(bmProperties.getManagerSessionName(),managers.get(0));
return "pages/manager/bookDatalist.jsp";
}
//读者自动登录
@Transactional
public Boolean autoLoginReader(HttpServletResponse response, HttpServletRequest request) {
//获取账户名 （编码）
String account = CookieUtils.getCookieValue(request, bmProperties.getAutoCookieName());
if(StringUtils.isBlank(account)){ //空字符串 删除该cookie
CookieUtils.deleteCookie(request,response, bmProperties.getAutoCookieName(),request.getContextPath()+ bmProperties.getCookiePath()); //用户端删除该cookie
return false;
}
//查询账户是否存在
List<Reader> readers = readerMapper.select(new Reader(account));
if(CollectionUtils.isEmpty(readers)){ //未查询到 登录失败 用户账户不存在
CookieUtils.deleteCookie(request,response, bmProperties.getAutoCookieName(),request.getContextPath()+ bmProperties.getCookiePath()); //用户端删除该cookie
return false;
}
//将用户信息存入session中
saveReaderToSession(request,readers.get(0));
return true;
Reader reader = (Reader) session.getAttribute(bmProperties.getReaderSessionName());
reserveGiveBack.setRName(reader.getRName());
return ResponseEntity.ok(giveBackBookService.giveBackBook(page,size, reserveGiveBack,true));
}
}
package com.bookManagerment.controller.reader;
@RequestMapping("/reader/borrowBook")
@RestController
public class RBorrowBookController {
@Autowired
private BorrowBookService borrowBookService;
@Autowired
private BMSystemProperties bmProperties;
//分页查询 并可以带查询参数
@GetMapping("/{page}/{size}")
public ResponseEntity<Page<BorrowBooks>> borrowBookByPage(@PathVariable("page") Integer page,
@PathVariable("size") Integer size,
BorrowBooks borrowBooks,
HttpSession session){
Reader reader = (Reader) session.getAttribute(bmProperties.getReaderSessionName());
borrowBooks.setRName(reader.getRName());
return ResponseEntity.ok(borrowBookService.borrowBookByPage(page,size, borrowBooks,true));
}
}
package com.bookManagerment.controller.reader;
e.printStackTrace();
}
}
//获取参数
private Map<String, String> getParams(Map<String, String[]> requestParams){
Map<String, String> params = new HashMap<String, String>();
for (Iterator<String> iter = requestParams.keySet().iterator(); iter.hasNext(); ) {
String name = (String) iter.next();
String[] values = (String[]) requestParams.get(name);
String valueStr = "";
for (int i = 0; i < values.length; i++) {
valueStr = (i == values.length - 1) ? valueStr + values[i]
: valueStr + values[i] + ",";
}
//乱码解决，这段代码在出现乱码时使用
// valueStr = new String(valueStr.getBytes("ISO-8859-1"), "utf-8");
params.put(name, valueStr);
}
return params;
}
public Double refreshMoney(HttpServletRequest request) {
Reader reader = (Reader) request.getSession().getAttribute(bmProperties.getReaderSessionName());
Reader reader1 = readerMapper.selectByPrimaryKey(reader.getRId());
if(reader.getBalance() != reader1.getBalance()){
request.getSession().setAttribute(bmProperties.getReaderSessionName(),reader1);
}
return reader1.getBalance()/100.0;
}
}
package com.bookManagerment.service;
}
} 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的值 不设置生效时间,但编码
*/
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,"/");
}
/**
* 删除Cookie带cookie域名
*/
public static void deleteCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,String path) {
doSetCookie(request, response, cookieName, "", -1, false,path);
}
//分页查询 并可以带查询参数
@GetMapping("/{page}/{size}")
public ResponseEntity<Page<ReserveBorrowBooks>> borrowBookByPage(@PathVariable("page") Integer page,
@PathVariable("size") Integer size,
ReserveBorrowBooks reserveBorrowBooks){
return ResponseEntity.ok(reserveBookService.reserveBookByPage(page,size, reserveBorrowBooks));
}
//借书 一个
@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();
}
}
package com.bookManagerment.controller.reader;
@RequestMapping("reader/giveBack")
@RestController
public class RGiveBackController {
@Autowired
public void saveReserves(List<Integer> resIds) {
for (Integer resId : resIds) {
//根据在 reserveBorrowBooks 表中查询数据
ReserveBorrowBooks reserveBorrowBooks = reserveBookMapper.selectByPrimaryKey(resId);
if(reserveBorrowBooks == null){ //预借书记录未找到！
throw new LyException(ExceptionEnum.RESERVE_NOT_FOUND);
}
//账户至少有 多少钱才能预定图书
Reader reader = readerMapper.selectByPrimaryKey(reserveBorrowBooks.getRId());
if(reader.getBalance()/100.0 < bmProperties.getBorrowBooksAccountLest()){
//抱歉，{r_name}用户，账户余额少于{balanceLess}元不能借书，请先充值!
ExceptionEnum em = ExceptionEnum.APPOINT_ACCOUNT_BALANCE_LESS;
em.setMsg(em.getMsg().replace("{balanceLess}",bmProperties.getBorrowBooksAccountLest()+"")
.replace("{r_name}",reader.getRName()));
throw new LyException(em);
}
//根据 bId查询图书信息 获取图书的基础租金，逾期租金单位
Books book = bookMapper.selectByPrimaryKey(reserveBorrowBooks.getBId());
//将数据插入 borrow_books表中
BorrowBooks borrowBook = new BorrowBooks(reserveBorrowBooks);
borrowBookMapper.insert(borrowBook);
//将预约借书 该预记录删除
reserveBookMapper.deleteByPrimaryKey(resId);
//持久化数据
bookMapper.updateByPrimaryKey(book);
}
}
//读者 预定借书
@Transactional
public Integer reserveBook(Integer bId, Integer rentDay, HttpSession session){
//读者信息
Reader reader = (Reader) session.getAttribute(bmProperties.getReaderSessionName());
reader = readerMapper.selectByPrimaryKey(reader.getRId());
//根据 bId查询图书信息
Books books = bookMapper.selectByPrimaryKey(bId);
if(books == null){ //抱歉，该图书信息已失效，请刷新页面!
throw new LyException(ExceptionEnum.BOOK_INFO_LOSE);
}
//是否是开启状态
if(books.getStatus() == false){ //抱歉，该图书信息正在维护中，暂时不可借阅该图书，请您刷新页面！
throw new LyException(ExceptionEnum.BOOK_STATUS_FALSE);
}
//在馆数
books.setInLibraryTotal(books.getTotal()-borrowBookMapper.selectCount(new BorrowBooks(books.getBId())));
//预定数
books.setReserveNum(reserveBookMapper.selectCount(new ReserveBorrowBooks(books.getBId())));
if(books.getInLibraryTotal() <= 0){ //抱歉，该图书已全部借出！
throw new LyException(ExceptionEnum.SORRY_BOOK_BORROW_ALL);
}
@Service
public class LoginService {
@Autowired
private ReaderMapper readerMapper;
@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);
}
//获取数据库中的读者信息
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);
}
}
}
package com.bookManagerment.utils;
/**
*
private MailTemplateService templateService;
/**
* 获取邮箱占位符
* @return
*/
@GetMapping("/mailSetBtn")
public ResponseEntity<List<MailSymbol>> getMailSetBtn(){
return ResponseEntity.ok(symbolService.getMailSymbol());
}
/**
* 根据id获取邮箱模板
* @param id
* @return
*/
@GetMapping("/mailTemplate/{id}")
public ResponseEntity<MailTemplate> getMailTemplate(@PathVariable("id") Integer id){
return ResponseEntity.ok(templateService.getMailTemplate(id));
}
/**
* 根据id修改邮箱模板
* @param id
* @param template
* @return
*/
@PutMapping("/mailTemplate/{id}")
public ResponseEntity<Void> modifyMailTemplate(@PathVariable("id") Integer id,
@RequestBody String template){
templateService.modifyMailTemplate(id,template);
return ResponseEntity.ok().build();
}
/**
* 根据id修改默认邮箱模板
* @param id
* @param defaultTemplate
* @return
*/
@PutMapping("/mailTemplate/default/{id}")
public ResponseEntity<Void> modifyMailDefaultTemplate(@PathVariable("id") Integer id,
@RequestBody String defaultTemplate){
templateService.modifyMailDefaultTemplate(id,defaultTemplate);
return ResponseEntity.ok().build();
}
//提醒还书
@PostMapping("/remind/{bbId}")
public ResponseEntity<Void> remind(@PathVariable("bbId") Integer bbId){
return true;
}
// 执行这里表示用户身份需要认证，跳转登陆页面
response.sendRedirect("/pages/login.jsp");
return false;
}
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}
}
package com.bookManagerment.controller;
@RequestMapping("register")
@RestController
public class RegisterController {
@Autowired
private ReaderService readerService;
//用户名是否存在
@PostMapping("/account/{accountName}")
@ResponseBody
public ResponseEntity<Void> accountName(@PathVariable("accountName") String accountName){
readerService.accountNameExist(accountName);
return ResponseEntity.ok().build();
}
//用户注册
@PostMapping
@ResponseBody
public ResponseEntity<Void> registerReader(@RequestBody Reader reader){
reader.builderReader();
readerService.saveReader(reader);
return ResponseEntity.ok().build();
}
//发送邮箱验证码
@PostMapping("/verifyMailCode/{account}/{email}")
//分页查询 并可以带查询参数
@GetMapping("/{page}/{size}")
public ResponseEntity<Page<ReserveBorrowBooks>> borrowBookByPage(@PathVariable("page") Integer page,
@PathVariable("size") Integer size,
ReserveBorrowBooks reserveBorrowBooks,
HttpServletRequest request){
//获取当前用户
Reader reader = (Reader)request.getSession().getAttribute(bmProperties.getReaderSessionName());
reserveBorrowBooks.setRName(reader.getRName()); //根据当前用户查找
return ResponseEntity.ok(reserveBookService.reserveBookByPage(page,size, reserveBorrowBooks));
}
//读者修改 借阅天数
@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));
}
}
package com.bookManagerment.controller.mannager;
1010
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
