基于springboot vue前后端分离的蛋糕甜品销售商城平台

随着现在互联网的发展，电商时代，据统计目前全世界的人口量不断的在增加已经达到了78亿口以上，整个世界会上网的人就已经达到46亿以上，在互联网还没进入我们生活之前，没人敢想我在家就能知道外面的事情，在家就能买衣服，等从互联网进入我们的生活改变了我们很多东西节省很人力，时间，金钱，随着Internet的发展很多蛋糕店都拥有了自己的官网，用网络去宣传销售，这样可以达到人们随时随地通过网络就可以了解自己的产品提高产品的知名度。

该系统是一个根据Web的蛋糕市场销售系统，关键完成了一个灵便、可扩展性、界面友好的蛋糕市场销售管理系统。系统带来了强悍的数据库管理、精确高效率的数据分析、迅速灵活多变的数据统计、客户管理等服务。前端采用 VUE等技术来设计一个界面简洁、易用性高和用户 友好性好的人机交互界面； 后端采用SpringbBoot Mybatis等技术来建设一个易管理、易操作、安全性高、灵活，扩展和数据的高效、动态、交互访问的管理平台；总体实现一个可视化、科学化和简约化的蛋糕销售管理系统。

关键字: 蛋糕销售；前后端分离;SpringBoot Vue;Mysql

【719】基于springboot vue前后端分离的蛋糕甜品销售商城平台源码和论文含代码讲解视频

ABSTRACT

With the development of the Internet and the era of e-commerce, according to statistics, the population of the world is increasing constantly, and has reached more than 7.8 billion. The number of people who can access the Internet in the world has reached more than 4.6 billion. Before the Internet entered our lives, no one dared to think that I can know things outside at home and buy clothes at home. When the Internet enters our lives, many things have changed, saving manpower and time, Money. With the development of the Internet, many furniture companies have their own official websites. They use the Internet to promote sales, so that people can know their products anytime and anywhere through the Internet and improve the popularity of their products.

This system is a home market sales system based on the Web, which has completed a flexible, scalable, user-friendly home market sales management system. The system brings powerful database management, accurate and efficient data analysis, fast and flexible data statistics, customer management and other services. The front-end uses VUE and other technologies to design a human-computer interaction interface with simple interface, high usability and good user friendliness; The back-end uses SpringbBoot Mybatis and other technologies to build a management platform that is easy to manage, easy to operate, high security, flexible, efficient, dynamic and interactive access to expansion and data; The overall realization of a visual, scientific and simple home sales management system.

Keyword: home sales; Front and rear end separation; SpringBoot Vue; Mysql

1.1  课题背景

互联网的兴起从本质上改变了整个社会的蛋糕交易方式，国内各大企业从上个世纪90年代互联网兴起之时，就产生了通过网络进行销售经营蛋糕的想法。但是由于在互联网上企业的信誉难以认证、网络的法规政策不健全、物流不发达等一系列的原因，限制了网上交易发展的步伐。进入21世纪以后，随着整个社会的发展、进步，制约网上交易的各个瓶颈问题逐一被击破，各企业也纷纷的加入到电子商务的洪潮之中。中国互联网协会网络营销工作委员会调查显示，随着国内产业环境和消费市场的成熟，网络购物尤其是以蛋糕为代表的网购将在今年实现更大发展。根据会员企业艾瑞咨询集团的预测，2008年我国网络购物交易将同比增长125.1％，交易总量将达1263亿，形成了中国网络购物的快速增长浪潮。其中，蛋糕消费人群成为推动此浪潮的一大主力。究其原因，除了该人群对网络购物等新兴的购物模式接受程度较高之外，相比其他细分行业和产品，蛋糕网络购物有着更加完备的产业链条和发展后劲，为其高速增长提供了保障。网络购物这一消费方式给人们生活带来的变化，除了购物场所的改变以外，更重要的是大大改变了传统的消费行为习惯，无论是否在网上购物，上网查看产品的相关信息，已经成为购物决策环节的重要组成部分，这一环节对购物行为的实际发生起到了至关重要的指导作用。

1.2  课题目的及意义

蛋糕商城顾名思义是一个可以购买到各种蛋糕的商场，但它和一般的蛋糕点相比又有着其特点：

1.较大规模的商店，如：单一规模的商场，档次划分的商场，风格划分类商场，全档次类商场。

2.商业界、经济界，如“商场如战场”。

3.聚集在一个或相连的几个建筑物内的各种购买蛋糕商店组成的市场。

4.面积较大、蛋糕计较齐全的综合商场。

