计算机毕业设计选题推荐-网上宠物商城-Java项目实战

✨作者主页：IT毕设梦工厂✨
个人简介：曾从事计算机专业培训教学，擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。
☑文末获取源码☑
精彩专栏推荐⬇⬇⬇
Java项目
Python项目
安卓项目
微信小程序项目

一、前言

随着社会经济的发展和人们生活水平的提高，宠物已经成为越来越多家庭的重要成员。然而，人们在日常生活和工作中难免会有需要离家或者无法照顾宠物的时候，这时候就需要宠物寄养服务来解决这个问题。因此，建立网上宠物商城，提供宠物寄养服务、商品信息以及交流平台，具有重要的现实意义和社会价值。

目前，市场上已经存在一些网上宠物商城，但它们往往存在以下问题：
服务信息不齐全：很多平台只提供简单的寄养服务信息，缺乏对服务内容、服务标准的详细介绍和透明度，用户难以判断服务的质量和价值。
商品信息不准确：很多平台上的商品信息不准确，甚至存在虚假宣传的情况，用户难以了解商品的真实情况。
交流平台管理不规范：一些平台的交流区存在大量的广告、不良信息等，缺乏管理和监管，用户体验差。

本课题旨在建立一个透明、规范的网上宠物商城，提供以下服务：
宠物寄养服务信息详细、透明，包括服务内容、服务标准、价格等。
商品信息准确、详细，包括商品详情、价格、销量等。
交流平台规范管理，包括广告管理、不良信息管理等。

本课题的研究成果将为网上宠物商城的发展提供有益的参考和借鉴，具有重要的理论和实践意义：
理论意义：本课题将深入研究网上宠物商城的发展规律和特点，提出一系列创新的理论观点和实践方案，为相关领域的研究提供有益的参考和借鉴。
实践意义：本课题的研究成果将有助于提高网上宠物商城的服务质量和用户体验，增进该行业的发展和壮大。同时，研究成果还可以为其他电子商务领域提供有益的参考和借鉴。

二、开发环境

• 开发语言：Java
• 数据库：MySQL
• 系统架构：B/S
• 后端：SpringBoot
• 前端：Vue

三、系统功能模块

• 角色：用户、管理员
• 功能：
  用户：
  宠物寄养服务信息、商品信息、论坛、公告信息、购物车、在线客服、收货地址管理、宠物寄养订单管理、商品订单管理；
  管理员：
  用户管理、商品管理（信息、收藏、评价、订单）、宠物寄养服务管理、宠物寄养订单管理、寄存日志管理、客服聊天管理、基础数据管理（宠物类型、寄养服务类型、商品类型、公告类型）、论坛管理、公告信息管理。

四、系统界面展示

• 网上宠物商城系统界面展示：
  
  
  
  
  
  
  
  

五、部分代码设计

• SpringBoot项目实战-代码参考：

@WebServlet("/api/admin/goods/*")
public class GoodsServlet extends HttpServlet {

    private GoodsService goodsService = new GoodsServiceImpl();

    private ObjectMapper objectMapper = new ObjectMapper();

    {
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        String op = requestURI.replaceAll("/api/admin/goods/", "");
        if (op.equals("imgUpload")) {
            imgUpload(request, response);
        } else if (op.equals("addGoods")) {
            addGoods(request, response);
        } else if (op.equals("addType")) {
            addType(request, response);
        } else if (op.equals("addSpec")) {
            addSpec(request, response);
        } else if (op.equals("updateGoods")) {
            updateGoods(request, response);
        } else if (op.equals("deleteSpec")) {
            deleteSpec(request, response);
        } else if (op.equals("reply")) {
            reply(request, response);
        }
     }

