基于javaweb+mysql的ssm+maven网上图书商城系统(java+ssm+jsp+mysql+redis+easyui)
运行环境
Java≥8、MySQL≥5.7、Tomcat≥8
开发工具
eclipse/idea/myeclipse/sts等均可配置运行
适用
课程设计，大作业，毕业设计，项目练习，学习演示等
功能说明
基于javaweb+mysql的SSM+Maven网上图书商城系统(java+ssm+jsp+mysql+redis+easyui)
这个项目涉及到Shiro整合JWT、秒杀功能所具备的基本要求(限流、乐观锁、接口隐藏、JMeter高并发测试等等)、消息中间件RabbitMQ的异步邮件通知和死信队列、沙箱支付宝模拟支付等等技术亮点。
项目功能：该项目分为买家、卖家、管理员三个角色。买家角色的功能：登录、注册、浏览图书、管理购物车、结算订单、支付订单、查看订单、修改个人信息等等功能。
卖家角色的功能：登录、注册、浏览商品、管理自己发布的图书、管理收到的订单、查看自己的收益详情等等。管理员角色的功能：登录、管理所有用户信息、管理权限信息、管理所有卖家发布的图书、管理所有订单信息、管理所有支付信息、查看总共收益详情等等。
应用技术：SSM + Jsp + MySQL + Redis + JWT + Shiro + EasyUI等
运行环境：Eclipse/IntelliJ IDEA + MySQL5.7 + Maven3.6.3+ JDK1.8 + Redis5.0.5+ Tomcat8.5 +
public ResponseVo<Boolean> edit(Book book, String time){
return bookService.editBook(book, time);
}
/**
* 删除图书信息操作处理
* @param ids
* @return
*/
@PostMapping("/admin/book/delete")
@ResponseBody
public ResponseVo<Boolean> delete(String ids){
return bookService.deleteBook(ids);
}
/**
* 设置图书秒杀信息操作处理
* @param id
* @param isKill
* @param time
* @param newPrice
* @return
*/
@PostMapping("/admin/book/set_kill")
@ResponseBody
public ResponseVo<Boolean> setKill(String id, Integer isKill, String time, BigDecimal newPrice){
return bookService.setKill(id, isKill, time, newPrice);
}
/**
* 下架图书操作处理
* @param id
* @return
*/
@PostMapping("/admin/book/off_shelves")
@ResponseBody
public ResponseVo<Boolean> offShelves(String id){
return bookService.offShelves(id);
}
/**
* 上架图书操作处理
* @param id
* @return
*/
Map<String, Object> ret = new HashMap<>();
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
Map<String, Object> queryMap = new HashMap<>();
if(page != null){
page.setRows(1); //每页1条数据
queryMap.put("offset", page.getOffset());
queryMap.put("pageSize", page.getRows());
}
queryMap.put("customerId", user.getId());
queryMap.put("isDeleted", OrderDeleteEnum.NO.getCode());
List<Order> orderList = orderDao.selectAll(queryMap);
ret.put("orderList", orderList);
ret.put("page", page.getPage());
ret.put("totalCount", orderDao.getAllTotal(queryMap));
page.setTotalCount(orderDao.getAllTotal(queryMap));
ret.put("totalPage", page.getTotalPage());
ret.put("sendTotal", orderDao.getCountByOrderState(user.getId(), OrderStateEnum.SEND.getCode()));
ret.put("signTotal", orderDao.getCountByOrderState(user.getId(), OrderStateEnum.SIGN.getCode()));
return ResponseVo.success(ret);
}
@Override
public ResponseVo<Boolean> delOrderByUser(String orderId) {
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
if(CommonUtil.isEmpty(orderId)){
return ResponseVo.errorByMsg(CodeMsg.DATA_ERROR);
}
Order selectedOrder = orderDao.selectById(orderId);
if(selectedOrder == null){
return ResponseVo.errorByMsg(CodeMsg.ORDER_NOT_EXIST);
}
selectedOrder.setCustomerDelete(OrderDeleteEnum.YES.getCode());
if(orderDao.updateById(selectedOrder) <= 0){
return ResponseVo.errorByMsg(CodeMsg.ORDER_DELETE_ERROR);
}
return ResponseVo.successByMsg(true, "成功删除订单！");
}
@Override
public Map<String, Object> getOrderList(Page page, String customerName, String sellerName, Integer state, String orderNo) {
Map<String, Object> ret = new HashMap<>();
Map<String, Object> queryMap = new HashMap<>();
if(!CommonUtil.isEmpty(customerName)){
queryMap.put("customerName", customerName);
}
*/
/**
* 验证码Captcha控制类
*/
@Controller
public class CaptchaController {
private Logger log = LoggerFactory.getLogger(CaptchaController.class);
/**
* 通用验证码生成器
* @param vcodeLength
* @param fontSize
* @param width
* @param height
* @param method
* @param request
* @param response
*/
@GetMapping(value="/common/captcha/generate_captcha")
public void generateCaptcha(
@RequestParam(name="vl",defaultValue="4")Integer vcodeLength,//vcodeLength,验证码长度
@RequestParam(name="fs",defaultValue="21")Integer fontSize,//fontSize,验证码字体大小
@RequestParam(name="w",defaultValue="98")Integer width,//width,图片宽度
@RequestParam(name="h",defaultValue="33")Integer height,//height,图片高度
@RequestParam(name="method")String method,//用来调用此方法的名称，以此名称为键，存入到session中
HttpServletRequest request,
HttpServletResponse response){
CaptchaUtil captchaUtil = new CaptchaUtil(vcodeLength,fontSize,width,height);
String generatorVCode = captchaUtil.generatorVCode(); //验证码的值
//将生成的验证码放入session，以供放后面程序的验证使用
request.getSession().setAttribute(method, generatorVCode);
log.info("验证码成功生成，method=" + method + ",value=" + generatorVCode);
try {
ImageIO.write(captchaUtil.generatorRotateVCodeImage(generatorVCode, true), "gif", response.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
}
package com.yjq.programmer.controller.admin;
@ResponseBody
public ResponseVo<Boolean> delOrderByUser(String orderId){
return orderService.delOrderByUser(orderId);
}
}
package com.yjq.programmer.exception;
/**
*/
/**
* 运行时触发异常捕获
*/
@ControllerAdvice
public class RuntimeExceptionHandler {
private final Logger logger = LoggerFactory.getLogger(RuntimeExceptionHandler.class);
@ExceptionHandler(RuntimeException.class)
@ResponseBody
public ResponseVo<Boolean> handle(RuntimeException e) {
e.printStackTrace();
if(!CommonUtil.isEmpty(e.getMessage())){
logger.info("异常信息={}", e.getMessage());
if("提交订单失败，请稍后重试！".equals(e.getMessage())){
return ResponseVo.errorByMsg(CodeMsg.SUBMIT_ORDER_ERROR);
}else if(e.getMessage().contains("售罄")){
CodeMsg codeMsg = CodeMsg.STOCK_SOLD_OUT;
codeMsg.setMsg(e.getMessage());
// //签名方式
// private final String SIGN_TYPE = "RSA2";
// //支付宝异步通知路径,付款完毕后会异步调用本项目的方法,必须为公网地址
// private final String NOTIFY_URL = "http://localhost:8080/OnlineBookShop/common/alipay/returnUrl";
// //支付宝同步通知路径,也就是当付款完毕后跳转本项目的页面,可以不是公网地址
// private final String RETURN_URL = "http://localhost:8080/OnlineBookShop/common/alipay/returnUrl";
// //==========================这些信息未经作者允许，不允许分享使用！！！=================================
//
// private final Logger logger = LoggerFactory.getLogger(AliPayController_backup.class);
//
// @Autowired
// private PayDao payDao;
//
// @Autowired
// private ICartService cartService;
//
// @Autowired
// private OrderDao orderDao;
//
// @Autowired
// private IOrderService orderService;
//
// @Autowired
// private IPayService payService;
//
// @Autowired
// private IPayItemService payItemService;
//
// @Autowired
// private IBookService bookService;
//
@Autowired
private AmqpTemplate amqpTemplate;
//
// /**
// * 支付页面
// * @param req
// * @param httpResponse
// * @throws IOException
// */
// @GetMapping("/common/alipay/pay")
// public void alipay(HttpServletRequest req, HttpServletResponse httpResponse) throws IOException {
return null;
}
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(obj);
return bo.toByteArray();
}
/**
* 字节码转化为对象
* @param objBytes
* @return
* @throws Exception
*/
public static Object getObjectFromBytes(byte[] objBytes) throws Exception {
if (objBytes == null || objBytes.length == 0) {
return null;
}
ByteArrayInputStream bi = new ByteArrayInputStream(objBytes);
ObjectInputStream oi = new ObjectInputStream(bi);
return oi.readObject();
}
/**
* 判断后缀是否是图片文件的后缀
* @param suffix
* @return
*/
public static boolean isPhoto(String suffix){
if("jpg".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else if("png".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else if("gif".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else if("jpeg".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else{
return false;
}
}
/**
* 返回指定格式的日期
@GetMapping("/home/book/more")
public String more(){
return "home/book/more";
}
/**
* 前台图书详情展示页面
* @param model
* @param id
* @return
*/
@GetMapping("/home/book/info")
public String info(Model model, String id){
return bookService.toBookInfo(model, id);
}
/**
* 前往搜索查询结果页面
* @return
*/
@GetMapping("/home/book/search")
public String search(){
return "home/book/search";
}
/**
* 前台搜索图书操作处理
* @param searchContent
* @return
*/
@PostMapping("/home/book/search")
@ResponseBody
public ResponseVo<List<Book>> getSearchBook(String searchContent){
return bookService.getSearchBook(searchContent);
}
/**
* 前台前往更多图书页面前数据加载
* @return
*/
@PostMapping("/home/book/more")
@ResponseBody
public ResponseVo<List<Book>> getMoreBook(){
return bookService.getMoreBook();
}
/**
* 前台首页图书展示
* @return
*/
@PostMapping("/home/book/index")
@ResponseBody
// AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
// //在公共参数中设置回跳和通知地址
// request.setReturnUrl(RETURN_URL);
// //request.setNotifyUrl(NOTIFY_URL);
//
// //发送RabbitMQ异步消息 5分钟后检查是否已支付成功，如果没有，则取消订单
try{
//将Java对象匹配JSON结构
//对象转化为字节码 把对象转化为字节码后，把字节码传输过去再转化为对象
byte[] bytes = CommonUtil.getBytesFromObject(selectedPay);
//发送消息
amqpTemplate.convertAndSend("my_normal_exchange", "my_ttl_dlx", bytes);
}catch (Exception e){
//邮件发送失败
e.printStackTrace();
}
//
//
// //商户订单号，商户网站订单系统中唯一订单号，必填
// //生成随机Id
// String out_trade_no = selectedPay.getPayNo();
// //付款金额，必填
// String total_amount = String.valueOf(selectedPay.getTotalAmount());
// //订单名称，必填
// String subject ="网上图书商城订单支付";
// //商品描述，可空
// String body = "尊敬的用户："+user.getUsername()+"，欢迎您在网上图书商城下单！";
// request.setBizContent("{\"out_trade_no\":\""+ out_trade_no +"\","
// + "\"total_amount\":\""+ total_amount +"\","
// + "\"subject\":\""+ subject +"\","
// + "\"body\":\""+ body +"\","
// + "\"timeout_express\":\""+"5m"+"\","
// + "\"product_code\":\"FAST_INSTANT_TRADE_PAY\"}");
// String form = "";
// try {
// form = alipayClient.pageExecute(request).getBody(); // 调用SDK生成表单
// } catch (AlipayApiException e) {
// e.printStackTrace();
// }
// httpResponse.setContentType("text/html;charset=" + CHARSET);
return ResponseVo.errorByMsg(CodeMsg.BOOK_NOT_EXIST);
}
if(selectedBook.get(0).getStock() == null){
return ResponseVo.errorByMsg(CodeMsg.STOCK_NOT_EXIST);
}
//判断库存是否满足用户选择购买的数量
if(selectedBook.get(0).getStock().getCount() < cart.getQuantity()){
return ResponseVo.errorByMsg(CodeMsg.STOCK_NOT_ENOUGH);
}
QueryWrapper<Cart> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("user_id", user.getId());
//判断该用户的购物车是否小等于100种图书
List<Cart> selectedCartByUser = cartDao.selectList(queryWrapper);
if(selectedCartByUser.size() > 100){
return ResponseVo.errorByMsg(CodeMsg.CART_NUM_OUT_LIMIT);
}
//判断该图书是否是参与秒杀的图书，如果是，判断当前是否已超过秒杀时间
if(BookIsKillEnum.YES.getCode().equals(selectedBook.get(0).getIsKill())){
if(CommonUtil.getTimeStamp(new Date()) > CommonUtil.getTimeStamp(selectedBook.get(0).getKillEnd())){
return ResponseVo.errorByMsg(CodeMsg.KILL_END_EXPIRED);
}
}
//判断购物车中是否已有此图书
queryWrapper.eq("book_id", cart.getBookId());
Cart selectedCart = cartDao.selectOne(queryWrapper);
if(selectedCart != null){
selectedCart.setQuantity(cart.getQuantity() + selectedCart.getQuantity());
//已存在，则加上对应数量
if(cartDao.updateById(selectedCart) < 0){
return ResponseVo.errorByMsg(CodeMsg.CART_ADD_ERROR);
}
}else{
//添加数据库中的购物车信息
if(cartDao.insert(cart) < 0){
return ResponseVo.errorByMsg(CodeMsg.CART_ADD_ERROR);
}
}
return ResponseVo.successByMsg(true, "添加购物车成功！");
}
@Override
public ResponseVo<List<Cart>> getCartByUser() {
//获取当前登录的用户
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
//获取当前登录用户的所有购物车数据
Map<String, Object> queryMap = new HashMap<>();
queryMap.put("userId", user.getId());
public ResponseVo<Boolean> add(Authority authority){
return authorityService.addAuthority(authority);
}
/**
* 修改权限信息操作处理
* @param authority
* @return
*/
@PostMapping("/admin/authority/edit")
@ResponseBody
public ResponseVo<Boolean> edit(Authority authority){
return authorityService.editAuthority(authority);
}
/**
* 修改权限信息操作处理
* @param ids
* @return
*/
@PostMapping("/admin/authority/delete")
@ResponseBody
public ResponseVo<Boolean> delete(String ids){
return authorityService.deleteAuthority(ids);
}
}
package com.yjq.programmer.controller.admin;
/**
*/
@PostMapping("/admin/book/edit_state")
@ResponseBody
public ResponseVo<Boolean> editState(String id, Integer state){
return bookService.editState(id, state);
}
}
package com.yjq.programmer.controller.admin;
/**
*/
/**
* 后台用户User控制类
*/
@Controller
public class UserController {
@Autowired
private IUserService userService;
/**
* 后台用户登录页面
* @return
*/
@GetMapping("/admin/user/login")
public String login(){
return "admin/user/login";
}
/**
* 后台用户登录操作处理
* @param user
* @param request
* @param captcha
}
/**
* 后台用户登录操作处理
* @param user
* @param request
* @param captcha
* @return
*/
@PostMapping("/admin/user/login")
@ResponseBody
public ResponseVo<String> login(User user, HttpServletRequest request, String captcha){
String correctCaptcha = (String) request.getSession().getAttribute("admin_login");
return userService.adminLogin(user, captcha, correctCaptcha);
}
/**
* 后台用户退出登录操作处理
* @return
*/
@PostMapping("/admin/user/logout")
@ResponseBody
public ResponseVo<Boolean> logout(){
return userService.logout();
}
/**
* 后台用户修改密码操作处理
* @param prePassword
* @param newPassword
* @param reNewPassword
* @return
*/
@PostMapping("/admin/user/modify_passwd")
@ResponseBody
public ResponseVo<Boolean> modifyPassword(String prePassword, String newPassword, String reNewPassword){
return userService.updatePassword(prePassword, newPassword, reNewPassword);
}
/**
* 后台用户列表页面
* @return
*/
@GetMapping("/admin/user/list")
public String list(){
return "admin/user/list";
}
@Autowired
private IUserService userService;
//用户和图书MD5加密的redis键名模板
private static final String USER_BOOK_KEY_TEMPLATE = "user_%d_book_%d";
//盐
private static final String salt = "yang yang ya";
//创建令牌桶实例
private RateLimiter rateLimiter = RateLimiter.create(10); //1s向令牌桶中放置10个令牌
private final Logger logger = LoggerFactory.getLogger(CartServiceImpl.class);
@Override
public ResponseVo<Boolean> addCart(Cart cart, HttpServletRequest request) {
//限流处理 设置一个等待时间,如果在等待的时间内获取到了token 令牌,则处理业务,如果在等待时间内没有获取到响应token则抛弃
if(!rateLimiter.tryAcquire(2, TimeUnit.SECONDS)){
//2s内没获取到令牌桶中的令牌，选择抛弃
logger.info("请求被限流，直接抛弃......");
return ResponseVo.errorByMsg(CodeMsg.REQUEST_LIMIT);
}
logger.info("接收请求，执行后续业务......");
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
//判断当前用户在一定时间内的访问次数，为0次则用户数据异常
int count = userService.saveUserCount(user.getId());
if(count == 0){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
//大于10次则拒绝访问
if(count > 10){
return ResponseVo.errorByMsg(CodeMsg.REQUEST_COUNT_MANY);
}
cart.setUserId(user.getId());
//进行统一表单验证
CodeMsg validate = ValidateEntityUtil.validate(cart);
if(!validate.getCode().equals(CodeMsg.SUCCESS.getCode())){
return ResponseVo.errorByMsg(validate);
}
package com.yjq.programmer.controller.admin;
/**
*/
/**
* 权限Authority控制类
*/
@Controller
public class AuthorityController {
@Autowired
private IAuthorityService authorityService;
/**
* 后台权限列表页面
* @return
*/
@GetMapping("/admin/authority/list")
public String list(){
return "admin/authority/list";
}
/**
* 获取权限列表信息
* @param page
* @param rows
* @param roleId
// }
// String payId = (String) req.getSession().getAttribute(RuntimeConstant.payIdSession);
// if(CommonUtil.isEmpty(payId)){
// throw new RuntimeException("支付会话失效，请重新操作！");
// }
// QueryWrapper<Pay> queryWrapper = new QueryWrapper<>();
// queryWrapper.eq("user_id", user.getId());
// queryWrapper.eq("id", payId);
// Pay selectedPay = payDao.selectOne(queryWrapper);
// if(selectedPay == null){
// throw new RuntimeException("数据非法，支付失败，请重新操作！");
// }
// Random r = new Random();
// //实例化客户端,填入所需参数
// AlipayClient alipayClient = new DefaultAlipayClient(GATEWAY_URL, APP_ID, APP_PRIVATE_KEY, FORMAT, CHARSET, ALIPAY_PUBLIC_KEY, SIGN_TYPE);
// AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
// //在公共参数中设置回跳和通知地址
// request.setReturnUrl(RETURN_URL);
// //request.setNotifyUrl(NOTIFY_URL);
//
// //发送RabbitMQ异步消息 5分钟后检查是否已支付成功，如果没有，则取消订单
try{
//将Java对象匹配JSON结构
//对象转化为字节码 把对象转化为字节码后，把字节码传输过去再转化为对象
byte[] bytes = CommonUtil.getBytesFromObject(selectedPay);
//发送消息
amqpTemplate.convertAndSend("my_normal_exchange", "my_ttl_dlx", bytes);
}catch (Exception e){
//邮件发送失败
e.printStackTrace();
}
//
//
// //商户订单号，商户网站订单系统中唯一订单号，必填
// //生成随机Id
// String out_trade_no = selectedPay.getPayNo();
// //付款金额，必填
// String total_amount = String.valueOf(selectedPay.getTotalAmount());
// //订单名称，必填
// String subject ="网上图书商城订单支付";
// //商品描述，可空
* 后台添加用户信息操作处理
* @param user
* @return
*/
@PostMapping("/admin/user/add")
@ResponseBody
public ResponseVo<Boolean> add(User user){
return userService.addUser(user);
}
/**
* 后台修改用户信息操作处理
* @param user
* @return
*/
@PostMapping("/admin/user/edit")
@ResponseBody
public ResponseVo<Boolean> edit(User user){
return userService.editUser(user);
}
/**
* 后台删除用户信息操作处理
* @param ids
* @return
*/
@PostMapping("/admin/user/delete")
@ResponseBody
public ResponseVo<Boolean> delete(String ids){
return userService.deleteUser(ids);
}
}
package com.yjq.programmer.controller.home;
if(photo == null){
return ResponseVo.errorByMsg(CodeMsg.PHOTO_EMPTY);
}
//检查上传文件大小 不能超过10MB
if(photo.getSize() > 10*1024*1024) {
return ResponseVo.errorByMsg(CodeMsg.PHOTO_SURPASS_MAX_SIZE);
}
//获取文件后缀
String suffix = photo.getOriginalFilename().substring(photo.getOriginalFilename().lastIndexOf(".")+1,photo.getOriginalFilename().length());
if(!CommonUtil.isPhoto(suffix)){
return ResponseVo.errorByMsg(CodeMsg.PHOTO_FORMAT_NOT_CORRECT);
}
String path = request.getContextPath();
String savePath = RuntimeConstant.BASE_UPLOAD_PHOTO_PATH + CommonUtil.getFormatterDate(new Date(), "yyyyMMdd") + "\\";
File savePathFile = new File(savePath);
if(!savePathFile.exists()){
//若不存在改目录，则创建目录
savePathFile.mkdir();
}
String filename = new Date().getTime()+"."+suffix;
log.info("保存图片的路径:{}",savePath + filename);
try {
//将文件保存至指定目录
photo.transferTo(new File(savePath + filename));
}catch (Exception e) {
e.printStackTrace();
return ResponseVo.errorByMsg(CodeMsg.SAVE_FILE_EXCEPTION);
}
String filepath = "../../resources/upload/" + CommonUtil.getFormatterDate(new Date(), "yyyyMMdd") + "/" + filename;
return ResponseVo.successByMsg(filepath, "图片上传成功！");
}
/**
* 系统统一的图片查看方法
* @param filename
* @return
*/
@RequestMapping(value="/common/photo/view_photo")
@ResponseBody
public ResponseEntity<?> viewPhoto(@RequestParam(name="filename",required=true)String filename){
String uploadPhotoPath = RuntimeConstant.BASE_UPLOAD_PHOTO_PATH;
String fileDate = CommonUtil.getFileDate(filename); //取得文件路径中的日期部分
log.info("文件路径中日期部分：{}",fileDate);
filename = "\\" + filename.substring(filename.lastIndexOf("/") + 1); //取得文件名
Resource resource = resourceLoader.getResource("file:" + uploadPhotoPath + fileDate + filename);
log.info("查看图片路径:{}",uploadPhotoPath + fileDate + filename);
try {
return ResponseEntity.ok(resource);
} catch (Exception e) {
return ResponseEntity.notFound().build();
}
}
ByteArrayInputStream bi = new ByteArrayInputStream(objBytes);
ObjectInputStream oi = new ObjectInputStream(bi);
return oi.readObject();
}
/**
* 判断后缀是否是图片文件的后缀
* @param suffix
* @return
*/
public static boolean isPhoto(String suffix){
if("jpg".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else if("png".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else if("gif".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else if("jpeg".toUpperCase().equals(suffix.toUpperCase())){
return true;
}else{
return false;
}
}
/**
* 返回指定格式的日期
* @param str_date
* @param formatter
* @return
*/
public static Date getFormatterDate(String str_date, String formatter){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatter);
try{
Date date = simpleDateFormat.parse(str_date);
return date;
}catch(Exception e){
e.printStackTrace();
return null;
}
}
/**
* 截取文件路径中的日期部分
* @param filePath
}
/**
* 返回指定格式的日期
* @param str_date
* @param formatter
* @return
*/
public static Date getFormatterDate(String str_date, String formatter){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatter);
try{
Date date = simpleDateFormat.parse(str_date);
return date;
}catch(Exception e){
e.printStackTrace();
return null;
}
}
/**
* 截取文件路径中的日期部分
* @param filePath
* @return
*/
public static String getFileDate(String filePath){
filePath = filePath.substring(0,filePath.lastIndexOf("/")); //把路径去掉文件名部分
String fileDate = filePath.substring(filePath.lastIndexOf("/") + 1);
return fileDate;
}
/**
* 返回指定格式的日期字符串
* @param date
* @param formatter
* @return
*/
public static String getFormatterDate(Date date, String formatter){
SimpleDateFormat sdf = new SimpleDateFormat(formatter);
return sdf.format(date);
}
/**
* 获取时间戳
}
if(RoleEnum.SELLER.getCode().equals(user.getRoleId())){
//如果是卖家角色，只能查看到自己的订单信息
queryMap.put("sellerId", user.getId());
}
//如果是管理员角色，可以查看所有卖家发布的图书信息
ret.put("rows", orderDao.selectAll(queryMap));
ret.put("total", orderDao.getAllTotal(queryMap));
return ret;
}
@Override
public ResponseVo<Boolean> deleteOrder(String ids) {
if(CommonUtil.isEmpty(ids)){
return ResponseVo.errorByMsg(CodeMsg.DATA_ERROR);
}
//把ids根据','拆分，然后转换成List类型
String[] split = ids.split(",");
List<String> idsList = Arrays.asList(split);
//删除订单数据
orderDao.deleteBatchIds(idsList);
//删除订单详情数据
orderItemDao.deleteByOrderIdList(idsList);
return ResponseVo.successByMsg(true, "成功删除订单！");
}
@Override
public ResponseVo<Boolean> editState(Order order) {
if(order == null || order.getId() == null || order.getState() == null){
return ResponseVo.errorByMsg(CodeMsg.DATA_ERROR);
}
Order selectedOrder = orderDao.selectById(order.getId());
if(selectedOrder == null){
return ResponseVo.errorByMsg(CodeMsg.ORDER_NOT_EXIST);
}
selectedOrder.setState(order.getState());
if(orderDao.updateById(selectedOrder) < 0){
return ResponseVo.errorByMsg(CodeMsg.EDIT_ORDER_STATE_ERROR);
}
return ResponseVo.successByMsg(true, "成功修改订单状态！");
public ResponseVo<Boolean> deleteOrder(String ids) {
if(CommonUtil.isEmpty(ids)){
return ResponseVo.errorByMsg(CodeMsg.DATA_ERROR);
}
//把ids根据','拆分，然后转换成List类型
String[] split = ids.split(",");
List<String> idsList = Arrays.asList(split);
//删除订单数据
orderDao.deleteBatchIds(idsList);
//删除订单详情数据
orderItemDao.deleteByOrderIdList(idsList);
return ResponseVo.successByMsg(true, "成功删除订单！");
}
@Override
public ResponseVo<Boolean> editState(Order order) {
if(order == null || order.getId() == null || order.getState() == null){
return ResponseVo.errorByMsg(CodeMsg.DATA_ERROR);
}
Order selectedOrder = orderDao.selectById(order.getId());
if(selectedOrder == null){
return ResponseVo.errorByMsg(CodeMsg.ORDER_NOT_EXIST);
}
selectedOrder.setState(order.getState());
if(orderDao.updateById(selectedOrder) < 0){
return ResponseVo.errorByMsg(CodeMsg.EDIT_ORDER_STATE_ERROR);
}
return ResponseVo.successByMsg(true, "成功修改订单状态！");
}
@Override
public Map<String, Object> getStatsData() {
Map<String, Object> ret = new HashMap<>();
Map<String, Object> queryMap = new HashMap<>();
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ret;
}
queryMap.put("offset", 0);
queryMap.put("pageSize", 5);
if(RoleEnum.SELLER.getCode().equals(user.getRoleId())){
queryMap.put("sellerId", user.getId());
}
ret.put("orderData", orderDao.selectAll(queryMap));
queryMap.remove("offset");
queryMap.remove("pageSize");
List<Order> selectedOrderList = orderDao.selectAll(queryMap);
BigDecimal totalPrice = new BigDecimal("0.00");
for(Order order : selectedOrderList){
totalPrice = totalPrice.add(order.getTotalPrice());
//遍历购物车中选择的信息，封装OrderItem实体类
final BigDecimal[] totalPrice = {new BigDecimal("0.00")};
cartList.forEach(e->{
if(e.getBook() != null){
OrderItem orderItem = new OrderItem();
orderItem.setBookId(e.getBook().getId());
orderItem.setBookName(e.getBook().getName());
orderItem.setBookPic(e.getBook().getPhoto());
if(BookIsKillEnum.YES.getCode().equals(e.getBook().getIsKill())){
orderItem.setBookPrice(e.getBook().getNewPrice());
}else if(BookIsKillEnum.NO.getCode().equals(e.getBook().getIsKill())){
orderItem.setBookPrice(e.getBook().getOldPrice());
}
orderItem.setQuantity(e.getQuantity());
orderItem.setSubtotal(new BigDecimal(e.getQuantity()).multiply(orderItem.getBookPrice()));
totalPrice[0] = totalPrice[0].add(orderItem.getSubtotal());
orderItemList.add(orderItem);
}
});
Order order = new Order();
order.setTotalPrice(totalPrice[0]);
order.setOrderItemList(orderItemList);
return ResponseVo.success(order);
}
@Override
public ResponseVo<Boolean> submitOrder(Order order, HttpServletRequest request) {
//限流处理 设置一个等待时间,如果在等待的时间内获取到了token 令牌,则处理业务,如果在等待时间内没有获取到响应token则抛弃
if(!rateLimiter.tryAcquire(2, TimeUnit.SECONDS)){
//2s内没获取到令牌桶中的令牌，选择抛弃
logger.info("请求被限流，直接抛弃......");
return ResponseVo.errorByMsg(CodeMsg.REQUEST_LIMIT);
}
logger.info("接收请求，执行后续业务......");
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
//验证用户输入信息是否合法
if(CommonUtil.isEmpty(order.getRemark())){
order.setRemark("");
}
//进行统一表单验证
CodeMsg validate = ValidateEntityUtil.validate(order);
if(!validate.getCode().equals(CodeMsg.SUCCESS.getCode())){
return ResponseVo.errorByMsg(validate);
/**
*/
/**
* 库存Stock控制类
*/
@Controller
public class StockController {
@Autowired
private IStockService stockService;
/**
* 库存列表页面
* @param model
* @return
*/
@GetMapping("/admin/stock/list")
public String list(Model model){
return stockService.toStockList(model);
}
/**
* 获取库存列表信息
* @param page
* @param name
* @return
*/
@PostMapping("/admin/stock/list")
@ResponseBody
public Map<String, Object> list(Page page, String name){
return stockService.getStockList(page, name);
}
/**
* 添加库存信息操作处理
* @param stock
//用户和图书MD5加密的redis键名模板
private static final String USER_BOOK_KEY_TEMPLATE = "user_%d_book_%d";
//盐
private static final String salt = "yang yang ya";
//创建令牌桶实例
private RateLimiter rateLimiter = RateLimiter.create(10); //1s向令牌桶中放置10个令牌
private final Logger logger = LoggerFactory.getLogger(CartServiceImpl.class);
@Override
public ResponseVo<Boolean> addCart(Cart cart, HttpServletRequest request) {
//限流处理 设置一个等待时间,如果在等待的时间内获取到了token 令牌,则处理业务,如果在等待时间内没有获取到响应token则抛弃
if(!rateLimiter.tryAcquire(2, TimeUnit.SECONDS)){
//2s内没获取到令牌桶中的令牌，选择抛弃
logger.info("请求被限流，直接抛弃......");
return ResponseVo.errorByMsg(CodeMsg.REQUEST_LIMIT);
}
logger.info("接收请求，执行后续业务......");
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
//判断当前用户在一定时间内的访问次数，为0次则用户数据异常
int count = userService.saveUserCount(user.getId());
if(count == 0){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
//大于10次则拒绝访问
if(count > 10){
return ResponseVo.errorByMsg(CodeMsg.REQUEST_COUNT_MANY);
}
cart.setUserId(user.getId());
//进行统一表单验证
CodeMsg validate = ValidateEntityUtil.validate(cart);
if(!validate.getCode().equals(CodeMsg.SUCCESS.getCode())){
return ResponseVo.errorByMsg(validate);
}
//判断MD5加密信息是否合法，不合法，则是用脚本访问接口，直接拒绝
String redisKey = String.format(USER_BOOK_KEY_TEMPLATE, user.getId(), cart.getBookId().longValue());
String md5 = stringRedisTemplate.opsForValue().get(redisKey);
//判断MD5加密信息是否为空
if(CommonUtil.isEmpty(md5)){
return ResponseVo.errorByMsg(CodeMsg.ADD_CART_BUST);
}
String md5Token = "";
Cookie[] cookies = request.getCookies();
if(cookies != null && cookies.length > 0){
for (Cookie cookie : cookies) {
if ("md5_token".equals(cookie.getName())) {
md5Token = cookie.getValue();
}
payItemList.forEach(e->{orderIdSet.add(e.getOrderId());});
List<Order> orderList = orderDao.selectBatchIds(orderIdSet);
if(orderList == null || orderList.size() == 0){
throw new RuntimeException("支付成功，但订单状态异常，下单失败，请及时联系管理员解决！");
}
for(Order order : orderList){
order.setState(OrderStateEnum.PAYED.getCode());
if(orderDao.updateById(order) <= 0){
throw new RuntimeException("支付成功，但订单状态异常，下单失败，请及时联系管理员解决！");
}
}
return orderList;
}
@Override
public ResponseVo<Map<String, Object>> getUserOrderData(Page page) {
Map<String, Object> ret = new HashMap<>();
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
Map<String, Object> queryMap = new HashMap<>();
if(page != null){
page.setRows(1); //每页1条数据
queryMap.put("offset", page.getOffset());
queryMap.put("pageSize", page.getRows());
}
queryMap.put("customerId", user.getId());
queryMap.put("isDeleted", OrderDeleteEnum.NO.getCode());
List<Order> orderList = orderDao.selectAll(queryMap);
ret.put("orderList", orderList);
ret.put("page", page.getPage());
ret.put("totalCount", orderDao.getAllTotal(queryMap));
page.setTotalCount(orderDao.getAllTotal(queryMap));
ret.put("totalPage", page.getTotalPage());
ret.put("sendTotal", orderDao.getCountByOrderState(user.getId(), OrderStateEnum.SEND.getCode()));
ret.put("signTotal", orderDao.getCountByOrderState(user.getId(), OrderStateEnum.SIGN.getCode()));
return ResponseVo.success(ret);
}
@Override
public ResponseVo<Boolean> delOrderByUser(String orderId) {
User user = (User) SecurityUtils.getSubject().getPrincipal();
if(user == null){
return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
}
if(CommonUtil.isEmpty(orderId)){
//对象转化为字节码 把对象转化为字节码后，把字节码传输过去再转化为对象
byte[] bytes = CommonUtil.getBytesFromObject(email);
//发送消息
amqpTemplate.convertAndSend("my_normal_exchange", "my_email", bytes);
}catch (Exception e){
//邮件发送失败
e.printStackTrace();
}
//
// response.sendRedirect("../../home/user/my_order");//跳转付款成功页面
// } else {
// //付款失败
// response.sendRedirect("../../home/order/index");//跳转付款失败页面
// }
// }
//
//}
package com.yjq.programmer.service.impl.home;
public ResponseVo<Boolean> add(Book book, String time){
return bookService.addBook(book, time);
}
/**
* 修改图书信息操作处理
* @param book
* @param time
* @return
*/
@PostMapping("/admin/book/edit")
@ResponseBody
public ResponseVo<Boolean> edit(Book book, String time){
return bookService.editBook(book, time);
}
/**
* 删除图书信息操作处理
* @param ids
* @return
*/
@PostMapping("/admin/book/delete")
@ResponseBody
public ResponseVo<Boolean> delete(String ids){
return bookService.deleteBook(ids);
}
/**
* 设置图书秒杀信息操作处理
* @param id
* @param isKill
* @param time
* @param newPrice
* @return
*/
@PostMapping("/admin/book/set_kill")
@ResponseBody
public ResponseVo<Boolean> setKill(String id, Integer isKill, String time, BigDecimal newPrice){
return bookService.setKill(id, isKill, time, newPrice);
}
/**
* 下架图书操作处理
* @param id
* @return
*/
@PostMapping("/admin/book/off_shelves")
@ResponseBody
public ResponseVo<Boolean> offShelves(String id){
return bookService.offShelves(id);
}
381
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