5.提供各种经营模式，经营种类较多，能够聚集多种货物的大型销售店面。

但是随着社会的快速发展，人们的生活节奏也随着加快，人们更加忙于自己 的工作，以至于很难抽空亲自去往家私商城选购心仪的蛋糕。随着互联网的发展和普遍的应用，人们可以在网上买到自己想要东西，所以就发展出了网上商城等类型的大大小小的网店，自然也就有家私商城。就如淘宝网一样，家私商城网可以让客户在一天忙碌的工作后回到家，点点鼠标轻松的挑选适合自己的蛋糕而不用拖着疲劳的身体亲自前往商场。

客户也不用一家一家的奔走来挑选，只要轻轻点击鼠标就能做到货比三家，让你更好更快的做决定，省时有省力。从营业者的角度来讲，筹办一个网上商场的投入很小，不用去办营业执照，不用组店面，不用囤积货物；网上商场的“租金”要低的多，也不会因为营业面

积的扩张而增加，因为你根本不需要是实体店面，哪怕你只是街边的一个小店，在网上你也可以建设一个百货大楼。投资者也不用为延长营业时间而增加额外的费用。总的来说网上商城基本不需要占压资金。同时也不会占压人力资源，营业者可以 24 小时营业，也不会因为天气等客观因素导致暂停休息。更不会受到地理位置的影响，不管顾客在国内还是远在国外都可以通过互联网方便的进行购买

1.3  课题研究内容

本文利用SpringBoot与VUE技术，基于B/S模式设计实现了蛋糕销售网上商城平台，具体工作内容如下：

1. 分析阶段，采用面向对象的设计方法进行分析设计，从可行性分析入手， 再从用户的功能需求、非功能需求、系统性能需求与安全需求等几方面进行需求分析，挖掘出用户的真正需求。蛋糕销售管理工作需求不仅涉及到蛋糕销售部门，还 需要挖掘普通用户的实际需求。
2. 设计阶段，蛋糕销售网上商城设计工作分为系统功能设计、系统数据库设计 两方面。在用户需求分析的基础上，完成用户用例分析，设计系统开发所必须 的各种模型，包括系统开发环境的设计、网络结构设计等内容。在功能上设计网上商城的功能模块，完成了功能模块流程图的设计。在数据库的设计过程中，设计网上商城的实体关系图，设计出相应的数据库表逻辑结构。
3. 实现阶段，系统实现分为程序代码实现和系统界面实现两部分。在编程 过程中，使用IDE开发工具，根据系统设计阶段设计的功能，进行相应功能的 实现。在系统界面实现过程中，运用IDE开发工具提供的标准化页面组件，设 计出系统功能界面。最后将信息系统分别部署到Web服务器和数据库服务器上。
4. 测试阶段，针对各个功能模块编写测试用例，采用黑盒测试的方法，完 成对系统软件测试工作。

package com.example.controller;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.auth0.jwt.JWT;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.common.Result;
import com.example.dto.PreOrderQo;
import com.example.entity.*;
import com.example.exception.CustomException;
import com.example.service.*;
import org.json.JSONException;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/order")
public class OrderController {
    @Resource
    private OrderService orderService;
    @Resource
    private HttpServletRequest request;
    @Resource
    private UserService userService;
    @Resource
    private CartService cartService;
    @Resource
    private OrderGoodsService orderGoodsService;
    @Resource
    private GoodsService goodsService;

    public User getUser() {
        String token = request.getHeader("token");
        String username = JWT.decode(token).getAudience().get(0);
        return userService.getOne(Wrappers.<User>lambdaQuery().eq(User::getUsername, username));
    }

    @Transactional
    @PostMapping
    public Result<?> save(@RequestBody Order order) {
        order.setUserId(getUser().getId());
        order.setOrderNo(DateUtil.format(new Date(), "yyyyMMddHHmmss") + RandomUtil.randomNumbers(6));
        order.setCreateTime(DateUtil.now());

        String cartsStr = order.getCarts();
        List<Cart> carts = JSONUtil.toBean(cartsStr, new TypeReference<List<Cart>>() {
        }, true);
        orderService.save(order);

        for (Cart cart : carts) {
            Integer count = cart.getCount();
            Long goodsId = cart.getGoodsId();

            // 扣库存
            Goods goods = goodsService.getById(goodsId);
            if(goods.getStore() - cart.getCount() < 0) {
                throw new CustomException("-1", "库存不足");
            }
            goods.setStore(goods.getStore() - cart.getCount());
            goods.setSales(goods.getSales() + cart.getCount());
            goodsService.updateById(goods);

            OrderGoods orderGoods = new OrderGoods();
            orderGoods.setOrderId(order.getId());
            orderGoods.setGoodsId(goodsId);
            orderGoods.setCount(count);
            orderGoodsService.save(orderGoods);
        }

        if (order.getType() == 1) {  // 1表示购物车，0表示直接购买
            // 提交订单时清空个人的购物车商品
            cartService.remove(Wrappers.<Cart>lambdaUpdate().eq(Cart::getUserId, getUser().getId()));
        }

        return Result.success(order);
    }