    /**
     * 增加商品或编辑商品时上传图片到数据库
     * @param request
     * @param response
     * @throws IOException
     */
    private void imgUpload(HttpServletRequest request, HttpServletResponse response) throws IOException {
        Map<String, Object> map = FileUploadUtils.upload(request);
        String fileUrl = (String) map.get("file");
        System.out.println("surprise！！！即将响应图片 > V <");
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(fileUrl)));
    }

    /**
     * 在一类型下增加商品
     * @param request
     * @param response
     * @throws IOException
     */
    private void addGoods(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        AddGoodsBo addGoodsBo;
        try {
            addGoodsBo = objectMapper.readValue(requestBody, AddGoodsBo.class);
        } catch (Exception e) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数类型错误")));
            return;
        }
        if (addGoodsBo.getName() == null || addGoodsBo.getName().equals("")) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("商品名不能为空")));
            return;
        }
        if (addGoodsBo.getImg() == null || addGoodsBo.getImg().equals("")) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("传入图片不能为空")));
            return;
        }
        for (Spec spec : addGoodsBo.getSpecList()) {
            if (spec.getStockNum() <= 0 || spec.getUnitPrice() <= 0) {
                response.getWriter().println(objectMapper.writeValueAsString(Result.error("库存与价格不可为负数")));
                return;
            }
        }
        boolean result = goodsService.addGoods(addGoodsBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("增加商品信息失败")));
        }
    }

    /**
     * 增加类型
     * @param request
     * @param response
     * @throws IOException
     */
    private void addType(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        AddTypeBo addTypeBo = objectMapper.readValue(requestBody, AddTypeBo.class);
        boolean result = goodsService.addType(addTypeBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("增加商品出错")));
        }
    }

    /**
     * 在一商品下增加规格
     * @param request
     * @param response
     * @throws IOException
     */
    private void addSpec(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        AddSpecBo addSpecBo = null;
        try {
            addSpecBo = objectMapper.readValue(requestBody, AddSpecBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数类型不正确")));
            return;
        }
        if (addSpecBo.getStockNum() <= 0 || addSpecBo.getUnitPrice() <= 0) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("库存与价格不可设置负数")));
            return;
        }
        AddSpecVo addSpecVo = goodsService.addSpec(addSpecBo);
        if (addSpecVo == null) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("增加规格未成功,可能存在重复的规格名")));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok(addSpecVo)));
        }
    }

    /**
     * 更新商品信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void updateGoods(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        GoodsUpdateBo goodsUpdateBo = null;
        try {
            goodsUpdateBo = objectMapper.readValue(requestBody, GoodsUpdateBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("传入参数错误")));
            return;
        }
        if (goodsUpdateBo.getName() == null || goodsUpdateBo.getName().equals("")) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("商品名不能为空")));
            return;
        }
        if (goodsUpdateBo.getImg() == null || goodsUpdateBo.getImg().equals("")) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("传入图片不能为空")));
            return;
        }
        for (SpecGetVo specGetVo : goodsUpdateBo.getSpecList()) {
            if (specGetVo.getStockNum() < 0 || specGetVo.getUnitPrice() < 0) {
                response.getWriter().println(objectMapper.writeValueAsString(Result.error("库存与价格不可为负数")));
                return;
            }
        }
        boolean result = goodsService.updateGoods(goodsUpdateBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("商品更新未成功")));
        }
    }

    /**
     * 删除某商品规格
     * @param request
     * @param response
     * @throws IOException
     */
    private void deleteSpec(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        SpecDeleteBo specDeleteBo = null;
        try {
            specDeleteBo = objectMapper.readValue(requestBody, SpecDeleteBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("请求参数不正确")));
            return;
        }
        boolean result = goodsService.deleteSpec(specDeleteBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("删除商品规格不成功")));
        }
    }

    /**
     * 回复商品问答
     * @param request
     * @param response
     * @throws IOException
     */
    private void reply(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        ReplyBo replyBo = null;
        try {
            replyBo = objectMapper.readValue(requestBody, ReplyBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数类型错误")));
        }
        boolean result = goodsService.reply(replyBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("回复留言失败")));
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        String op = requestURI.replaceAll("/api/admin/goods/", "");
        if (op.equals("getType")) {
            getType(request, response);
        } else if (op.startsWith("getGoodsByType")) {
            getGoodsByType(request, response);
        } else if (op.startsWith("deleteGoods")) {
            deleteGoods(request, response);
        } else if (op.startsWith("deleteType")) {
            deleteType(request, response);
        } else if (op.startsWith("getGoodsInfo")) {
            getGoodsInfo(request, response);
        } else if (op.equals("noReplyMsg")) {
            noReplyMsg(request, response);
        } else if (op.equals("repliedMsg")) {
            repliedMsg(request, response);
        }
    }

    /**
     * 获得商品类型信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void getType(HttpServletRequest request, HttpServletResponse response) throws IOException {
        List<Type> typeList = goodsService.getType();
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(typeList)));
    }

    private void getGoodsByType(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String typeId = request.getParameter("typeId");
        List<GoodsGetByTypeVo> goodsList;
        try {
            goodsList = goodsService.getGoodsByType(Integer.parseInt(typeId));
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("请求参数错误")));
            return;
        }
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(goodsList)));
    }

    /**
     * 删除某一商品信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void deleteGoods(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String id = request.getParameter("id");
        boolean result;
        try {
            result = goodsService.deleteGoods(Integer.parseInt(id));
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("传入参数错误")));
            return;
        }
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("删除商品信息错误")));
        }
    }

    /**
     * 删除商品类型
     * @param request
     * @param response
     * @throws IOException
     */
    private void deleteType(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String typeIdStr = request.getParameter("typeId");
        int typeId;
        try {
            typeId = Integer.parseInt(typeIdStr);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString("传入参数错误"));
            return;
        }
        boolean result = goodsService.deleteType(typeId);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("删除类目失败")));
        }
    }

    /**
     * 获得商品信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void getGoodsInfo(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String id = request.getParameter("id");
        GoodsGetInfoVo goodsGetInfoVo = null;
        try {
            goodsGetInfoVo = goodsService.getGoodsInfo(Integer.parseInt(id));
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数转化失败")));
        }
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(goodsGetInfoVo)));
    }

    /**
     * 没有回复的商品问答的信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void noReplyMsg(HttpServletRequest request, HttpServletResponse response) throws IOException {
        List<Reply> replies = goodsService.noReplyMsg();
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(replies)));
    }

    /**
     * 已回复商品问答的信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void repliedMsg(HttpServletRequest request, HttpServletResponse response) throws IOException {
        List<Reply> replies = goodsService.repliedMsg();
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(replies)));
    }
}

@WebServlet("/api/admin/order/*")
public class OrdersServlet extends HttpServlet {

    private ObjectMapper objectMapper = new ObjectMapper();

    private OrdersService ordersService = new OrdersServiceImpl();

    {
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        String op = requestURI.replaceAll("/api/admin/order/", "");
        if (op.equals("ordersByPage")) {
            ordersByPage(request, response);
        } else if (op.equals("changeOrder")) {
            changeOrder(request, response);
        }
    }

    /**
     * 根据页面获取订单信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void ordersByPage(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        OrdersByPageBo ordersByPageBo = null;
        try {
            ordersByPageBo = objectMapper.readValue(requestBody, OrdersByPageBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数类型不正确")));
            return;
        }
        OrdersByPageVo ordersByPageVo = ordersService.orderByPage(ordersByPageBo);
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(ordersByPageVo)));
    }

    /**
     * 改变订单信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void changeOrder(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        ChangeOrderBo changeOrderBo = null;
        try {
            changeOrderBo = objectMapper.readValue(requestBody, ChangeOrderBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数类型错误")));
            return;
        }
        boolean result = ordersService.changeOrder(changeOrderBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("改变订单信息失败")));
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        String op = requestURI.replaceAll("/api/admin/order/", "");
        if (op.startsWith("orders")) {
            orders(request, response);
        } else if (op.startsWith("order")) {
            order(request, response);
        } else if (op.startsWith("deleteOrder")) {
            deleteOrder(request, response);
        }
    }

    /**
     * 根据状态获取订单信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void orders(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String stateStr = request.getParameter("state");
        int state;
        try {
            state = Integer.parseInt(stateStr);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数类型错误")));
            return;
        }
        List<OrdersVo> ordersVos =  ordersService.orders(state);
        String s = objectMapper.writeValueAsString(Result.ok(ordersVos));
        System.out.println(s);
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(ordersVos)));
    }

    /**
     * 根据id获取订单信息
     * @param request
     * @param response
     * @throws IOException
     */
    private void order(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String id = request.getParameter("id");
        OrderVo orderVo = null;
        try {
            orderVo = ordersService.order(Integer.parseInt(id));
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("查询订单失败")));
            return;
        }
        if (orderVo == null) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("订单信息为空")));
            return;
        }
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(orderVo)));
    }

    /**
     * 删除订单
     * @param request
     * @param response
     * @throws IOException
     */
    private void deleteOrder(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String idStr = request.getParameter("id");
        int id;
        try {
            id = Integer.parseInt(idStr);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数类型错误")));
            return;
        }
        boolean result = ordersService.deleteOrder(id);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("删除订单失败")));
        }
    }
}

