• 基于Springboot+Vue实现前后端分离商城管理系统

    项目编号：BS-SC-030

    一，项目简介

    新新商城，一款基于 Springboot+Vue 的电商项目，前后端分离项目。完整的实现了一个商城系统应有的基本功能，包括但不限于以下主要功能模块：

    前端商城用户

    1. 用户注册登陆
    2. 商品信息分类和品牌浏览
    3. 全文搜索
    4. 添加购物车管理
    5. 在线购买商品：使用支付宝沙箱在线支付
    6. 个人信息管理
    7. 个人订单管理
    8. 在线退换货功能
    9. 退款功能

    后台用户管理功能

    1. 商品分类管理
    2. 商品品牌管理
    3. 商品规格管理
    4. 商品采购管理
    5. 供应商管理
    6. 订单管理
    7. 退货退款管理
    8. 轮播图设置管理
    9. 用户管理
    10. 权限角色管理
    11. 个人信息管理

    项目后台基于Springboot+MybatisPlus开发实现，前端使用VUE+Element开发实现，前后端分离开发，前端通过调用后台接口来进行相应的交互处理。

    亮点技术：短信发送验证码、阿里云OSS云存储商品图片、邮箱自动发邮件验证操作权限，Shiro权限管理，数据加密处理，支付宝沙箱技术应用，Redis数据缓存处理。

    项目功能完整，界面优雅大方，人机交互流畅，是一个难得的毕业设计作品。

    二，环境介绍

    语言环境：Java: jdk1.8

    数据库：Mysql: mysql5.7 Redis:5.0.10

    应用服务器：Tomcat: tomcat8.5.31

    开发工具：IDEA或eclipse

    技术应用：

    后端技术

    技术

    说明

    官网

    SpringBoot

    容器+MVC框架

    https://spring.io/projects/spring-boot

    Shiro

    认证和授权框架

    Apache Shiro Simple. Java. Security.

    MyBatis

    ORM框架

    http://www.mybatis.org/mybatis-3/zh/index.html

    MySQL

    数据库

    https://www.mysql.com/

    Redis

    分布式缓存

    https://redis.io/

    Druid

    数据库连接池

    https://github.com/alibaba/druid

    前端技术

    技术

    说明

    官网

    Vue

    前端框架

    https://vuejs.org/

    Vue-router

    路由框架

    https://router.vuejs.org/

    Vuex

    全局状态管理框架

    https://vuex.vuejs.org/

    Element

    前端UI框架

    https://element.eleme.io

    Axios

    前端HTTP框架

    https://github.com/axios/axios

    vue-clipboard2

    将内容复制到剪贴板

    https://github.com/Inndy/vue-clipboard2

    vuex-persistedstate

    vuex持久化

    https://www.npmjs.com/package/vuex-persistedstate

    nprogress

    进度条控件

    https://github.com/rstacruz/nprogress

    开发环境

    工具

    版本号

    下载

    JDK

    1.8

    https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

    Mysql

    5.7

    https://www.mysql.com/

    Redis

    5.0.10

    https://redis.io/download

    第三方技术

    工具

    官网

    支付宝沙箱技术

    沙箱环境 ｜ 开放平台

    OSS 存储

    阿里云-为了无法计算的价值

    阿里云短信服务

    阿里云-为了无法计算的价值

    QQ邮箱服务

    登录QQ邮箱

    三，系统展示

    下面展示一下项目的主要核心功能：

    前端用户操作

    用户注册：会对邮箱发验证码验证，要求必须真实有效邮箱

    用户登陆

    首页

    商品购买

    购物车

    结算付款

    我的订单：可以申请退款、收货后可以申请退货等操作

    后台管理用户功能

    后台首页

    商品管理：可以实现商品添加、编辑、删除、下架、查询等，另可以对商品分类、品牌、规则、采购信息进行管理，以及对供应商进行管理，不再一一展示。菜单上的功能都是齐全的。

    订单管理：可以进行发货、退货、退款等相关操作

    营销管理

    主要对前端展示的广告轮播图进行管理

    用户和权限管理：可以对管理员、顾客、角色进行管理操作

    四，核心代码展示

    package com.qiu.controller;