    @PutMapping
    public Result<?> update(@RequestBody Order order) {
        orderService.updateById(order);
        return Result.success();
    }

    /**
     * 付款
     * @param id
     * @return
     */
    @Transactional
    @PutMapping("/pay/{id}")
    public Result<?> pay(@PathVariable Long id) {
        Order order = orderService.getById(id);
        BigDecimal totalPrice = order.getTotalPrice();

        Long userId = getUser().getId();
        User user = userService.findById(userId);

        if (user.getAccount().compareTo(totalPrice) <= 0) {
            throw new CustomException("-1", "余额不足");
        }

        user.setAccount(user.getAccount().subtract(totalPrice)); // 设置用户余额
        userService.updateById(user);
        order.setState("待发货");
        orderService.updateById(order);
        return Result.success();
    }

    @DeleteMapping("/{id}")
    public Result<?> delete(@PathVariable Long id) {
        orderService.removeById(id);
        return Result.success();
    }

    /**
     * 获取订单的确认信息
     *
     * @return
     */
    @PostMapping("/pre")
    public Result<?> pre(@RequestBody PreOrderQo preOrderQo) throws JSONException {
        String cartsStr = preOrderQo.getCarts();
        // 讲前台传来的json字符串转换成 list对象
        List<Cart> carts = JSONUtil.toBean(cartsStr, new TypeReference<List<Cart>>() {
        }, true);
        Map<String, Object> all = cartService.findAll(carts);
        return Result.success(all);
    }

    @GetMapping("/{id}")
    public Result<?> findById(@PathVariable Long id) {
        return Result.success(orderService.getById(id));
    }

    @GetMapping
    public Result<?> findAll() {
        List<Order> list = orderService.list();
        return Result.success(list);
    }

    @GetMapping("/page")
    public Result<?> findPage(@RequestParam(required = false, defaultValue = "") String name,
                              @RequestParam(required = false, defaultValue = "1") Integer pageNum,
                              @RequestParam(required = false, defaultValue = "10") Integer pageSize) {
        LambdaQueryWrapper<Order> query = Wrappers.<Order>lambdaQuery().orderByDesc(Order::getId);
        if (StrUtil.isNotBlank(name)) {
            query.like(Order::getOrderNo, name);
        }
        IPage<Order> page = orderService.page(new Page<>(pageNum, pageSize), query);
        return Result.success(page);
    }

    /**
     * 前台查询订单列表
     * @param state
     * @param pageNum
     * @param pageSize
     * @return
     */
    @GetMapping("/page/front")
    public Result<?> findPageFront(@RequestParam(required = false, defaultValue = "") String state,
                                   @RequestParam(required = false, defaultValue = "1") Integer pageNum,
                                   @RequestParam(required = false, defaultValue = "10") Integer pageSize) {
        LambdaQueryWrapper<Order> query = Wrappers.<Order>lambdaQuery().orderByDesc(Order::getId);
        query.eq(Order::getUserId, getUser().getId());
        // 根据状态查询
        if (StrUtil.isNotBlank(state)) {
            query.eq(Order::getState, state);
        }
        IPage<Order> page = orderService.page(new Page<>(pageNum, pageSize), query);

        for (Order order : page.getRecords()) {
            Long orderId = order.getId();
            List<Cart> carts = orderGoodsService.findByOrderId(orderId);
            order.setCarts(JSONUtil.toJsonStr(carts));
        }
        return Result.success(page);
    }

}

 

package com.example.controller;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.poi.excel.ExcelUtil;
import cn.hutool.poi.excel.ExcelWriter;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.common.Result;
import com.example.entity.User;
import com.example.exception.CustomException;
import com.example.service.LogService;
import com.example.service.UserService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/user")
public class UserController {

    @Resource
    private UserService userService;

    @Resource
    private LogService logService;
    @Resource
    private HttpServletRequest request;

