Java实战之仿天猫商城系统的实现_Java教程

一、项目介绍

迷你天猫商城是一个基于SSM框架的综合性B2C电商平台，需求设计主要参考天猫商城的购物流程：用户从注册开始，到完成登录，浏览商品，加入购物车，进行下单，确认收货，评价等一系列操作。

作为模拟天猫商城系统的核心组成部分之一，采用SSM框架的天猫数据管理后台包含商品管理，订单管理，类别管理，用户管理和交易额统计等模块，实现了对整个商城的一站式管理和维护。

二、项目运行

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

项目技术： JSP + Springboot + SpringMVC + Spring +MyBatis + css + JavaScript + JQuery + Ajax + layui+ maven等等。

三、效果图

Java实战之仿天猫商城系统的实现

四、核心代码

权限基础控制层

				?

									/**

									 * 基控制器

									 */

									public class BaseController {

									    //log4j

									    protected Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);

									    //检查管理员权限

									    protected Object checkAdmin(HttpSession session){

									        Object o = session.getAttribute("adminId");

									        if(o==null){

									            logger.info("无管理权限，返回管理员登陆页");

									            return null;

									        }

									        logger.info("权限验证成功，管理员ID：{}",o);

									        return o;

									    }

									    //检查用户是否登录

									    protected Object checkUser(HttpSession session){

									        Object o = session.getAttribute("userId");

									        if(o==null){

									            logger.info("用户未登录");

									            return null;

									        }

									        logger.info("用户已登录，用户ID：{}", o);

									        return o;

									    }

									}

用户信息操作控制层

				?

									@Controller

									public class ForeUserController extends BaseController{

									    @Autowired

									    private AddressService addressService;

									    @Autowired

									    private UserService userService;

									    //转到前台天猫-用户详情页

									    @RequestMapping(value = "userDetails", method = RequestMethod.GET)

									    public String goToUserDetail(HttpSession session, Map<String,Object> map){

									        logger.info("检查用户是否登录");

									        Object userId = checkUser(session);

									        if (userId != null) {

									            logger.info("获取用户信息");

									            User user = userService.get(Integer.parseInt(userId.toString()));

									            map.put("user", user);

									            logger.info("获取用户所在地区级地址");

									            String districtAddressId = user.getUser_address().getAddress_areaId();

									            Address districtAddress = addressService.get(districtAddressId);

									            logger.info("获取市级地址信息");

									            Address cityAddress = addressService.get(districtAddress.getAddress_regionId().getAddress_areaId());

									            logger.info("获取其他地址信息");

									            List<Address> addressList = addressService.getRoot();

									            List<Address> cityList = addressService.getList(null,cityAddress.getAddress_regionId().getAddress_areaId());

									            List<Address> districtList = addressService.getList(null,cityAddress.getAddress_areaId());

									            map.put("addressList", addressList);

									            map.put("cityList", cityList);

									            map.put("districtList", districtList);

									            map.put("addressId", cityAddress.getAddress_regionId().getAddress_areaId());

									            map.put("cityAddressId", cityAddress.getAddress_areaId());

									            map.put("districtAddressId", districtAddressId);

									            return  "fore/userDetails";

									        } else {

									            return "redirect:/login";

									        }

									    }

									    //前台天猫-用户更换头像

									    @ResponseBody

									    @RequestMapping(value = "user/uploadUserHeadImage", method = RequestMethod.POST, produces = "application/json;charset=utf-8")

									    public  String uploadUserHeadImage(@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/userProfilePicture/" + fileName;

									        logger.info("文件上传路径：{}", filePath);

									        JSONObject jsonObject = new JSONObject();

									        try {

									            logger.info("文件上传中...");

									            file.transferTo(new File(filePath));

									            logger.info("文件上传成功！");

									            jsonObject.put("success", true);

									            jsonObject.put("fileName", fileName);

									        } catch (IOException e) {

									            logger.warn("文件上传失败！");

									            e.printStackTrace();

									            jsonObject.put("success", false);

									        }

									        return jsonObject.toJSONString();

									    }

									    //前台天猫-用户详情更新

									    @RequestMapping(value="user/update",method=RequestMethod.POST,produces ="application/json;charset=utf-8")

									    public String userUpdate(HttpSession session, Map<String,Object> map,

									                             @RequestParam(value = "user_nickname") String user_nickname  /*用户昵称 */,

									                             @RequestParam(value = "user_realname") String user_realname  /*真实姓名*/,

									                             @RequestParam(value = "user_gender") String user_gender  /*用户性别*/,

									                             @RequestParam(value = "user_birthday") String user_birthday /*用户生日*/,

									                             @RequestParam(value = "user_address") String user_address  /*用户所在地 */,

									                             @RequestParam(value = "user_profile_picture_src", required = false) String user_profile_picture_src /* 用户头像*/,

									                             @RequestParam(value = "user_password") String user_password/* 用户密码 */

									    ) throws ParseException, UnsupportedEncodingException {

									        logger.info("检查用户是否登录");

									        Object userId = checkUser(session);

									        if (userId != null) {

									            logger.info("获取用户信息");

									            User user = userService.get(Integer.parseInt(userId.toString()));

									            map.put("user", user);

									        } else {

									            return "redirect:/login";

									        }

									        logger.info("创建用户对象");

									        if (user_profile_picture_src != null && "".equals(user_profile_picture_src)) {

									            user_profile_picture_src = null;

									        }

									        User userUpdate = new User()

									                .setUser_id(Integer.parseInt(userId.toString()))

									                .setUser_nickname(new String(user_nickname.getBytes("ISO8859-1"),"UTF-8"))

									                .setUser_realname(new String(user_realname.getBytes("ISO8859-1"),"UTF-8"))

									                .setUser_gender(Byte.valueOf(user_gender))

									                .setUser_birthday(new SimpleDateFormat("yyyy-MM-dd").parse(user_birthday))

									                .setUser_address(new Address().setAddress_areaId(user_address))

									                .setUser_profile_picture_src(user_profile_picture_src)

									                .setUser_password(user_password);

									        logger.info("执行修改");

									        if (userService.update(userUpdate)){

									             logger.info("修改成功!跳转到用户详情页面");

									             return "redirect:/userDetails";

									         }

									         throw new RuntimeException();

									    }

									}