import com.qiu.entity.Banner;
import com.qiu.service.BannerService;
import com.qiu.util.general.CommonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @author ZNZ
 * @email 469603589@qq.com
 * @date 2022/12/31 16:23
 * @description 商品类别
 */
@CrossOrigin
@RestController
public class BannerController {
    @Autowired
    private BannerService bannerService;

    @RequestMapping(value = "/banner/add")
    public CommonResult addBanner(Banner banner) {
        if (bannerService.insertData(banner)) {
            return CommonResult.success("商品轮播图添加成功", banner);
        }
        return CommonResult.error("商品轮播图添加失败");
    }

    @RequestMapping(value = "/banner/update")
    public CommonResult updateType(Banner banner) {
        if (bannerService.updateById(banner)) {
            return CommonResult.success("商品轮播图修改成功", banner);
        }
        return CommonResult.error("商品轮播图修改失败");
    }

    @RequestMapping(value = "/banner/deleteById")
    public CommonResult deleteTypeById(Integer bannerId) {
        if (bannerService.deleteById(bannerId)) {
            return CommonResult.success("商品轮播图删除成功", "bannerId: " + bannerId);
        }
        return CommonResult.error("商品轮播图删除失败");
    }


    @RequestMapping(value = "/banner/findAll")
    public CommonResult findAllType() {
        List banners = bannerService.selectAll();
        if (banners != null) {
            return CommonResult.success("商品轮播图查询成功", banners);
        }
        return CommonResult.error("商品轮播图查询失败");
    }

    @RequestMapping(value = "/banner/findById")
    public CommonResult findById(Integer bannerId) {
        Banner banner = bannerService.selectById(bannerId);
        if (banner != null) {
            return CommonResult.success("商品轮播图查询成功", banner);
        }
        return CommonResult.error("商品轮播图查询失败");
    }
}


package com.qiu.controller;

import cn.dev33.satoken.secure.SaSecureUtil;
import cn.dev33.satoken.stp.StpUtil;
import com.qiu.constant.UserStatusEnum;
import com.qiu.entity.Role;
import com.qiu.entity.User;
import com.qiu.service.RoleService;
import com.qiu.service.UserService;
import com.qiu.util.general.CommonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @author ZNZ
 * @email 469603589@qq.com
 * @date 2022/12/6 17:10
 * @description 登录、退出、修改个人信息等业务操作
 */
@Slf4j
@CrossOrigin
@RestController
public class OperateController {
    private static final String EMAIL_FLAG = "@";

    @Autowired
    private RoleService roleService;

    @Autowired
    private UserService userService;

    /**
     * 登录操作
     *
     * @param username 用户登录的账号
     * @param password 用户登录的密码
     */
    @RequestMapping(value = "/login", produces = {"application/json;charset=UTF-8"})
    public CommonResult doLogin(String username, String password) {
        User user;
        if (username.contains(EMAIL_FLAG)) {
            //包含@符号，代表用户通过邮箱账号登录
            user = userService.selectByKey(username);
        } else {
            //不包含@符号，代表用户通过手机号登录
            user = userService.selectByPhone(username);
        }
        if (user == null) {
            return CommonResult.error("账号不存在");
        }
        String encodePassword = SaSecureUtil.md5BySalt(password, user.getAccountNumber());
        if (!encodePassword.equals(user.getPassword())) {
            return CommonResult.error("用户名或密码错误");
        }
        // 账号被锁定
        if (!user.getUserState()) {
            StpUtil.disable(user.getUserId(), -1);
        }
        StpUtil.login(user.getUserId());
        //更新最后登录时间
        user.setLoginTime(new Date());
        userService.updateById(user);
        //存放用户信息
        Map info = new HashMap<>(4);
        info.put("user", user);
        //存放sessionId, 即 token
        info.put("sessionId", StpUtil.getTokenInfo().getTokenValue());
        List roles = userService.getRoleList(user.getUserId());
        Set roseNames = roles.stream().map(Role::getRoleName).collect(Collectors.toSet());
        Set roseDescribes = roles.stream().map(Role::getRoleDescribe).collect(Collectors.toSet());
        info.put("role", roseNames);
        info.put("roleInfo", roseDescribes);
        return CommonResult.success("登录成功", info);
    }