    public User getUser() {
        String token = request.getHeader("token");
        String username = JWT.decode(token).getAudience().get(0);
        return userService.getOne(Wrappers.<User>lambdaQuery().eq(User::getUsername, username));
    }

    /**
     * 登录
     *
     * @param user
     * @return
     */
    @PostMapping("/login")
    public Result<User> login(@RequestBody User user) {
        User res = userService.login(user);
        // 生成token
        String token = JWT.create().withAudience(res.getUsername()).sign(Algorithm.HMAC256(res.getPassword()));
        res.setToken(token);

        logService.log(user.getUsername(), StrUtil.format("用户 {} 登录系统", user.getUsername()));
        return Result.success(res);
    }

    /**
     * 注册
     *
     * @param user
     * @param request
     * @return
     */
    @PostMapping("/register")
    public Result<User> register(@RequestBody User user, HttpServletRequest request) {
        if (user.getPassword() == null) {
            user.setPassword("123456");
        }
        User dbUser = userService.register(user);
        request.getSession().setAttribute("user", user);

        logService.log(user.getUsername(), StrUtil.format("用户 {} 注册账号成功", user.getUsername()));
        return Result.success(dbUser);
    }


    @PostMapping
    public Result<?> save(@RequestBody User user) {
        if (user.getPassword() == null) {
            user.setPassword("123456");
        }
        logService.log(StrUtil.format("新增用户：{} ", user.getUsername()));
        return Result.success(userService.save(user));
    }

    @PutMapping("/reset")
    public Result<?> reset(@RequestBody User user) {
        if (StrUtil.isBlank(user.getUsername()) || StrUtil.isBlank(user.getPhone())
                || StrUtil.isBlank(user.getPassword())) {
            throw new CustomException("-1", "参数错误");
        }
        logService.log(user.getUsername(), StrUtil.format("{} 用户重置密码", user.getUsername()));
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", user.getUsername());
        queryWrapper.eq("phone", user.getPhone());
        User one = userService.getOne(queryWrapper);
        if (one == null) {
            throw new CustomException("-1", "未找到用户");
        }
        one.setPassword(user.getPassword());
        return Result.success(userService.updateById(one));
    }

    @PutMapping
    public Result<?> update(@RequestBody User user) {
        logService.log(StrUtil.format("更新用户：{} ", user.getUsername()));
        return Result.success(userService.updateById(user));
    }

    /**
     * 更新账户余额
     * @param money
     * @return
     */
    @PutMapping("/account/{money}")
    public Result<?> recharge(@PathVariable BigDecimal money) {
        User user = getUser();
        user.setAccount(user.getAccount().add(money));
        userService.updateById(user);
        logService.log(StrUtil.format("更新用户账户：{} ", user.getUsername()));
        return Result.success();
    }

    @DeleteMapping("/{id}")
    public Result<?> delete(@PathVariable Long id) {
        User user = userService.getById(id);
        logService.log(StrUtil.format("删除用户 {} ", user.getUsername()));

        userService.removeById(id);
        return Result.success();
    }

    @GetMapping("/{id}")
    public Result<User> findById(@PathVariable Long id) {
        return Result.success(userService.findById(id));
    }

    @GetMapping
    public Result<List<User>> findAll() {
        return Result.success(userService.list());
    }

    @GetMapping("/page")
    public Result<IPage<User>> findPage(@RequestParam(required = false, defaultValue = "") String name,
                                        @RequestParam(required = false, defaultValue = "1") Integer pageNum,
                                        @RequestParam(required = false, defaultValue = "10") Integer pageSize) {
        LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery().ne(User::getUsername, "admin").like(User::getUsername, name).orderByDesc(User::getId);
        return Result.success(userService.page(new Page<>(pageNum, pageSize), wrapper));
    }

    @GetMapping("/export")
    public void export(HttpServletResponse response) throws IOException {

        List<Map<String, Object>> list = CollUtil.newArrayList();

        List<User> all = userService.list();
        for (User user : all) {
            Map<String, Object> row1 = new LinkedHashMap<>();
            row1.put("名称", user.getUsername());
            row1.put("手机", user.getPhone());
            row1.put("邮箱", user.getEmail());
            list.add(row1);
        }

        // 2. 写excel
        ExcelWriter writer = ExcelUtil.getWriter(true);
        writer.write(list, true);

        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=utf-8");
        String fileName = URLEncoder.encode("用户信息", "UTF-8");
        response.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xlsx");

        ServletOutputStream out = response.getOutputStream();
        writer.flush(out, true);
        writer.close();
        IoUtil.close(System.out);
    }

}