@WebServlet("/api/mall/order/*")
public class MallOrderServlet extends HttpServlet {

    private OrdersService ordersService = new OrdersServiceImpl();

    private ObjectMapper objectMapper = new ObjectMapper();

    {
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        String op = requestURI.replaceAll("/api/mall/order/", "");
        if (op.equals("addOrder")) {
            addOrder(request, response);
        } else if (op.equals("settleAccounts")) {
            settleAccounts(request, response);
        } else if (op.equals("sendComment")) {
            sendComment(request, response);
        }
    }

    /**
     * 加入购物车
     *
     * @param request
     * @param response
     * @throws IOException
     */
    private void addOrder(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        AddOrderBo addOrderBo = null;
        try {
            if (requestBody.substring(requestBody.indexOf("num") + 4
                    , requestBody.indexOf(",", requestBody.indexOf("num") + 4)).contains(".")) {
                response.getWriter().println(objectMapper.writeValueAsString(Result.error("请下单整数数量商品")));
                return;
            }
            addOrderBo = objectMapper.readValue(requestBody, AddOrderBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数传入错误")));
            return;
        }
        if (addOrderBo.getNum() <= 0) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("商品数量不正确")));
            return;
        }
        boolean result = ordersService.addOrder(addOrderBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("添加订单失败,可能存在购买商品数量超出库存")));
        }
    }

    /**
     * 下单
     *
     * @param request
     * @param response
     * @throws IOException
     */
    private void settleAccounts(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        SettleAccountsBo settleAccountsBo = null;
        try {
            VerifyDoubleBo verifyDoubleBo = objectMapper.readValue(requestBody, VerifyDoubleBo.class);
            for (VerifyCartDoubleBo verifyCartDoubleBo : verifyDoubleBo.getCartList()) {
                if (verifyCartDoubleBo.getGoodsNum().contains(".")) {
                    response.getWriter().println(objectMapper.writeValueAsString(Result.error("请下单整数数量商品")));
                    return;
                }
            }
            settleAccountsBo = objectMapper.readValue(requestBody, SettleAccountsBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数传入错误")));
            return;
        }
        for (CartBo cartBo : settleAccountsBo.getCartList()) {
            if (cartBo.getGoodsNum() <= 0) {
                response.getWriter().println(objectMapper.writeValueAsString(Result.error("下单数量不正确")));
                return;
            }
            String goodsNum = String.valueOf(cartBo.getGoodsNum());
            if (goodsNum.contains(".")) {
                response.getWriter().println(objectMapper.writeValueAsString(Result.error("请下单整数数量商品")));
                return;
            }
        }
        boolean result = ordersService.settleAccounts(settleAccountsBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("下订单失败，可能存在购买数量大于库存")));
        }
    }

    /**
     * 发送评论
     *
     * @param request
     * @param response
     * @throws IOException
     */
    private void sendComment(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String requestBody = HttpUtils.getRequestBody(request);
        SendCommentBo sendCommentBo = null;
        try {
            sendCommentBo = objectMapper.readValue(requestBody, SendCommentBo.class);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数传入错误")));
            return;
        }
        boolean result = ordersService.sendComment(sendCommentBo);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("发送评论发生错误")));
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        String op = requestURI.replaceAll("/api/mall/order/", "");
        if (op.startsWith("getOrderByState")) {
            getOrderByState(request, response);
        } else if (op.startsWith("deleteOrder")) {
            deleteOrder(request, response);
        } else if (op.startsWith("pay")) {
            pay(request, response);
        } else if (op.startsWith("confirmReceive")) {
            confirmReceive(request, response);
        }
    }

    /**
     * 根据状态获取订单信息
     *
     * @param request
     * @param response
     * @throws IOException
     */
    private void getOrderByState(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String stateStr = request.getParameter("state");
        String token = request.getParameter("token");
        int state;
        try {
            state = Integer.parseInt(stateStr);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数传入错误")));
            return;
        }
        List<GetOrderByStateVo> getOrderByStateVos = ordersService.getOrderByState(state, token);
        response.getWriter().println(objectMapper.writeValueAsString(Result.ok(getOrderByStateVos)));
    }

    /**
     * 删除订单
     *
     * @param request
     * @param response
     * @throws IOException
     */
    private void deleteOrder(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String idStr = request.getParameter("id");
        int id;
        try {
            id = Integer.parseInt(idStr);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数传入错误")));
            return;
        }
        boolean result = ordersService.deleteOrder(id);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("删除订单失败")));
        }
    }

    /**
     * 付款
     *
     * @param request
     * @param response
     * @throws IOException
     */
    private void pay(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String idStr = request.getParameter("id");
        int id;
        try {
            id = Integer.parseInt(idStr);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数传入错误")));
            return;
        }
        boolean result = ordersService.pay(id);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("付款失败，可能存在购买商品数量大于库存")));
        }
    }

    /**
     * 确认收货
     *
     * @param request
     * @param response
     * @throws IOException
     */
    private void confirmReceive(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String idStr = request.getParameter("id");
        int id;
        try {
            id = Integer.parseInt(idStr);
        } catch (Exception e) {
            e.printStackTrace();
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("参数传入错误")));
            return;
        }
        boolean result = ordersService.confirmReceive(id);
        if (result) {
            response.getWriter().println(objectMapper.writeValueAsString(Result.ok()));
        } else {
            response.getWriter().println(objectMapper.writeValueAsString(Result.error("确认收货发生错误")));
        }
    }
}

六、论文参考

• 计算机毕业设计选题推荐_网上宠物商城系统-论文参考：
  

七、系统视频

网上宠物商城系统-项目视频：

SpringBoot项目实战：网上宠物商城-选题推荐

结语

SpringBoot项目实战：网上宠物商城-计算机毕业设计选题推荐
大家可以帮忙点赞、收藏、关注、评论啦～
源码获取：私信我

精彩专栏推荐⬇⬇⬇
Java项目
Python项目
安卓项目
微信小程序项目