    /**
     * 注销登录
     */
    @RequestMapping(value = "/logout")
    public CommonResult logout() {
        StpUtil.logout();
        return CommonResult.success("注销成功");
    }

    /**
     * 判断key是否存在   目前用于判断邮箱是否被注册过
     *
     * @param email 邮箱号（账号）
     */
    @RequestMapping(value = "/allow/existUser")
    public CommonResult existUser(String email) {
        Boolean isExist = userService.existsWithPrimaryKey(email);
        if (isExist != null) {
            return CommonResult.success("查询成功", isExist);
        }
        return CommonResult.error("查询失败");
    }

    /**
     * 判断手机号phone是否存在  目前被用于绑定手机号时，确认手机号已被绑定
     *
     * @param telephone 手机号
     */
    @RequestMapping(value = "/allow/existPhone")
    public CommonResult existPhone(String telephone) {
        Boolean isExist = userService.existsWithPrimaryPhone(telephone);
        if (isExist != null) {
            return CommonResult.success("手机号查询成功", isExist);
        }
        return CommonResult.error("手机号查询失败");
    }

    /**
     * 重置密码、找回密码
     *
     * @param account  账号
     * @param password 密码
     */
    @RequestMapping(value = "/allow/resetpwd")
    public CommonResult resetPwd(String account, String password) {
        if (account != null && password != null) {
            String encodePassword = SaSecureUtil.md5BySalt(password, account);
            Integer id = userService.selectIdByKey(account);
            User user = new User();
            user.setUserId(id);
            user.setPassword(encodePassword);
            if (userService.updateById(user)) {
                return CommonResult.success("重置密码成功", user);
            }
            return CommonResult.error("重置密码失败");
        }
        return CommonResult.error("用户数据不存在");
    }


