软件编程
位置:首页>> 软件编程>> java编程>> Java毕业设计实战项目之在线服装销售商城系统的实现流程

Java毕业设计实战项目之在线服装销售商城系统的实现流程

作者:OldWinePot  发布时间:2023-03-27 00:15:31 

标签:Java,服装,在线,销售,商城

一、项目运行

环境配置:

Jdk1.8 + Tomcat8.5 + Mysql + HBuilderX(Webstorm也行)+ Eclispe(IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持)。

项目技术:

Spring + SpringBoot+ mybatis + Maven + Vue 等等组成,B/S模式 + Maven管理等等。

Java毕业设计实战项目之在线服装销售商城系统的实现流程

Java毕业设计实战项目之在线服装销售商城系统的实现流程

Java毕业设计实战项目之在线服装销售商城系统的实现流程

Java毕业设计实战项目之在线服装销售商城系统的实现流程

Java毕业设计实战项目之在线服装销售商城系统的实现流程

后台管理-用户页:


/**
* 后台管理-用户页
*/
@Controller
public class UserController extends BaseController{
   @Resource(name="userService")
   private UserService userService;
   @Resource(name="addressService")
   private AddressService addressService;
   @Resource(name ="reviewService")
   private ReviewService reviewService;
   @Resource(name = "productOrderItemService")
   private ProductOrderItemService productOrderItemService;
   @Resource(name = "productService")
   private ProductService productService;
   @Resource(name = "productImageService")
   private ProductImageService productImageService;

//转到后台管理-用户页-ajax
   @RequestMapping(value = "admin/user", method = RequestMethod.GET)
   public String goUserManagePage(HttpSession session, Map<String, Object> map){
       logger.info("获取前十条用户信息");
       PageUtil pageUtil = new PageUtil(0, 10);
       List<User> userList = userService.getList(null, null, pageUtil);
       map.put("userList", userList);
       logger.info("获取用户总数量");
       Integer userCount = userService.getTotal(null);
       map.put("userCount", userCount);
       logger.info("获取分页信息");
       pageUtil.setTotal(userCount);
       map.put("pageUtil", pageUtil);

logger.info("转到后台管理-用户页-ajax方式");
       return "admin/userManagePage";
   }

//转到后台管理-用户详情页-ajax
   @RequestMapping(value = "admin/user/{uid}", method = RequestMethod.GET)
   public String getUserById(HttpSession session, Map<String,Object> map, @PathVariable Integer uid/* 用户ID */){
       logger.info("获取user_id为{}的用户信息",uid);
       User user = userService.get(uid);
       logger.info("获取用户详情-所在地地址信息");
       Address address = addressService.get(user.getUser_address().getAddress_areaId());
       Stack<String> addressStack = new Stack<>();
       //最后一级地址
       addressStack.push(address.getAddress_name() + " ");
       //如果不是第一级地址
       while (!address.getAddress_areaId().equals(address.getAddress_regionId().getAddress_areaId())) {
           address = addressService.get(address.getAddress_regionId().getAddress_areaId());
           addressStack.push(address.getAddress_name() + " ");
       }
       StringBuilder builder = new StringBuilder();
       while (!addressStack.empty()) {
           builder.append(addressStack.pop());
       }
       logger.info("所在地地址字符串:{}", builder);
       user.setUser_address(new Address().setAddress_name(builder.toString()));

logger.info("获取用户详情-家乡地址信息");
       address = addressService.get(user.getUser_homeplace().getAddress_areaId());
       //最后一级地址
       addressStack.push(address.getAddress_name() + " ");
       //如果不是第一级地址
       while (!address.getAddress_areaId().equals(address.getAddress_regionId().getAddress_areaId())) {
           address = addressService.get(address.getAddress_regionId().getAddress_areaId());
           addressStack.push(address.getAddress_name() + " ");
       }
       builder = new StringBuilder();
       while (!addressStack.empty()) {
           builder.append(addressStack.pop());
       }
       logger.info("家乡地址字符串:{}", builder);
       user.setUser_homeplace(new Address().setAddress_name(builder.toString()));

logger.info("获取用户详情-购物车订单项信息");
       List<ProductOrderItem> productOrderItemList = productOrderItemService.getListByUserId(
               user.getUser_id(), null
       );
       if (productOrderItemList != null) {
           logger.info("获取用户详情-购物车订单项对应的产品信息");
           for (ProductOrderItem productOrderItem : productOrderItemList) {
               Integer productId = productOrderItem.getProductOrderItem_product().getProduct_id();
               logger.warn("获取产品ID为{}的产品信息", productId);
               Product product = productService.get(productId);
               if (product != null) {
                   logger.warn("获取产品ID为{}的第一张预览图片信息", productId);
                   product.setSingleProductImageList(productImageService.getList(
                           productId, (byte) 0, new PageUtil(0, 1))
                   );
               }
               productOrderItem.setProductOrderItem_product(product);
           }
       }
       user.setProductOrderItemList(productOrderItemList);

if (user.getUser_realname() != null) {
           logger.info("用户隐私加密");
           user.setUser_realname(user.getUser_realname().substring(0, 1) + "*");
       } else {
           user.setUser_realname("未命名");
       }

map.put("user",user);

logger.info("转到后台管理-用户详情页-ajax方式");
       return "admin/include/userDetails";
   }

//按条件查询用户-ajax
   @ResponseBody
   @RequestMapping(value = "admin/user/{index}/{count}", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
   public String getUserBySearch(@RequestParam(required = false) String user_name/* 用户名称 */,
                                 @RequestParam(required = false) Byte[] user_gender_array/* 用户性别数组 */,
                                 @RequestParam(required = false) String orderBy/* 排序字段 */,
                                 @RequestParam(required = false,defaultValue = "true") Boolean isDesc/* 是否倒序 */,
                                 @PathVariable Integer index/* 页数 */,
                                 @PathVariable Integer count/* 行数 */) throws UnsupportedEncodingException {
       //移除不必要条件
       Byte gender = null;
       if (user_gender_array != null && user_gender_array.length == 1) {
           gender = user_gender_array[0];
       }

if (user_name != null) {
           //如果为非空字符串则解决中文乱码:URLDecoder.decode(String,"UTF-8");
           user_name = "".equals(user_name) ? null : URLDecoder.decode(user_name, "UTF-8");
       }
       if (orderBy != null && "".equals(orderBy)) {
           orderBy = null;
       }
       //封装查询条件
       User user = new User()
               .setUser_name(user_name)
               .setUser_gender(gender);

OrderUtil orderUtil = null;
       if (orderBy != null) {
           logger.info("根据{}排序,是否倒序:{}",orderBy,isDesc);
           orderUtil = new OrderUtil(orderBy, isDesc);
       }

JSONObject object = new JSONObject();
       logger.info("按条件获取第{}页的{}条用户", index + 1, count);
       PageUtil pageUtil = new PageUtil(index, count);
       List<User> userList = userService.getList(user, orderUtil, pageUtil);
       object.put("userList", JSONArray.parseArray(JSON.toJSONString(userList)));
       logger.info("按条件获取用户总数量");
       Integer userCount = userService.getTotal(user);
       object.put("userCount", userCount);
       logger.info("获取分页信息");
       pageUtil.setTotal(userCount);
       object.put("totalPage", pageUtil.getTotalPage());
       object.put("pageUtil", pageUtil);

return object.toJSONString();
   }
}

后台管理-产品类型页:


/**
* 后台管理-产品类型页
*/
@Controller
public class CategoryController extends BaseController {
   @Resource(name = "categoryService")
   private CategoryService categoryService;
   @Resource(name = "lastIDService")
   private LastIDService lastIDService;
   @Resource(name = "propertyService")
   private PropertyService propertyService;

//转到后台管理-产品类型页-ajax
   @RequestMapping(value = "admin/category", method = RequestMethod.GET)
   public String goToPage(HttpSession session, Map<String, Object> map) {
       logger.info("获取前10条产品类型列表");
       PageUtil pageUtil = new PageUtil(0, 10);
       List<Category> categoryList = categoryService.getList(null, pageUtil);
       map.put("categoryList", categoryList);
       logger.info("获取产品类型总数量");
       Integer categoryCount = categoryService.getTotal(null);
       map.put("categoryCount", categoryCount);
       logger.info("获取分页信息");
       pageUtil.setTotal(categoryCount);
       map.put("pageUtil", pageUtil);

logger.info("转到后台管理-分类页-ajax方式");
       return "admin/categoryManagePage";
   }

//转到后台管理-产品类型详情页-ajax
   @RequestMapping(value = "admin/category/{cid}", method = RequestMethod.GET)
   public String goToDetailsPage(HttpSession session, Map<String, Object> map, @PathVariable Integer cid/* 分类ID */) {
       logger.info("获取category_id为{}的分类信息", cid);
       Category category = categoryService.get(cid);
       logger.info("获取分类子信息-属性列表");
       category.setPropertyList(propertyService.getList(new Property().setProperty_category(category), null));
       map.put("category", category);

logger.info("转到后台管理-分类详情页-ajax方式");
       return "admin/include/categoryDetails";
   }

//转到后台管理-产品类型添加页-ajax
   @RequestMapping(value = "admin/category/new", method = RequestMethod.GET)
   public String goToAddPage(HttpSession session, Map<String, Object> map) {
       logger.info("转到后台管理-分类添加页-ajax方式");
       return "admin/include/categoryDetails";
   }

//添加产品类型信息-ajax
   @ResponseBody
   @RequestMapping(value = "admin/category", method = RequestMethod.POST, produces = "application/json;charset=utf-8")
   public String addCategory(@RequestParam String category_name/* 分类名称 */,
                             @RequestParam String category_image_src/* 分类图片路径 */) {
       JSONObject jsonObject = new JSONObject();
       logger.info("整合分类信息");
       Category category = new Category()
               .setCategory_name(category_name)
               .setCategory_image_src(category_image_src.substring(category_image_src.lastIndexOf("/") + 1));
       logger.info("添加分类信息");
       boolean yn = categoryService.add(category);
       if (yn) {
           int category_id = lastIDService.selectLastID();
           logger.info("添加成功!,新增分类的ID值为:{}", category_id);
           jsonObject.put("success", true);
           jsonObject.put("category_id", category_id);
       } else {
           jsonObject.put("success", false);
           logger.warn("添加失败!事务回滚");
           throw new RuntimeException();
       }

return jsonObject.toJSONString();
   }

//更新产品类型信息-ajax
   @ResponseBody
   @RequestMapping(value = "admin/category/{category_id}", method = RequestMethod.PUT, produces = "application/json;charset=utf-8")
   public String updateCategory(@RequestParam String category_name/* 分类名称 */,
                                @RequestParam String category_image_src/* 分类图片路径 */,
                                @PathVariable("category_id") Integer category_id/* 分类ID */) {
       JSONObject jsonObject = new JSONObject();
       logger.info("整合分类信息");
       Category category = new Category()
               .setCategory_id(category_id)
               .setCategory_name(category_name)
               .setCategory_image_src(category_image_src.substring(category_image_src.lastIndexOf("/") + 1));
       logger.info("更新分类信息,分类ID值为:{}", category_id);
       boolean yn = categoryService.update(category);
       if (yn) {
           logger.info("更新成功!");
           jsonObject.put("success", true);
           jsonObject.put("category_id", category_id);
       } else {
           jsonObject.put("success", false);
           logger.info("更新失败!事务回滚");
           throw new RuntimeException();
       }

return jsonObject.toJSONString();
   }

//按条件查询产品类型-ajax
   @ResponseBody
   @RequestMapping(value = "admin/category/{index}/{count}", method = RequestMethod.GET, produces = "application/json;charset=utf-8")
   public String getCategoryBySearch(@RequestParam(required = false) String category_name/* 分类名称 */,
                                     @PathVariable Integer index/* 页数 */,
                                     @PathVariable Integer count/* 行数 */) throws UnsupportedEncodingException {
       //移除不必要条件
       if (category_name != null) {
           //如果为非空字符串则解决中文乱码:URLDecoder.decode(String,"UTF-8");
           category_name = "".equals(category_name) ? null : URLDecoder.decode(category_name, "UTF-8");
       }

JSONObject object = new JSONObject();
       logger.info("按条件获取第{}页的{}条分类", index + 1, count);
       PageUtil pageUtil = new PageUtil(index, count);
       List<Category> categoryList = categoryService.getList(category_name, pageUtil);
       object.put("categoryList", JSONArray.parseArray(JSON.toJSONString(categoryList)));
       logger.info("按条件获取分类总数量");
       Integer categoryCount = categoryService.getTotal(category_name);
       object.put("categoryCount", categoryCount);
       logger.info("获取分页信息");
       pageUtil.setTotal(categoryCount);
       object.put("totalPage", pageUtil.getTotalPage());
       object.put("pageUtil", pageUtil);

return object.toJSONString();
   }

// 上传产品类型图片-ajax
   @ResponseBody
   @RequestMapping(value = "admin/uploadCategoryImage", method = RequestMethod.POST, produces = "application/json;charset=utf-8")
   public String uploadCategoryImage(@RequestParam MultipartFile file, HttpSession session) {
       String originalFileName = file.getOriginalFilename();
       logger.info("获取图片原始文件名:  {}", originalFileName);
       String extension = originalFileName.substring(originalFileName.lastIndexOf('.'));
       String fileName = UUID.randomUUID() + extension;
       String filePath = session.getServletContext().getRealPath("/") + "res/images/item/categoryPicture/" + fileName;

logger.info("文件上传路径:{}", filePath);
       JSONObject object = new JSONObject();
       try {
           logger.info("文件上传中...");
           file.transferTo(new File(filePath));
           logger.info("文件上传完成");
           object.put("success", true);
           object.put("fileName", fileName);
       } catch (IOException e) {
           logger.warn("文件上传失败!");
           e.printStackTrace();
           object.put("success", false);
       }

return object.toJSONString();
   }
}

订单列表页:


/**
* 订单列表页
*/
@Controller
public class ForeOrderController extends BaseController {
   @Resource(name = "productService")
   private ProductService productService;
   @Resource(name = "userService")
   private UserService userService;
   @Resource(name = "productOrderItemService")
   private ProductOrderItemService productOrderItemService;
   @Resource(name = "addressService")
   private AddressService addressService;
   @Resource(name = "categoryService")
   private CategoryService categoryService;
   @Resource(name = "productImageService")
   private ProductImageService productImageService;
   @Resource(name = "productOrderService")
   private ProductOrderService productOrderService;
   @Resource(name = "reviewService")
   private ReviewService reviewService;
   @Resource(name = "lastIDService")
   private LastIDService lastIDService;
   //转到前台天猫-订单列表页
   @RequestMapping(value = "order", method = RequestMethod.GET)
   public String goToPageSimple() {
       return "redirect:/order/0/10";
   }
   @RequestMapping(value = "order/{index}/{count}", method = RequestMethod.GET)
   public String goToPage(HttpSession session, Map<String, Object> map,
                          @RequestParam(required = false) Byte status,
                          @PathVariable("index") Integer index/* 页数 */,
                          @PathVariable("count") Integer count/* 行数*/) {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       Byte[] status_array = null;
       if (status != null) {
           status_array = new Byte[]{status};
       }

PageUtil pageUtil = new PageUtil(index, count);
       logger.info("根据用户ID:{}获取订单列表", userId);
       List<ProductOrder> productOrderList = productOrderService.getList(
               new ProductOrder().setProductOrder_user(
                       new User().setUser_id(Integer.valueOf(userId.toString()))
               ), status_array, new OrderUtil("productOrder_id", true), pageUtil
       );

//订单总数量
       Integer orderCount = 0;
       if (productOrderList.size() > 0) {
           orderCount = productOrderService.getTotal(new ProductOrder().setProductOrder_user(new User().setUser_id(Integer.valueOf(userId.toString()))), status_array);
           logger.info("获取订单项信息及对应的产品信息");
           for (ProductOrder order : productOrderList) {
               List<ProductOrderItem> productOrderItemList = productOrderItemService.getListByOrderId(
                       order.getProductOrder_id(), null
               );
               if (productOrderItemList != null) {
                   for (ProductOrderItem productOrderItem : productOrderItemList) {
                       Integer product_id = productOrderItem.getProductOrderItem_product().getProduct_id();
                       Product product = productService.get(product_id);
                       product.setSingleProductImageList(productImageService.getList(
                               product_id, (byte) 0, new PageUtil(0, 1)
                       ));
                       productOrderItem.setProductOrderItem_product(product);
                       if (order.getProductOrder_status() == 3) {
                           productOrderItem.setIsReview(reviewService.getTotalByOrderItemId(
                                   productOrderItem.getProductOrderItem_id()) > 0
                           );
                       }
                   }
               }
               order.setProductOrderItemList(productOrderItemList);
           }
       }
       pageUtil.setTotal(orderCount);

logger.info("获取产品分类列表信息");
       List<Category> categoryList = categoryService.getList(null, new PageUtil(0, 5));

map.put("pageUtil", pageUtil);
       map.put("productOrderList", productOrderList);
       map.put("categoryList", categoryList);
       map.put("status", status);

logger.info("转到前台天猫-订单列表页");
       return "fore/orderListPage";
   }

//转到前台天猫-订单建立页
   @RequestMapping(value = "order/create/{product_id}", method = RequestMethod.GET)
   public String goToOrderConfirmPage(@PathVariable("product_id") Integer product_id,
                                      @RequestParam(required = false, defaultValue = "1") Short product_number,
                                      Map<String, Object> map,
                                      HttpSession session,
                                      HttpServletRequest request) throws UnsupportedEncodingException {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       logger.info("通过产品ID获取产品信息:{}", product_id);
       Product product = productService.get(product_id);
       if (product == null) {
           return "redirect:/";
       }
       logger.info("获取产品的详细信息");
       product.setProduct_category(categoryService.get(product.getProduct_category().getCategory_id()));
       product.setSingleProductImageList(productImageService.getList(product_id, (byte) 0, new PageUtil(0, 1)));

logger.info("封装订单项对象");
       ProductOrderItem productOrderItem = new ProductOrderItem();
       productOrderItem.setProductOrderItem_product(product);
       productOrderItem.setProductOrderItem_number(product_number);
       productOrderItem.setProductOrderItem_price(product.getProduct_sale_price() * product_number);
       productOrderItem.setProductOrderItem_user(new User().setUser_id(Integer.valueOf(userId.toString())));

//初始化订单地址信息
       String addressId = "110000";
       String cityAddressId = "110100";
       String districtAddressId = "110101";
       String detailsAddress = null;
       String order_post = null;
       String order_receiver = null;
       String order_phone = null;
       Cookie[] cookies = request.getCookies();
       //如果读取到了浏览器Cookie
       if (cookies != null) {
           for (Cookie cookie : cookies) {
               String cookieName = cookie.getName();
               String cookieValue = cookie.getValue();
               switch (cookieName) {
                   case "addressId":
                       addressId = cookieValue;
                       break;
                   case "cityAddressId":
                       cityAddressId = cookieValue;
                       break;
                   case "districtAddressId":
                       districtAddressId = cookieValue;
                       break;
                   case "order_post":
                       order_post = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
                   case "order_receiver":
                       order_receiver = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
                   case "order_phone":
                       order_phone = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
                   case "detailsAddress":
                       detailsAddress = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
               }
           }
       }
       logger.info("获取省份信息");
       List<Address> addressList = addressService.getRoot();
       logger.info("获取addressId为{}的市级地址信息", addressId);
       List<Address> cityAddress = addressService.getList(null, addressId);
       logger.info("获取cityAddressId为{}的区级地址信息", cityAddressId);
       List<Address> districtAddress = addressService.getList(null, cityAddressId);

List<ProductOrderItem> productOrderItemList = new ArrayList<>();
       productOrderItemList.add(productOrderItem);

map.put("orderItemList", productOrderItemList);
       map.put("addressList", addressList);
       map.put("cityList", cityAddress);
       map.put("districtList", districtAddress);
       map.put("orderTotalPrice", productOrderItem.getProductOrderItem_price());

map.put("addressId", addressId);
       map.put("cityAddressId", cityAddressId);
       map.put("districtAddressId", districtAddressId);
       map.put("order_post", order_post);
       map.put("order_receiver", order_receiver);
       map.put("order_phone", order_phone);
       map.put("detailsAddress", detailsAddress);

logger.info("转到前台天猫-订单建立页");
       return "fore/productBuyPage";
   }

//转到前台天猫-购物车订单建立页
   @RequestMapping(value = "order/create/byCart", method = RequestMethod.GET)
   public String goToOrderConfirmPageByCart(Map<String, Object> map,
                                            HttpSession session, HttpServletRequest request,
                                            @RequestParam(required = false) Integer[] order_item_list) throws UnsupportedEncodingException {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       if (order_item_list == null || order_item_list.length == 0) {
           logger.warn("用户订单项数组不存在,回到购物车页");
           return "redirect:/cart";
       }
       logger.info("通过订单项ID数组获取订单信息");
       List<ProductOrderItem> orderItemList = new ArrayList<>(order_item_list.length);
       for (Integer orderItem_id : order_item_list) {
           orderItemList.add(productOrderItemService.get(orderItem_id));
       }
       logger.info("------检查订单项合法性------");
       if (orderItemList.size() == 0) {
           logger.warn("用户订单项获取失败,回到购物车页");
           return "redirect:/cart";
       }
       for (ProductOrderItem orderItem : orderItemList) {
           if (orderItem.getProductOrderItem_user().getUser_id() != userId) {
               logger.warn("用户订单项与用户不匹配,回到购物车页");
               return "redirect:/cart";
           }
           if (orderItem.getProductOrderItem_order() != null) {
               logger.warn("用户订单项不属于购物车,回到购物车页");
               return "redirect:/cart";
           }
       }
       logger.info("验证通过,获取订单项的产品信息");
       double orderTotalPrice = 0.0;
       for (ProductOrderItem orderItem : orderItemList) {
           Product product = productService.get(orderItem.getProductOrderItem_product().getProduct_id());
           product.setProduct_category(categoryService.get(product.getProduct_category().getCategory_id()));
           product.setSingleProductImageList(productImageService.getList(product.getProduct_id(), (byte) 0, new PageUtil(0, 1)));
           orderItem.setProductOrderItem_product(product);
           orderTotalPrice += orderItem.getProductOrderItem_price();
       }
       String addressId = "110000";
       String cityAddressId = "110100";
       String districtAddressId = "110101";
       String detailsAddress = null;
       String order_post = null;
       String order_receiver = null;
       String order_phone = null;
       Cookie[] cookies = request.getCookies();
       if (cookies != null) {
           for (Cookie cookie : cookies) {
               String cookieName = cookie.getName();
               String cookieValue = cookie.getValue();
               switch (cookieName) {
                   case "addressId":
                       addressId = cookieValue;
                       break;
                   case "cityAddressId":
                       cityAddressId = cookieValue;
                       break;
                   case "districtAddressId":
                       districtAddressId = cookieValue;
                       break;
                   case "order_post":
                       order_post = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
                   case "order_receiver":
                       order_receiver = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
                   case "order_phone":
                       order_phone = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
                   case "detailsAddress":
                       detailsAddress = URLDecoder.decode(cookieValue, "UTF-8");
                       break;
               }
           }
       }
       logger.info("获取省份信息");
       List<Address> addressList = addressService.getRoot();
       logger.info("获取addressId为{}的市级地址信息", addressId);
       List<Address> cityAddress = addressService.getList(null, addressId);
       logger.info("获取cityAddressId为{}的区级地址信息", cityAddressId);
       List<Address> districtAddress = addressService.getList(null, cityAddressId);

map.put("orderItemList", orderItemList);
       map.put("addressList", addressList);
       map.put("cityList", cityAddress);
       map.put("districtList", districtAddress);
       map.put("orderTotalPrice", orderTotalPrice);

map.put("addressId", addressId);
       map.put("cityAddressId", cityAddressId);
       map.put("districtAddressId", districtAddressId);
       map.put("order_post", order_post);
       map.put("order_receiver", order_receiver);
       map.put("order_phone", order_phone);
       map.put("detailsAddress", detailsAddress);

logger.info("转到前台天猫-订单建立页");
       return "fore/productBuyPage";
   }

//转到前台天猫-订单支付页
   @RequestMapping(value = "order/pay/{order_code}", method = RequestMethod.GET)
   public String goToOrderPayPage(Map<String, Object> map, HttpSession session,
                                  @PathVariable("order_code") String order_code) {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 0) {
           logger.warn("订单状态不正确,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           return "redirect:/order/0/10";
       }
       order.setProductOrderItemList(productOrderItemService.getListByOrderId(order.getProductOrder_id(), null));

double orderTotalPrice = 0.00;
       if (order.getProductOrderItemList().size() == 1) {
           logger.info("获取单订单项的产品信息");
           ProductOrderItem productOrderItem = order.getProductOrderItemList().get(0);
           Product product = productService.get(productOrderItem.getProductOrderItem_product().getProduct_id());
           product.setProduct_category(categoryService.get(product.getProduct_category().getCategory_id()));
           productOrderItem.setProductOrderItem_product(product);
           orderTotalPrice = productOrderItem.getProductOrderItem_price();
       } else {
           for (ProductOrderItem productOrderItem : order.getProductOrderItemList()) {
               orderTotalPrice += productOrderItem.getProductOrderItem_price();
           }
       }
       logger.info("订单总金额为:{}元", orderTotalPrice);

map.put("productOrder", order);
       map.put("orderTotalPrice", orderTotalPrice);

logger.info("转到前台天猫-订单支付页");
       return "fore/productPayPage";
   }

//转到前台天猫-订单支付成功页
   @RequestMapping(value = "order/pay/success/{order_code}", method = RequestMethod.GET)
   public String goToOrderPaySuccessPage(Map<String, Object> map, HttpSession session,
                                         @PathVariable("order_code") String order_code) {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 1) {
           logger.warn("订单状态不正确,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           return "redirect:/order/0/10";
       }
       order.setProductOrderItemList(productOrderItemService.getListByOrderId(order.getProductOrder_id(), null));

double orderTotalPrice = 0.00;
       if (order.getProductOrderItemList().size() == 1) {
           logger.info("获取单订单项的产品信息");
           ProductOrderItem productOrderItem = order.getProductOrderItemList().get(0);
//            Product pro = pro.setProduct_id(productOrderItem.getProductOrderItem_product().getProduct_id());
           Product pro = productService.get(productOrderItem.getProductOrderItem_product().getProduct_id());
           System.out.println(pro.getProduct_stock_count());
           System.out.println(productOrderItem.getProductOrderItem_number());
           pro.setProduct_stock_count(pro.getProduct_stock_count()-productOrderItem.getProductOrderItem_number());
//            此处减库存
           productService.update(pro);
           orderTotalPrice = productOrderItem.getProductOrderItem_price();
       } else {
           for (ProductOrderItem productOrderItem : order.getProductOrderItemList()) {
              Product pro = productService.get(productOrderItem.getProductOrderItem_product().getProduct_id());
                  System.out.println(pro.getProduct_stock_count());
                  System.out.println(productOrderItem.getProductOrderItem_number());
                  pro.setProduct_stock_count(pro.getProduct_stock_count()-productOrderItem.getProductOrderItem_number());
//                   此处减库存
                  productService.update(pro);
               orderTotalPrice += productOrderItem.getProductOrderItem_price();
           }
       }
       logger.info("订单总金额为:{}元", orderTotalPrice);

logger.info("获取订单详情-地址信息");
       Address address = addressService.get(order.getProductOrder_address().getAddress_areaId());
       Stack<String> addressStack = new Stack<>();
       //详细地址
       addressStack.push(order.getProductOrder_detail_address());
       //最后一级地址
       addressStack.push(address.getAddress_name() + " ");
       //如果不是第一级地址
       while (!address.getAddress_areaId().equals(address.getAddress_regionId().getAddress_areaId())) {
           address = addressService.get(address.getAddress_regionId().getAddress_areaId());
           addressStack.push(address.getAddress_name() + " ");
       }
       StringBuilder builder = new StringBuilder();
       while (!addressStack.empty()) {
           builder.append(addressStack.pop());
       }
       logger.info("订单地址字符串:{}", builder);
       order.setProductOrder_detail_address(builder.toString());

map.put("productOrder", order);
       map.put("orderTotalPrice", orderTotalPrice);

logger.info("转到前台天猫-订单支付成功页");
       return "fore/productPaySuccessPage";
   }

//转到前台天猫-订单确认页
   @RequestMapping(value = "order/confirm/{order_code}", method = RequestMethod.GET)
   public String goToOrderConfirmPage(Map<String, Object> map, HttpSession session,
                                      @PathVariable("order_code") String order_code) {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 2) {
           logger.warn("订单状态不正确,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           return "redirect:/order/0/10";
       }
       order.setProductOrderItemList(productOrderItemService.getListByOrderId(order.getProductOrder_id(), null));

double orderTotalPrice = 0.00;
       if (order.getProductOrderItemList().size() == 1) {
           logger.info("获取单订单项的产品信息");
           ProductOrderItem productOrderItem = order.getProductOrderItemList().get(0);
           Integer product_id = productOrderItem.getProductOrderItem_product().getProduct_id();
           Product product = productService.get(product_id);
           product.setSingleProductImageList(productImageService.getList(product_id, (byte) 0, new PageUtil(0, 1)));
           productOrderItem.setProductOrderItem_product(product);
           orderTotalPrice = productOrderItem.getProductOrderItem_price();
       } else {
           logger.info("获取多订单项的产品信息");
           for (ProductOrderItem productOrderItem : order.getProductOrderItemList()) {
               Integer product_id = productOrderItem.getProductOrderItem_product().getProduct_id();
               Product product = productService.get(product_id);
               product.setSingleProductImageList(productImageService.getList(product_id, (byte) 0, new PageUtil(0, 1)));
               productOrderItem.setProductOrderItem_product(product);
               orderTotalPrice += productOrderItem.getProductOrderItem_price();
           }
       }
       logger.info("订单总金额为:{}元", orderTotalPrice);

map.put("productOrder", order);
       map.put("orderTotalPrice", orderTotalPrice);

logger.info("转到前台天猫-订单确认页");
       return "fore/orderConfirmPage";
   }

//转到前台天猫-订单完成页
   @RequestMapping(value = "order/success/{order_code}", method = RequestMethod.GET)
   public String goToOrderSuccessPage(Map<String, Object> map, HttpSession session,
                                      @PathVariable("order_code") String order_code) {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 3) {
           logger.warn("订单状态不正确,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("获取订单中订单项数量");
       Integer count = productOrderItemService.getTotalByOrderId(order.getProductOrder_id());
       Product product = null;
       if (count == 1) {
           logger.info("获取订单中的唯一订单项");
           ProductOrderItem productOrderItem = productOrderItemService.getListByOrderId(order.getProductOrder_id(), new PageUtil(0, 1)).get(0);
           if (productOrderItem != null) {
               logger.info("获取订单项评论数量");
               count = reviewService.getTotalByOrderItemId(productOrderItem.getProductOrderItem_id());
               if (count == 0) {
                   logger.info("获取订单项产品信息");
                   product = productService.get(productOrderItem.getProductOrderItem_product().getProduct_id());
                   if (product != null) {
                       product.setSingleProductImageList(productImageService.getList(product.getProduct_id(), (byte) 0, new PageUtil(0, 1)));
                   }
               }
           }
           map.put("orderItem", productOrderItem);
       }

map.put("product", product);

logger.info("转到前台天猫-订单完成页");
       return "fore/orderSuccessPage";
   }

//转到前台天猫-购物车页
   @RequestMapping(value = "cart", method = RequestMethod.GET)
   public String goToCartPage(Map<String, Object> map, HttpSession session) {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       User user;
       if (userId != null) {
           logger.info("获取用户信息");
           user = userService.get(Integer.parseInt(userId.toString()));
           map.put("user", user);
       } else {
           return "redirect:/login";
       }
       logger.info("获取用户购物车信息");
       List<ProductOrderItem> orderItemList = productOrderItemService.getListByUserId(Integer.valueOf(userId.toString()), null);
       Integer orderItemTotal = 0;
       if (orderItemList.size() > 0) {
           logger.info("获取用户购物车的商品总数");
           orderItemTotal = productOrderItemService.getTotalByUserId(Integer.valueOf(userId.toString()));
           logger.info("获取用户购物车内的商品信息");
           for (ProductOrderItem orderItem : orderItemList) {
               Integer product_id = orderItem.getProductOrderItem_product().getProduct_id();
               Product product = productService.get(product_id);
               product.setSingleProductImageList(productImageService.getList(product_id, (byte) 0, null));
               product.setProduct_category(categoryService.get(product.getProduct_category().getCategory_id()));
               orderItem.setProductOrderItem_product(product);
           }
       }
       map.put("orderItemList", orderItemList);
       map.put("orderItemTotal", orderItemTotal);

logger.info("转到前台天猫-购物车页");
       return "fore/productBuyCarPage";
   }

//更新订单信息为已支付,待发货-ajax
   @ResponseBody
   @RequestMapping(value = "order/pay/{order_code}", method = RequestMethod.PUT)
   public String orderPay(HttpSession session, @PathVariable("order_code") String order_code) {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("success", false);
           object.put("url", "/login");
           return object.toJSONString();
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 0) {
           logger.warn("订单状态不正确,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       order.setProductOrderItemList(productOrderItemService.getListByOrderId(order.getProductOrder_id(), null));

double orderTotalPrice = 0.00;
       if (order.getProductOrderItemList().size() == 1) {
           logger.info("获取单订单项的产品信息");
           ProductOrderItem productOrderItem = order.getProductOrderItemList().get(0);
           Product product = productService.get(productOrderItem.getProductOrderItem_product().getProduct_id());
           product.setProduct_category(categoryService.get(product.getProduct_category().getCategory_id()));
           productOrderItem.setProductOrderItem_product(product);
           orderTotalPrice = productOrderItem.getProductOrderItem_price();
           logger.info("更新产品销量信息");
           Product updateProduct = new Product()
                   .setProduct_id(product.getProduct_id())
                   .setProduct_sale_count(product.getProduct_sale_count() + productOrderItem.getProductOrderItem_number());
           logger.info("更新产品信息,产品ID值为:{}", product.getProduct_id());
           boolean yn = productService.update(updateProduct);
           if (!yn) {
               logger.info("产品销量信息更新失败!事务回滚");
               object.put("success", false);
               throw new RuntimeException();
           }
           logger.info("产品销量信息更新成功!");
       } else {
           for (ProductOrderItem productOrderItem : order.getProductOrderItemList()) {
               Product product = productService.get(productOrderItem.getProductOrderItem_product().getProduct_id());
               logger.info("更新产品销量信息");
               Product updateProduct = new Product()
                       .setProduct_id(product.getProduct_id())
                       .setProduct_sale_count(product.getProduct_sale_count() + productOrderItem.getProductOrderItem_number());
               logger.info("更新产品信息,产品ID值为:{}", product.getProduct_id());
               boolean yn = productService.update(updateProduct);
               if (!yn) {
                   logger.info("产品销量信息更新失败!事务回滚");
                   object.put("success", false);
                   throw new RuntimeException();
               }
               logger.info("产品销量信息更新成功!");
               orderTotalPrice += productOrderItem.getProductOrderItem_price();
           }
       }
       logger.info("总共支付金额为:{}元", orderTotalPrice);
       logger.info("更新订单信息");
       ProductOrder productOrder = new ProductOrder()
               .setProductOrder_id(order.getProductOrder_id())
               .setProductOrder_pay_date(new Date())
               .setProductOrder_status((byte) 1);

boolean yn = productOrderService.update(productOrder);
       if (yn) {
           object.put("success", true);
           object.put("url", "/order/pay/success/" + order_code);
       } else {
           object.put("success", false);
           object.put("url", "/order/0/10");
       }
       return object.toJSONString();
   }

//更新订单信息为已发货,待确认-ajax
   @RequestMapping(value = "order/delivery/{order_code}", method = RequestMethod.GET)
   public String orderDelivery(HttpSession session, @PathVariable("order_code") String order_code) {
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           return "redirect:/order/0/10";
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 1) {
           logger.warn("订单状态不正确,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           return "redirect:/order/0/10";
       }
       logger.info("更新订单信息");
       ProductOrder productOrder = new ProductOrder()
               .setProductOrder_id(order.getProductOrder_id())
               .setProductOrder_delivery_date(new Date())
               .setProductOrder_status((byte) 2);

productOrderService.update(productOrder);

return "redirect:/order/0/10";
   }

//更新订单信息为交易成功-ajax
   @ResponseBody
   @RequestMapping(value = "order/success/{order_code}", method = RequestMethod.PUT, produces = "application/json;charset=utf-8")
   public String orderSuccess(HttpSession session, @PathVariable("order_code") String order_code) {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("success", false);
           object.put("url", "/login");
           return object.toJSONString();
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 2) {
           logger.warn("订单状态不正确,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("更新订单信息");
       ProductOrder productOrder = new ProductOrder()
               .setProductOrder_id(order.getProductOrder_id())
               .setProductOrder_status((byte) 3)
               .setProductOrder_confirm_date(new Date());

boolean yn = productOrderService.update(productOrder);
       if (yn) {
           object.put("success", true);
       } else {
           object.put("success", false);
       }
       return object.toJSONString();
   }

//更新订单信息为交易关闭-ajax
   @ResponseBody
   @RequestMapping(value = "order/close/{order_code}", method = RequestMethod.PUT, produces = "application/json;charset=utf-8")
   public String orderClose(HttpSession session, @PathVariable("order_code") String order_code) {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("success", false);
           object.put("url", "/login");
           return object.toJSONString();
       }
       logger.info("------验证订单信息------");
       logger.info("查询订单是否存在");
       ProductOrder order = productOrderService.getByCode(order_code);
       if (order == null) {
           logger.warn("订单不存在,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("验证订单状态");
       if (order.getProductOrder_status() != 0) {
           logger.warn("订单状态不正确,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("验证用户与订单是否一致");
       if (order.getProductOrder_user().getUser_id() != Integer.parseInt(userId.toString())) {
           logger.warn("用户与订单信息不一致,返回订单列表页");
           object.put("success", false);
           object.put("url", "/order/0/10");
           return object.toJSONString();
       }
       logger.info("更新订单信息");
       ProductOrder productOrder = new ProductOrder()
               .setProductOrder_id(order.getProductOrder_id())
               .setProductOrder_status((byte) 4);

boolean yn = productOrderService.update(productOrder);
       if (yn) {
           object.put("success", true);
       } else {
           object.put("success", false);
       }
       return object.toJSONString();
   }

//更新购物车订单项数量-ajax
   @ResponseBody
   @RequestMapping(value = "orderItem", method = RequestMethod.PUT, produces = "application/json;charset=utf-8")
   public String updateOrderItem(HttpSession session, Map<String, Object> map, HttpServletResponse response,
                                 @RequestParam String orderItemMap) {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("success", false);
           return object.toJSONString();
       }

JSONObject orderItemString = JSON.parseObject(orderItemMap);
       Set<String> orderItemIDSet = orderItemString.keySet();
       if (orderItemIDSet.size() > 0) {
           logger.info("更新产品订单项数量");
           for (String key : orderItemIDSet) {
               ProductOrderItem productOrderItem = productOrderItemService.get(Integer.valueOf(key));
               if (productOrderItem == null || !productOrderItem.getProductOrderItem_user().getUser_id().equals(userId)) {
                   logger.warn("订单项为空或用户状态不一致!");
                   object.put("success", false);
                   return object.toJSONString();
               }
               if (productOrderItem.getProductOrderItem_order() != null) {
                   logger.warn("用户订单项不属于购物车,回到购物车页");
                   return "redirect:/cart";
               }
               Short number = Short.valueOf(orderItemString.getString(key));
               if (number <= 0 || number > 500) {
                   logger.warn("订单项产品数量不合法!");
                   object.put("success", false);
                   return object.toJSONString();
               }
               double price = productOrderItem.getProductOrderItem_price() / productOrderItem.getProductOrderItem_number();
               Boolean yn = productOrderItemService.update(new ProductOrderItem().setProductOrderItem_id(Integer.valueOf(key)).setProductOrderItem_number(number).setProductOrderItem_price(number * price));
               if (!yn) {
                   throw new RuntimeException();
               }
           }
           Object[] orderItemIDArray = orderItemIDSet.toArray();
           object.put("success", true);
           object.put("orderItemIDArray", orderItemIDArray);
           return object.toJSONString();
       } else {
           logger.warn("无订单项可以处理");
           object.put("success", false);
           return object.toJSONString();
       }
   }

//创建新订单-单订单项-ajax
   @ResponseBody
   @RequestMapping(value = "order", method = RequestMethod.POST, produces = "application/json;charset=utf-8")
   public String createOrderByOne(HttpSession session, Map<String, Object> map, HttpServletResponse response,
                                  @RequestParam String addressId,
                                  @RequestParam String cityAddressId,
                                  @RequestParam String districtAddressId,
                                  @RequestParam String productOrder_detail_address,
                                  @RequestParam String productOrder_post,
                                  @RequestParam String productOrder_receiver,
                                  @RequestParam String productOrder_mobile,
                                  @RequestParam String userMessage,
                                  @RequestParam Integer orderItem_product_id,
                                  @RequestParam Short orderItem_number) throws UnsupportedEncodingException {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("success", false);
           object.put("url", "/login");
           return object.toJSONString();
       }
       Product product = productService.get(orderItem_product_id);

if (product == null) {
           object.put("success", false);
           object.put("url", "/");
           return object.toJSONString();
       }
   if(product.getProduct_stock_count()<orderItem_number) {
   object.put("success", false);
           object.put("url", "/not");
           return object.toJSONString();
       }
       logger.info("将收货地址等相关信息存入Cookie中,便于下次使用");
       Cookie[] cookies = new Cookie[]{
               new Cookie("addressId", addressId),
               new Cookie("cityAddressId", cityAddressId),
               new Cookie("districtAddressId", districtAddressId),
               new Cookie("order_post", URLEncoder.encode(productOrder_post, "UTF-8")),
               new Cookie("order_receiver", URLEncoder.encode(productOrder_receiver, "UTF-8")),
               new Cookie("order_phone", URLEncoder.encode(productOrder_mobile, "UTF-8")),
               new Cookie("detailsAddress", URLEncoder.encode(productOrder_detail_address, "UTF-8"))
       };
       int maxAge = 60 * 60 * 24 * 365;
       for(Cookie cookie : cookies){
           //设置过期时间为一年
           cookie.setMaxAge(maxAge);
           //存储Cookie
           response.addCookie(cookie);
       }
       StringBuffer productOrder_code = new StringBuffer()
               .append(new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()))
               .append(0)
               .append(userId);
       logger.info("生成的订单号为:{}", productOrder_code);
       logger.info("整合订单对象");
       ProductOrder productOrder = new ProductOrder()
               .setProductOrder_status((byte) 0)
               .setProductOrder_address(new Address().setAddress_areaId(districtAddressId))
               .setProductOrder_post(productOrder_post)
               .setProductOrder_user(new User().setUser_id(Integer.valueOf(userId.toString())))
               .setProductOrder_mobile(productOrder_mobile)
               .setProductOrder_receiver(productOrder_receiver)
               .setProductOrder_detail_address(productOrder_detail_address)
               .setProductOrder_pay_date(new Date())
               .setProductOrder_code(productOrder_code.toString());
       Boolean yn = productOrderService.add(productOrder);
       if (!yn) {
           throw new RuntimeException();
       }
       Integer order_id = lastIDService.selectLastID();
       logger.info("整合订单项对象");
       ProductOrderItem productOrderItem = new ProductOrderItem()
               .setProductOrderItem_user(new User().setUser_id(Integer.valueOf(userId.toString())))
               .setProductOrderItem_product(productService.get(orderItem_product_id))
               .setProductOrderItem_number(orderItem_number)
               .setProductOrderItem_price(product.getProduct_sale_price() * orderItem_number)
               .setProductOrderItem_userMessage(userMessage)
               .setProductOrderItem_order(new ProductOrder().setProductOrder_id(order_id));
       yn = productOrderItemService.add(productOrderItem);
       if (!yn) {
           throw new RuntimeException();
       }

object.put("success", true);
       object.put("url", "/order/pay/" + productOrder.getProductOrder_code());
       return object.toJSONString();
   }

//创建新订单-多订单项-ajax
   @ResponseBody
   @RequestMapping(value = "order/list", method = RequestMethod.POST, produces = "application/json;charset=utf-8")
   public String createOrderByList(HttpSession session, Map<String, Object> map, HttpServletResponse response,
                                   @RequestParam String addressId,
                                   @RequestParam String cityAddressId,
                                   @RequestParam String districtAddressId,
                                   @RequestParam String productOrder_detail_address,
                                   @RequestParam String productOrder_post,
                                   @RequestParam String productOrder_receiver,
                                   @RequestParam String productOrder_mobile,
                                   @RequestParam String orderItemJSON) throws UnsupportedEncodingException {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("success", false);
           object.put("url", "/login");
           return object.toJSONString();
       }
       JSONObject orderItemMap = JSONObject.parseObject(orderItemJSON);
       Set<String> orderItem_id = orderItemMap.keySet();
       List<ProductOrderItem> productOrderItemList = new ArrayList<>(3);
       if (orderItem_id.size() > 0) {
           for (String id : orderItem_id) {
               ProductOrderItem orderItem = productOrderItemService.get(Integer.valueOf(id));
               if (orderItem == null || !orderItem.getProductOrderItem_user().getUser_id().equals(userId)) {
                   logger.warn("订单项为空或用户状态不一致!");
                   object.put("success", false);
                   object.put("url", "/cart");
                   return object.toJSONString();
               }
               if(orderItem.getProductOrderItem_product().getProduct_stock_count()<orderItem.getProductOrderItem_number()) {
           object.put("success", false);
                   object.put("url", "/not");
                   return object.toJSONString();
               }
               if (orderItem.getProductOrderItem_order() != null) {
                   logger.warn("用户订单项不属于购物车,回到购物车页");
                   object.put("success", false);
                   object.put("url", "/cart");
                   return object.toJSONString();
               }
               boolean yn = productOrderItemService.update(new ProductOrderItem().setProductOrderItem_id(Integer.valueOf(id)).setProductOrderItem_userMessage(orderItemMap.getString(id)));
               if (!yn) {
                   throw new RuntimeException();
               }
               orderItem.setProductOrderItem_product(productService.get(orderItem.getProductOrderItem_product().getProduct_id()));
               productOrderItemList.add(orderItem);
           }
       } else {
           object.put("success", false);
           object.put("url", "/cart");
           return object.toJSONString();
       }
       logger.info("将收货地址等相关信息存入Cookie中,便于下次使用");
       Cookie[] cookies = new Cookie[]{
               new Cookie("addressId", addressId),
               new Cookie("cityAddressId", cityAddressId),
               new Cookie("districtAddressId", districtAddressId),
               new Cookie("order_post", URLEncoder.encode(productOrder_post, "UTF-8")),
               new Cookie("order_receiver", URLEncoder.encode(productOrder_receiver, "UTF-8")),
               new Cookie("order_phone", URLEncoder.encode(productOrder_mobile, "UTF-8")),
               new Cookie("detailsAddress", URLEncoder.encode(productOrder_detail_address, "UTF-8"))
       };
       int maxAge = 60 * 60 * 24 * 365;
       for(Cookie cookie : cookies){
           //设置过期时间为一年
           cookie.setMaxAge(maxAge);
           //存储Cookie
           response.addCookie(cookie);
       }
       StringBuffer productOrder_code = new StringBuffer()
               .append(new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()))
               .append(0)
               .append(userId);
       logger.info("生成的订单号为:{}", productOrder_code);
       logger.info("整合订单对象");
       ProductOrder productOrder = new ProductOrder()
               .setProductOrder_status((byte) 0)
               .setProductOrder_address(new Address().setAddress_areaId(districtAddressId))
               .setProductOrder_post(productOrder_post)
               .setProductOrder_user(new User().setUser_id(Integer.valueOf(userId.toString())))
               .setProductOrder_mobile(productOrder_mobile)
               .setProductOrder_receiver(productOrder_receiver)
               .setProductOrder_detail_address(productOrder_detail_address)
               .setProductOrder_pay_date(new Date())
               .setProductOrder_code(productOrder_code.toString());
       Boolean yn = productOrderService.add(productOrder);
       if (!yn) {
           throw new RuntimeException();
       }
       Integer order_id = lastIDService.selectLastID();
       logger.info("整合订单项对象");
       for (ProductOrderItem orderItem : productOrderItemList) {
           orderItem.setProductOrderItem_order(new ProductOrder().setProductOrder_id(order_id));
           yn = productOrderItemService.update(orderItem);
       }
       if (!yn) {
           throw new RuntimeException();
       }

object.put("success", true);
       object.put("url", "/order/pay/" + productOrder.getProductOrder_code());
       return object.toJSONString();
   }

//创建订单项-购物车-ajax
   @ResponseBody
   @RequestMapping(value = "orderItem/create/{product_id}", method = RequestMethod.POST, produces = "application/json;charset=utf-8")
   public String createOrderItem(@PathVariable("product_id") Integer product_id,
                                 @RequestParam(required = false, defaultValue = "1") Short product_number,
                                 HttpSession session,
                                 HttpServletRequest request) {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("url", "/login");
           object.put("success", false);
           return object.toJSONString();
       }

logger.info("通过产品ID获取产品信息:{}", product_id);
       Product product = productService.get(product_id);
       if (product == null) {
           object.put("url", "/login");
           object.put("success", false);
           return object.toJSONString();
       }

ProductOrderItem productOrderItem = new ProductOrderItem();
       logger.info("检查用户的购物车项");
       List<ProductOrderItem> orderItemList = productOrderItemService.getListByUserId(Integer.valueOf(userId.toString()), null);
       for (ProductOrderItem orderItem : orderItemList) {
           if (orderItem.getProductOrderItem_product().getProduct_id().equals(product_id)) {
               logger.info("找到已有的产品,进行数量追加");
               int number = orderItem.getProductOrderItem_number();
               number += 1;
               productOrderItem.setProductOrderItem_id(orderItem.getProductOrderItem_id());
               productOrderItem.setProductOrderItem_number((short) number);
               productOrderItem.setProductOrderItem_price(number * product.getProduct_sale_price());
               boolean yn = productOrderItemService.update(productOrderItem);
               if (yn) {
                   object.put("success", true);
               } else {
                   object.put("success", false);
               }
               return object.toJSONString();
           }
       }
       logger.info("封装订单项对象");
       productOrderItem.setProductOrderItem_product(product);
       productOrderItem.setProductOrderItem_number(product_number);
       productOrderItem.setProductOrderItem_price(product.getProduct_sale_price() * product_number);
       productOrderItem.setProductOrderItem_user(new User().setUser_id(Integer.valueOf(userId.toString())));
       boolean yn = productOrderItemService.add(productOrderItem);
       if (yn) {
           object.put("success", true);
       } else {
           object.put("success", false);
       }
       return object.toJSONString();
   }

//删除订单项-购物车-ajax
   @ResponseBody
   @RequestMapping(value = "orderItem/{orderItem_id}", method = RequestMethod.DELETE, produces = "application/json;charset=utf-8")
   public String deleteOrderItem(@PathVariable("orderItem_id") Integer orderItem_id,
                                 HttpSession session,
                                 HttpServletRequest request) {
       JSONObject object = new JSONObject();
       logger.info("检查用户是否登录");
       Object userId = checkUser(session);
       if (userId == null) {
           object.put("url", "/login");
           object.put("success", false);
           return object.toJSONString();
       }
       logger.info("检查用户的购物车项");
       List<ProductOrderItem> orderItemList = productOrderItemService.getListByUserId(Integer.valueOf(userId.toString()), null);
       boolean isMine = false;
       for (ProductOrderItem orderItem : orderItemList) {
           logger.info("找到匹配的购物车项");
           if (orderItem.getProductOrderItem_id().equals(orderItem_id)) {
               isMine = true;
               break;
           }
       }
       if (isMine) {
           logger.info("删除订单项信息");
           boolean yn = productOrderItemService.deleteList(new Integer[]{orderItem_id});
           if (yn) {
               object.put("success", true);
           } else {
               object.put("success", false);
           }
       } else {
           object.put("success", false);
       }
       return object.toJSONString();
   }
}

用户登录页:


/**
* 登陆页
*/
@Controller
public class ForeLoginController extends BaseController {
   @Resource(name = "userService")
   private UserService userService;

//转到前台天猫-登录页
   @RequestMapping(value = "login", method = RequestMethod.GET)
   public String goToPage(HttpSession session, Map<String, Object> map) {
       logger.info("转到前台天猫-登录页");
       return "fore/loginPage";
   }
   @RequestMapping(value = "not", method = RequestMethod.GET)
   public String not(HttpSession session, Map<String, Object> map) {
       logger.info("转到cuwu页");
       return "fore/not";
   }
   //登陆验证-ajax
   @ResponseBody
   @RequestMapping(value = "login/doLogin", method = RequestMethod.POST, produces = "application/json;charset=utf-8")
   public String checkLogin(HttpSession session, @RequestParam String username, @RequestParam String password) {
       logger.info("用户验证登录");
       User user = userService.login(username, password);

JSONObject jsonObject = new JSONObject();
       if (user == null) {
           logger.info("登录验证失败");
           jsonObject.put("success", false);
       } else {
           logger.info("登录验证成功,用户ID传入会话");
           session.setAttribute("userId", user.getUser_id());
           jsonObject.put("success", true);
       }
       return jsonObject.toJSONString();
   }

//退出当前账号
   @RequestMapping(value = "login/logout", method = RequestMethod.GET)
   public String logout(HttpSession session) {
       Object o = session.getAttribute("userId");
       if (o != null) {
           session.removeAttribute("userId");
           session.invalidate();
           logger.info("登录信息已清除,返回用户登录页");
       }
       return "redirect:/login";
   }
}

来源:https://blog.csdn.net/pastclouds/article/details/122495992

0
投稿

猜你喜欢