用户订单控制层

				?

									@Controller

									public class ForeOrderController extends BaseController {

									    @Autowired

									    private ProductService productService;

									    @Autowired

									    private UserService userService;

									    @Autowired

									    private ProductOrderItemService productOrderItemService;

									    @Autowired

									    private AddressService addressService;

									    @Autowired

									    private CategoryService categoryService;

									    @Autowired

									    private ProductImageService productImageService;

									    @Autowired

									    private ProductOrderService productOrderService;

									    @Autowired

									    private ReviewService reviewService;

									    @Autowired

									    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();

									        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);

									            orderTotalPrice = productOrderItem.getProductOrderItem_price();

									        } else {

									            for (ProductOrderItem productOrderItem : order.getProductOrderItemList()) {

									                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();

									        } else {

									            for (ProductOrderItem productOrderItem : order.getProductOrderItemList()) {

									                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();

									        }

									        logger.info("将收货地址等相关信息存入Cookie中");

									        Cookie cookie1 = new Cookie("addressId", addressId);

									        Cookie cookie2 = new Cookie("cityAddressId", cityAddressId);

									        Cookie cookie3 = new Cookie("districtAddressId", districtAddressId);

									        Cookie cookie4 = new Cookie("order_post", URLEncoder.encode(productOrder_post, "UTF-8"));

									        Cookie cookie5 = new Cookie("order_receiver", URLEncoder.encode(productOrder_receiver, "UTF-8"));

									        Cookie cookie6 = new Cookie("order_phone", URLEncoder.encode(productOrder_mobile, "UTF-8"));

									        Cookie cookie7 = new Cookie("detailsAddress", URLEncoder.encode(productOrder_detail_address, "UTF-8"));

									        //设置过期时间为一年

									        int maxAge = 60 * 60 * 24 * 365;

									        cookie1.setMaxAge(maxAge);

									        cookie2.setMaxAge(maxAge);

									        cookie3.setMaxAge(maxAge);

									        cookie4.setMaxAge(maxAge);

									        cookie5.setMaxAge(maxAge);

									        cookie6.setMaxAge(maxAge);

									        cookie7.setMaxAge(maxAge);

									        response.addCookie(cookie1);

									        response.addCookie(cookie2);

									        response.addCookie(cookie3);

									        response.addCookie(cookie4);

									        response.addCookie(cookie5);

									        response.addCookie(cookie6);

									        response.addCookie(cookie7);

									        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_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 cookie1 = new Cookie("addressId", addressId);

									        Cookie cookie2 = new Cookie("cityAddressId", cityAddressId);

									        Cookie cookie3 = new Cookie("districtAddressId", districtAddressId);

									        Cookie cookie4 = new Cookie("order_post", URLEncoder.encode(productOrder_post, "UTF-8"));

									        Cookie cookie5 = new Cookie("order_receiver", URLEncoder.encode(productOrder_receiver, "UTF-8"));

									        Cookie cookie6 = new Cookie("order_phone", URLEncoder.encode(productOrder_mobile, "UTF-8"));

									        Cookie cookie7 = new Cookie("detailsAddress", URLEncoder.encode(productOrder_detail_address, "UTF-8"));

									        //设置过期时间为一年

									        int maxAge = 60 * 60 * 24 * 365;

									        cookie1.setMaxAge(maxAge);

									        cookie2.setMaxAge(maxAge);

									        cookie3.setMaxAge(maxAge);

									        cookie4.setMaxAge(maxAge);

									        cookie5.setMaxAge(maxAge);

									        cookie6.setMaxAge(maxAge);

									        cookie7.setMaxAge(maxAge);

									        response.addCookie(cookie1);

									        response.addCookie(cookie2);

									        response.addCookie(cookie3);

									        response.addCookie(cookie4);

									        response.addCookie(cookie5);

									        response.addCookie(cookie6);

									        response.addCookie(cookie7);

									        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 CategoryController extends BaseController {

									    @Autowired

									    private CategoryService categoryService;

									    @Autowired

									    private LastIDService lastIDService;

									    @Autowired

									    private PropertyService propertyService;

									    //转到后台管理-分类页-ajax

									    @RequestMapping(value = "admin/category", method = RequestMethod.GET)

									    public String goToPage(HttpSession session, Map<String, Object> map) {

									        logger.info("检查管理员权限");

									        Object adminId = checkAdmin(session);

									        if (adminId == null) {

									            return "admin/include/loginMessage";

									        }

									        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("检查管理员权限");

									        Object adminId = checkAdmin(session);

									        if (adminId == null) {

									            return "admin/include/loginMessage";

									        }

									        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("检查管理员权限");

									        Object adminId = checkAdmin(session);

									        if (adminId == null) {

									            return "admin/include/loginMessage";

									        }

									        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 ProductController extends BaseController{

									    @Autowired

									    private CategoryService categoryService;

									    @Autowired

									    private ProductService productService;

									    @Autowired

									    private ProductImageService productImageService;

									    @Autowired

									    private PropertyService propertyService;

									    @Autowired

									    private PropertyValueService propertyValueService;

									    @Autowired

									    private LastIDService lastIDService;

									    //转到后台管理-产品页-ajax

									    @RequestMapping(value = "admin/product",method = RequestMethod.GET)

									    public String goToPage(HttpSession session, Map<String, Object> map) {

									        logger.info("检查管理员权限");

									        Object adminId = checkAdmin(session);

									        if(adminId == null){

									            return "admin/include/loginMessage";

									        }

									        logger.info("获取产品分类列表");

									        List<Category> categoryList = categoryService.getList(null, null);

									        map.put("categoryList", categoryList);

									        logger.info("获取前10条产品列表");

									        PageUtil pageUtil = new PageUtil(0, 10);

									        List<Product> productList = productService.getList(null, null, null, pageUtil);

									        map.put("productList", productList);

									        logger.info("获取产品总数量");

									        Integer productCount = productService.getTotal(null, null);

									        map.put("productCount", productCount);

									        logger.info("获取分页信息");

									        pageUtil.setTotal(productCount);

									        map.put("pageUtil", pageUtil);

									        logger.info("转到后台管理-产品页-ajax方式");

									        return "admin/productManagePage";

									    }

									    //转到后台管理-产品详情页-ajax

									    @RequestMapping(value="admin/product/{pid}",method = RequestMethod.GET)

									    public String goToDetailsPage(HttpSession session, Map<String, Object> map, @PathVariable Integer pid/* 产品ID */) {

									        logger.info("检查管理员权限");

									        Object adminId = checkAdmin(session);

									        if(adminId == null){

									            return "admin/include/loginMessage";

									        }

									        logger.info("获取product_id为{}的产品信息",pid);

									        Product product = productService.get(pid);

									        logger.info("获取产品详情-图片信息");

									        Integer product_id =product.getProduct_id();

									        List<ProductImage> productImageList = productImageService.getList(product_id, null, null);

									        List<ProductImage> singleProductImageList = new ArrayList<>(5);

									        List<ProductImage> detailsProductImageList = new ArrayList<>(8);

									        for (ProductImage productImage : productImageList) {

									            if (productImage.getProductImage_type() == 0) {

									                singleProductImageList.add(productImage);

									            } else {

									                detailsProductImageList.add(productImage);

									            }

									        }

									        product.setSingleProductImageList(singleProductImageList);

									        product.setDetailProductImageList(detailsProductImageList);

									        map.put("product",product);

									        logger.info("获取产品详情-属性值信息");

									        List<PropertyValue> propertyValueList = propertyValueService.getList(new PropertyValue().setPropertyValue_product(product),null);

									        logger.info("获取产品详情-分类信息对应的属性列表");

									        List<Property> propertyList = propertyService.getList(new Property().setProperty_category(product.getProduct_category()),null);

									        logger.info("属性列表和属性值列表合并");

									        for(Property property : propertyList){

									            for(PropertyValue propertyValue : propertyValueList){

									                if(property.getProperty_id().equals(propertyValue.getPropertyValue_property().getProperty_id())){

									                    List<PropertyValue> property_value_item = new ArrayList<>(1);

									                    property_value_item.add(propertyValue);

									                    property.setPropertyValueList(property_value_item);

									                    break;

									                }

									            }

									        }

									        map.put("propertyList",propertyList);

									        logger.info("获取分类列表");

									        List<Category> categoryList = categoryService.getList(null,null);

									        map.put("categoryList",categoryList);

									        logger.info("转到后台管理-产品详情页-ajax方式");

									        return "admin/include/productDetails";

									    }

									    //转到后台管理-产品添加页-ajax

									    @RequestMapping(value = "admin/product/new",method = RequestMethod.GET)

									    public String goToAddPage(HttpSession session,Map<String, Object> map){

									        logger.info("检查管理员权限");

									        Object adminId = checkAdmin(session);

									        if(adminId == null){

									            return "admin/include/loginMessage";

									        }

									        logger.info("获取分类列表");

									        List<Category> categoryList = categoryService.getList(null,null);

									        map.put("categoryList",categoryList);

									        logger.info("获取第一个分类信息对应的属性列表");

									        List<Property> propertyList = propertyService.getList(new Property().setProperty_category(categoryList.get(0)),null);

									        map.put("propertyList",propertyList);

									        logger.info("转到后台管理-产品添加页-ajax方式");

									        return "admin/include/productDetails";

									    }

									    //添加产品信息-ajax.

									    @ResponseBody

									    @RequestMapping(value = "admin/product", method = RequestMethod.POST,produces = "application/json;charset=utf-8")

									    public String addProduct(@RequestParam String product_name/* 产品名称 */,

									                             @RequestParam String product_title/* 产品标题 */,

									                             @RequestParam Integer product_category_id/* 产品类型ID */,

									                             @RequestParam Double product_sale_price/* 产品最低价 */,

									                             @RequestParam Double product_price/* 产品最高价 */,

									                             @RequestParam Byte product_isEnabled/* 产品状态 */,

									                             @RequestParam String propertyJson/* 产品属性JSON */,

									                             @RequestParam(required = false) String[] productSingleImageList/*产品预览图片名称数组*/,

									                             @RequestParam(required = false) String[] productDetailsImageList/*产品详情图片名称数组*/) {

									        JSONObject jsonObject = new JSONObject();

									        logger.info("整合产品信息");

									        Product product = new Product()

									                .setProduct_name(product_name)

									                .setProduct_title(product_title)

									                .setProduct_category(new Category().setCategory_id(product_category_id))

									                .setProduct_sale_price(product_sale_price)

									                .setProduct_price(product_price)

									                .setProduct_isEnabled(product_isEnabled)

									                .setProduct_create_date(new Date());

									        logger.info("添加产品信息");

									        boolean yn = productService.add(product);

									        if (!yn) {

									            logger.warn("产品添加失败！事务回滚");

									            jsonObject.put("success", false);

									            throw new RuntimeException();

									        }

									        int product_id = lastIDService.selectLastID();

									        logger.info("添加成功！,新增产品的ID值为：{}", product_id);

									        JSONObject object = JSON.parseObject(propertyJson);

									        Set<String> propertyIdSet = object.keySet();

									        if (propertyIdSet.size() > 0) {

									            logger.info("整合产品子信息-产品属性");

									            List<PropertyValue> propertyValueList = new ArrayList<>(5);

									            for (String key : propertyIdSet) {

									                String value = object.getString(key);

									                PropertyValue propertyValue = new PropertyValue()

									                        .setPropertyValue_value(value)

									                        .setPropertyValue_property(new Property().setProperty_id(Integer.valueOf(key)))

									                        .setPropertyValue_product(new Product().setProduct_id(product_id));

									                propertyValueList.add(propertyValue);

									            }

									            logger.info("共有{}条产品属性数据", propertyValueList.size());

									            yn = propertyValueService.addList(propertyValueList);

									            if (yn) {

									                logger.info("产品属性添加成功！");

									            } else {

									                logger.warn("产品属性添加失败！事务回滚");

									                jsonObject.put("success", false);

									                throw new RuntimeException();

									            }

									        }

									        if (productSingleImageList != null && productSingleImageList.length > 0) {

									            logger.info("整合产品子信息-产品预览图片");

									            List<ProductImage> productImageList = new ArrayList<>(5);

									            for (String imageName : productSingleImageList) {

									                productImageList.add(new ProductImage()

									                        .setProductImage_type((byte) 0)

									                        .setProductImage_src(imageName.substring(imageName.lastIndexOf("/") + 1))

									                        .setProductImage_product(new Product().setProduct_id(product_id))

									                );

									            }

									            logger.info("共有{}条产品预览图片数据", productImageList.size());

									            yn = productImageService.addList(productImageList);

									            if (yn) {

									                logger.info("产品预览图片添加成功！");

									            } else {

									                logger.warn("产品预览图片添加失败！事务回滚");

									                jsonObject.put("success", false);

									                throw new RuntimeException();

									            }

									        }

									        if (productDetailsImageList != null && productDetailsImageList.length > 0) {

									            logger.info("整合产品子信息-产品详情图片");

									            List<ProductImage> productImageList = new ArrayList<>(5);

									            for (String imageName : productDetailsImageList) {

									                productImageList.add(new ProductImage()

									                        .setProductImage_type((byte) 1)

									                        .setProductImage_src(imageName.substring(imageName.lastIndexOf("/") + 1))

									                        .setProductImage_product(new Product().setProduct_id(product_id))

									                );

									            }

									            logger.info("共有{}条产品详情图片数据", productImageList.size());

									            yn = productImageService.addList(productImageList);

									            if (yn) {

									                logger.info("产品详情图片添加成功！");

									            } else {

									                logger.warn("产品详情图片添加失败！事务回滚");

									                jsonObject.put("success", false);

									                throw new RuntimeException();

									            }

									        }

									        logger.info("产品信息及其子信息添加成功！");

									        jsonObject.put("success", true);

									        jsonObject.put("product_id", product_id);

									        return jsonObject.toJSONString();

									    }

									    //更新产品信息-ajax

									    @ResponseBody

									    @RequestMapping(value = "admin/product/{product_id}", method = RequestMethod.PUT, produces = "application/json;charset=utf-8")

									    public String updateProduct(@RequestParam String product_name/* 产品名称 */,

									                                @RequestParam String product_title/* 产品标题 */,

									                                @RequestParam Integer product_category_id/* 产品类型ID */,

									                                @RequestParam Double product_sale_price/* 产品最低价 */,

									                                @RequestParam Double product_price/* 产品最高价 */,

									                                @RequestParam Byte product_isEnabled/* 产品状态 */,

									                                @RequestParam String propertyAddJson/* 产品添加属性JSON */,

									                                @RequestParam String propertyUpdateJson/* 产品更新属性JSON */,

									                                @RequestParam(required = false) Integer[] propertyDeleteList/* 产品删除属性ID数组 */,

									                                @RequestParam(required = false) String[] productSingleImageList/*产品预览图片名称数组*/,

									                                @RequestParam(required = false) String[] productDetailsImageList/*产品详情图片名称数组*/,

									                                @PathVariable("product_id") Integer product_id/* 产品ID */) {

									        JSONObject jsonObject = new JSONObject();

									        logger.info("整合产品信息");

									        Product product = new Product()

									                .setProduct_id(product_id)

									                .setProduct_name(product_name)

									                .setProduct_title(product_title)

									                .setProduct_category(new Category().setCategory_id(product_category_id))

									                .setProduct_sale_price(product_sale_price)

									                .setProduct_price(product_price)

									                .setProduct_isEnabled(product_isEnabled)

									                .setProduct_create_date(new Date());

									        logger.info("更新产品信息，产品ID值为：{}", product_id);

									        boolean yn = productService.update(product);

									        if (!yn) {

									            logger.info("产品信息更新失败！事务回滚");

									            jsonObject.put("success", false);

									            throw new RuntimeException();

									        }

									        logger.info("产品信息更新成功！");

									        JSONObject object = JSON.parseObject(propertyAddJson);

									        Set<String> propertyIdSet = object.keySet();

									        if (propertyIdSet.size() > 0) {

									            logger.info("整合产品子信息-需要添加的产品属性");

									            List<PropertyValue> propertyValueList = new ArrayList<>(5);

									            for (String key : propertyIdSet) {

									                String value = object.getString(key);

									                PropertyValue propertyValue = new PropertyValue()

									                        .setPropertyValue_value(value)

									                        .setPropertyValue_property(new Property().setProperty_id(Integer.valueOf(key)))

									                        .setPropertyValue_product(product);

									                propertyValueList.add(propertyValue);

									            }

									            logger.info("共有{}条需要添加的产品属性数据", propertyValueList.size());

									            yn = propertyValueService.addList(propertyValueList);

									            if (yn) {

									                logger.info("产品属性添加成功！");

									            } else {

									                logger.warn("产品属性添加失败！事务回滚");

									                jsonObject.put("success", false);

									                throw new RuntimeException();

									            }

									        }

									        object = JSON.parseObject(propertyUpdateJson);

									        propertyIdSet = object.keySet();

									        if (propertyIdSet.size() > 0) {

									            logger.info("整合产品子信息-需要更新的产品属性");

									            List<PropertyValue> propertyValueList = new ArrayList<>(5);

									            for (String key : propertyIdSet) {

									                String value = object.getString(key);

									                PropertyValue propertyValue = new PropertyValue()

									                        .setPropertyValue_value(value)

									                        .setPropertyValue_id(Integer.valueOf(key));

									                propertyValueList.add(propertyValue);

									            }

									            logger.info("共有{}条需要更新的产品属性数据", propertyValueList.size());

									            for (int i = 0; i < propertyValueList.size(); i++) {

									                logger.info("正在更新第{}条，共{}条", i + 1, propertyValueList.size());

									                yn = propertyValueService.update(propertyValueList.get(i));

									                if (yn) {

									                    logger.info("产品属性更新成功！");

									                } else {

									                    logger.warn("产品属性更新失败！事务回滚");

									                    jsonObject.put("success", false);

									                    throw new RuntimeException();

									                }

									            }

									        }

									        if (propertyDeleteList != null && propertyDeleteList.length > 0) {

									            logger.info("整合产品子信息-需要删除的产品属性");

									            logger.info("共有{}条需要删除的产品属性数据", propertyDeleteList.length);

									            yn = propertyValueService.deleteList(propertyDeleteList);

									            if (yn) {

									                logger.info("产品属性删除成功！");

									            } else {

									                logger.warn("产品属性删除失败！事务回滚");

									                jsonObject.put("success", false);

									                throw new RuntimeException();

									            }

									        }

									        if (productSingleImageList != null && productSingleImageList.length > 0) {

									            logger.info("整合产品子信息-产品预览图片");

									            List<ProductImage> productImageList = new ArrayList<>(5);

									            for (String imageName : productSingleImageList) {

									                productImageList.add(new ProductImage()

									                        .setProductImage_type((byte) 0)

									                        .setProductImage_src(imageName.substring(imageName.lastIndexOf("/") + 1))

									                        .setProductImage_product(product)

									                );

									            }

									            logger.info("共有{}条产品预览图片数据", productImageList.size());

									            yn = productImageService.addList(productImageList);

									            if (yn) {

									                logger.info("产品预览图片添加成功！");

									            } else {

									                logger.warn("产品预览图片添加失败！事务回滚");

									                jsonObject.put("success", false);

									                throw new RuntimeException();

									            }

									        }

									        if (productDetailsImageList != null && productDetailsImageList.length > 0) {

									            logger.info("整合产品子信息-产品详情图片");

									            List<ProductImage> productImageList = new ArrayList<>(5);

									            for (String imageName : productDetailsImageList) {

									                productImageList.add(new ProductImage()

									                        .setProductImage_type((byte) 1)

									                        .setProductImage_src(imageName.substring(imageName.lastIndexOf("/") + 1))

									                        .setProductImage_product(product)

									                );

									            }

									            logger.info("共有{}条产品详情图片数据", productImageList.size());

									            yn = productImageService.addList(productImageList);

									            if (yn) {

									                logger.info("产品详情图片添加成功！");

									            } else {

									                logger.warn("产品详情图片添加失败！事务回滚");

									                jsonObject.put("success", false);

									                throw new RuntimeException();

									            }

									        }

									        jsonObject.put("success", true);

									        jsonObject.put("product_id", product_id);

									        return jsonObject.toJSONString();

									    }

									    //按条件查询产品-ajax

									    @ResponseBody

									    @RequestMapping(value = "admin/product/{index}/{count}", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

									    public String getProductBySearch(@RequestParam(required = false) String product_name/* 产品名称 */,

									                                     @RequestParam(required = false) Integer category_id/* 产品类型ID */,

									                                     @RequestParam(required = false) Double product_sale_price/* 产品最低价 */,

									                                     @RequestParam(required = false) Double product_price/* 产品最高价 */,

									                                     @RequestParam(required = false) Byte[] product_isEnabled_array/* 产品状态数组 */,

									                                     @RequestParam(required = false) String orderBy/* 排序字段 */,

									                                     @RequestParam(required = false,defaultValue = "true") Boolean isDesc/* 是否倒序 */,

									                                     @PathVariable Integer index/* 页数 */,

									                                     @PathVariable Integer count/* 行数 */) throws UnsupportedEncodingException {

									        //移除不必要条件

									        if (product_isEnabled_array != null && (product_isEnabled_array.length <= 0 || product_isEnabled_array.length >=3)) {

									            product_isEnabled_array = null;

									        }

									        if (category_id != null && category_id == 0) {

									            category_id = null;

									        }

									        if (product_name != null) {

									            //如果为非空字符串则解决中文乱码：URLDecoder.decode(String,"UTF-8");

									            product_name = "".equals(product_name) ? null : URLDecoder.decode(product_name, "UTF-8");

									        }

									        if (orderBy != null && "".equals(orderBy)) {

									            orderBy = null;

									        }

									        //封装查询条件

									        Product product = new Product()

									                .setProduct_name(product_name)

									                .setProduct_category(new Category().setCategory_id(category_id))

									                .setProduct_price(product_price)

									                .setProduct_sale_price(product_sale_price);

									        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<Product> productList = productService.getList(product, product_isEnabled_array, orderUtil, pageUtil);

									        object.put("productList", JSONArray.parseArray(JSON.toJSONString(productList)));

									        logger.info("按条件获取产品总数量");

									        Integer productCount = productService.getTotal(product, product_isEnabled_array);

									        object.put("productCount", productCount);

									        logger.info("获取分页信息");

									        pageUtil.setTotal(productCount);

									        object.put("totalPage", pageUtil.getTotalPage());

									        object.put("pageUtil", pageUtil);

									        return object.toJSONString();

									    }

									    //按类型ID查询属性-ajax

									    @ResponseBody

									    @RequestMapping(value = "admin/property/type/{property_category_id}", method = RequestMethod.GET,produces = "application/json;charset=utf-8")

									    public String getPropertyByCategoryId(@PathVariable Integer property_category_id/* 属性所属类型ID*/){

									        //封装查询条件

									        Category category = new Category()

									                .setCategory_id(property_category_id);

									        JSONObject object = new JSONObject();

									        logger.info("按类型获取属性列表，类型ID：{}",property_category_id);

									        List<Property> propertyList = propertyService.getList(new Property().setProperty_category(category),null);

									        object.put("propertyList",JSONArray.parseArray(JSON.toJSONString(propertyList)));

									        return object.toJSONString();

									    }

									    //按ID删除产品图片并返回最新结果-ajax

									    @ResponseBody

									    @RequestMapping(value = "admin/productImage/{productImage_id}",method = RequestMethod.DELETE,produces = "application/json;charset=utf-8")

									    public String deleteProductImageById(@PathVariable Integer productImage_id/* 产品图片ID */){

									        JSONObject object = new JSONObject();

									        logger.info("获取productImage_id为{}的产品图片信息",productImage_id);

									        ProductImage productImage = productImageService.get(productImage_id);

									        logger.info("删除产品图片");

									        Boolean yn = productImageService.deleteList(new Integer[]{productImage_id});

									        if (yn) {

									            logger.info("删除图片成功！");

									            object.put("success", true);

									        } else {

									            logger.warn("删除图片失败！事务回滚");

									            object.put("success", false);

									            throw new RuntimeException();

									        }

									        return object.toJSONString();

									    }

									    //上传产品图片-ajax

									    @ResponseBody

									    @RequestMapping(value = "admin/uploadProductImage", method = RequestMethod.POST, produces = "application/json;charset=utf-8")

									    public String uploadProductImage(@RequestParam MultipartFile file, @RequestParam String imageType, HttpSession session) {

									        String originalFileName = file.getOriginalFilename();

									        logger.info("获取图片原始文件名：{}", originalFileName);

									        String extension = originalFileName.substring(originalFileName.lastIndexOf('.'));

									        String filePath;

									        String fileName = UUID.randomUUID() + extension;

									        if ("single".equals(imageType)) {

									            filePath = session.getServletContext().getRealPath("/") + "res/images/item/productSinglePicture/" + fileName;

									        } else {

									            filePath = session.getServletContext().getRealPath("/") + "res/images/item/productDetailsPicture/" + 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();

									    }

									}