    /**
     * 注册新用户
     *
     * @param user 用户信息
     */
    @RequestMapping(value = "/allow/add")
    public CommonResult add(User user) {
        if (user.getPassword() != null && user.getUserName() != null) {
            String encodePassword = SaSecureUtil.md5BySalt(user.getPassword(), user.getAccountNumber());
            user.setPassword(encodePassword);
            user.setUserState(true);
            user.setStatus(UserStatusEnum.CUSTOMER);
            if (userService.insertData(user)) {
                log.info("用户添加成功，用户信息：{}", user);
                return CommonResult.success("注册成功", user);
            } else {
                return CommonResult.error("注册失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    /**
     * 更新用户信息
     *
     * @param user 用户信息
     */
    @RequestMapping(value = "/allow/update")
    public CommonResult update(User user) {
        if (user.getUserState() != null && user.getUserState()) {
            StpUtil.untieDisable(user.getUserId());
        }
        if (userService.updateById(user)) {
            return CommonResult.success("信息保存成功", user);
        }
        return CommonResult.error("信息保存失败");
    }
}


package com.qiu.controller;

import com.alibaba.fastjson.JSON;
import com.qiu.entity.Logistics;
import com.qiu.entity.Order;
import com.qiu.entity.Product;
import com.qiu.service.LogisticsService;
import com.qiu.service.OrderService;
import com.qiu.service.ProductService;
import com.qiu.util.general.CommonResult;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author ZNZ
 * @email 469603589@qq.com
 * @date 2022/12/28 18:11
 * @description 订单相关业务
 */

@RestController
@CrossOrigin
public class OrderController {
    private static final String VIP = "Vip";
    private static final String COLLECT_GOODS_STATE = "已收货";

    @Autowired
    private OrderService orderService;

    @Autowired
    private ProductService productService;

    @Autowired
    private LogisticsService logisticsService;

    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping(value = "/order/findById")
    public CommonResult findOrderById(Integer orderId) {
        Order order = orderService.selectById(orderId);
        if (orderId != null) {
            return CommonResult.success("订单信息查询成功", order);
        }
        return CommonResult.error("订单信息查询失败");
    }

    @RequestMapping(value = "/order/findOrderInfo")
    public CommonResult findOrderInfo(String userAccount) {
        List> orderMap = orderService.selectAllOrder(userAccount);
        if (orderMap != null) {
            return CommonResult.success("订单信息查询成功", orderMap);
        }
        return CommonResult.error("订单信息查询失败");
    }

    @RequestMapping(value = "/order/findAll")
    public CommonResult findAllOrder() {
        List orders = orderService.selectAll();
        if (orders != null) {
            return CommonResult.success("订单信息查询成功", orders);
        }
        return CommonResult.error("订单信息查询失败");
    }

    @RequestMapping(value = "/order/findCount")
    public CommonResult findCount() {
        Integer count = orderService.selectCount();
        if (count != null) {
            return CommonResult.success("订单数量查询成功", count);
        }
        return CommonResult.error("订单数量查询失败");
    }


    @RequestMapping(value = "/order/add")
    public CommonResult addOrder(Order order) {
        if (order != null) {
            if (order.getProductNo().contains(VIP)) {
                return handleMemberOrders(order);
            }
            return handleMerchandiseOrders(order);
        } else {
            return CommonResult.error("订单数据不完整");
        }
    }

    @RequestMapping(value = "/order/cartOrder")
    public CommonResult cartOrder(String orderNo, String ordersInfo, String cartIds) {
        List cartIdList = JSON.parseArray(cartIds, String.class);
        List orders = JSON.parseArray(ordersInfo, Order.class);
        if (orders != null) {
            ArrayList orderInfo = new ArrayList<>();
            ArrayList productInfo = new ArrayList<>();
            for (Order order : orders) {
                Product product = productService.selectByKey(order.getProductNo());
                Integer productStock = product.getProductStock();
                Integer payAmount = order.getPayAmount();
                if (productStock >= payAmount) {
                    Product newProduct = new Product();
                    newProduct.setProductId(product.getProductId());
                    int newStock = productStock - payAmount;
                    newProduct.setProductStock(newStock);
                    newProduct.setIsStockOut(newStock < product.getLowestStock());
                    // 如果库存小于等于0，自动下架
                    newProduct.setIsSale(newStock > 0);
                    if (productService.updateById(newProduct) && orderService.insertData(order)) {
                        orderInfo.add(order.getOrderNo());
                        productInfo.add(order.getProductNo());
                    }
                }
            }
            if (!orderInfo.isEmpty()) {
                String cartIdsInfo = StringUtils.join(cartIdList.toArray(), ",");
                String orderNoInfo = StringUtils.join(orderInfo, ",");
                String productNoInfo = StringUtils.join(productInfo, ",");
                redisTemplate.opsForValue().set(orderNo, orderNoInfo, 24, TimeUnit.HOURS);
                redisTemplate.opsForValue().set("cartId" + orderNo, cartIdsInfo, 24, TimeUnit.HOURS);
                return CommonResult.success("创建订单成功", productNoInfo);
            }
            return CommonResult.error("创建订单失败，请查看商品库存是否满足购买数量");
        } else {
            return CommonResult.error("订单数据不完整");
        }
    }

    @RequestMapping(value = "/order/update")
    public CommonResult updateOrder(Order order) {
        if (orderService.updateById(order)) {
            return CommonResult.success("修改订单成功", order);
        }
        return CommonResult.error("修改订单失败");
    }

    @RequestMapping(value = "/order/delete")
    public CommonResult deleteOrder(Integer orderId) {
        if (orderService.deleteById(orderId)) {
            return CommonResult.success("删除订单成功", "订单id：" + orderId);
        }
        return CommonResult.error("删除订单失败");
    }

    @RequestMapping(value = "/order/receipt")
    public CommonResult updateOrder(Integer orderId) {
        Order order = new Order();
        order.setOrderId(orderId);
        order.setOrderState(COLLECT_GOODS_STATE);
        if (orderService.updateById(order)) {
            return CommonResult.success("商品收货成功", order);
        }
        return CommonResult.error("商品收货失败");
    }

    @RequestMapping(value = "/orderDetail/orderInfo")
    public CommonResult orderInfo(String orderNo) {
        ArrayList resultList = new ArrayList<>();
        Order order = orderService.selectByKey(orderNo);
        Logistics logistics = logisticsService.selectOrderNo(orderNo);
        if (order != null) {
            resultList.add(order);
        }
        if (logistics != null) {
            resultList.add(logistics);
        }
        return CommonResult.success("订单详情查询成功", resultList);
    }

    /**
     * 处理会员订单
     *
     * @param order 订单信息
     */
    private CommonResult handleMemberOrders(Order order) {
        if (orderService.insertData(order)) {
            return CommonResult.success("创建订单成功", order);
        } else {
            return CommonResult.error("创建订单失败");
        }
    }

    /**
     * 处理商品订单
     *
     * @param order 订单信息
     */
    private CommonResult handleMerchandiseOrders(Order order) {
        Product product = productService.selectByKey(order.getProductNo());
        Integer productStock = product.getProductStock();
        Integer payAmount = order.getPayAmount();
        boolean isOk = productStock >= payAmount;
        if (isOk) {
            Product newProduct = new Product();
            newProduct.setProductId(product.getProductId());
            int newStock = productStock - payAmount;
            newProduct.setProductStock(newStock);
            newProduct.setIsStockOut(newStock < product.getLowestStock());
            // 如果库存小于等于0，自动下架
            newProduct.setIsSale(newStock > 0);
            if (productService.updateById(newProduct)) {
                if (orderService.insertData(order)) {
                    redisTemplate.opsForValue().set(order.getOrderNo(), order.getOrderNo(), 24, TimeUnit.HOURS);
                    return CommonResult.success("创建订单成功", order);
                } else {
                    return CommonResult.error("创建订单失败");
                }
            } else {
                return CommonResult.error("创建订单失败");
            }
        } else {
            return CommonResult.error("商品库存不足");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
    • 371
    • 372
    • 373
    • 374
    • 375
    • 376
    • 377
    • 378
    • 379
    • 380
    • 381
    • 382
    • 383
    • 384
    • 385
    • 386
    • 387
    • 388
    • 389
    • 390
    • 391
    • 392
    • 393
    • 394
    • 395
    • 396
    • 397
    • 398
    • 399
    • 400
    • 401
    • 402
    • 403
    • 404
    • 405
    • 406
    • 407
    • 408
    • 409
    • 410
    • 411
    • 412
    • 413
    • 414
    • 415
    • 416
    • 417
    • 418
    • 419
    • 420
    • 421
    • 422
    • 423
    • 424
    • 425
    • 426
    • 427
    • 428
    • 429
    • 430
    • 431
    • 432
    • 433
    • 434
    • 435
    • 436
    • 437
    • 438
    • 439
    • 440
    • 441
    • 442
    • 443
    • 444
    • 445
    • 446
    • 447
    • 448
    • 449
    • 450
    • 451
    • 452
    • 453
    • 454
    • 455
    • 456
    • 457
    • 458
    • 459
    • 460
    • 461
    • 462
    • 463
    • 464
    • 465
    • 466
    • 467
    • 468
    • 469
    • 470
    • 471
    • 472
    • 473
    • 474
    • 475
    • 476
     

    五，项目总结
     

    项目后台基于Springboot+MybatisPlus开发实现，前端使用VUE+Element开发实现，前后端分离开发，前端通过调用后台接口来进行相应的交互处理。
     

    亮点技术：短信发送验证码、阿里云OSS云存储商品图片、邮箱自动发邮件验证操作权限，Shiro权限管理，数据加密处理，支付宝沙箱技术应用，Redis数据缓存处理。
     

    项目功能完整，界面优雅大方，人机交互流畅，是一个难得的毕业设计作品。
     

    先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦
    
                
                    
                

                
  • 

                    相关阅读:
    
                    
Linux开发工具之自动化构建工具-make/Makefile                            
    
幻兽帕鲁服务器配置怎么选？多少钱？                            
    
2023高教社杯数学建模C题思路模型 - 蔬菜类商品的自动定价与补货决策                            
    
【配置】Gradle下打包springboot项目，分离配置文件、依赖包                            
    
附录5-vscode常用配置                            
    
Git操作复习笔记                            
    
面试题 17.08. 马戏团人塔                            
    
Laravel模型层自动返回数据处理                            
    
深度学习代码入门test2_alexnet                            
    
3-3数据链路层-介质访问控制                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/m0_67403076/article/details/126066257
                
    •