  • C# using 三种使用方式介绍1.using指令。using + 命名空间名字,这样可以在程序中直接用命令空间中的类型,而不必指定类型的
  • java 线程池详解什么是线程池?提供一组线程资源用来复用线程资源的一个池子为什么要用线程池?线程的资源是有限的,当处理一组业务的时候,我们
  • Java泛型映射不同的值类型详解前言:一般来说,开发人员偶尔会遇到这样的情形: 在一个特定容器中映射任意类型的值。然而Java 集合API只
  • 很多开发者表示,不知道Android的Drawable和Bitmap之间如何相关转换。下面Android123给大家两种比较简单高效的方法。
  • 线程死锁是指由于两个或者多个线程互相持有对方所需要的资源,导致这些线程处于等待状态,无法前往执行。当线程进入对象的synchronized代
  • 在项目开发中经常会遇到调用第三方接口的情况,比如说调用第三方的天气预报接口。使用流程【1】准备工作:在项目的工具包下导入HttpClient
  • 1.基本介绍代码块又称为初始化块,属于类中的成员(类的一部分),类似于方法,讲逻辑语句封装在方法体中,用{}抱起来;但和方法不同,没有方法名
  • 鉴于各种复杂的网络环境,笔者决定采用不同的编程接口进行下载尝试,以增加程序的可用性。这里仅介绍使用 WebClient 的方法,后续的文章会
  • Android studio 出现 Unsupported major.minor version 52.0解决办法  最近更新了
  • 本文实例为大家分享了Java实现小型图书馆管理系统的具体代码,供大家参考,具体内容如下以下为小型图书馆管理系统模式图:模式总体概述:其中IB
  • 前言MyBatis中也提供了注解式开发⽅式,采⽤注解可以减少Sql映射⽂件的配置。 当然,使⽤注解式开发的话,sql语句是写在java程序中
  • 分页使用可以说非常普遍了,有时候会需要非常灵活的方式去开启或关闭分页,尝试使用一 * 解的方式来进行分页。依赖安装需要使用的依赖:Mybati
  • 之前写了一篇文章:Java 网络IO编程总结(BIO、NIO、AIO均含完整实例代码),介绍了如何使用Java原生IO支持进行网络编程,本文
  • 本次和大家分享的是怎么来消费服务,上篇文章讲了使用Feign来消费,本篇来使用rest+ribbon消费服务,并且通过轮询方式来自定义了个简
  • 本文实例为大家分享了unity实现手游虚拟摇杆的具体代码,供大家参考,具体内容如下using System.Collections;usin
  • 本文实例为大家分享了unity鼠标或者手指点击模型播放动的具体代码,供大家参考,具体内容如下using UnityEngine;using
  • 就是每隔一定的时间显示一张图片,全部图片文件位于:“工作空间\项目名称\bin\动态图\花好月圆\”文件夹下。文件名类似:1001.jpg,
  • 成为一名优秀的软件开发工程师,设计模式的重要性不言而喻,本章节是对设计模式的前置知识概述,涉及概念性较大,读者可在设计模式学习过程中参阅本文
  • 本文实例为大家分享了java模拟斗地主发牌的具体代码,供大家参考,具体内容如下1.案例介绍规则:组装54张扑克牌54张牌顺序打乱三个玩家参与
  • C++ 中const修饰虚函数实例详解【1】程序1#include <iostream>using namespace std;
手机版 软件编程 asp之家 www.aspxhome.com