基于javaweb+mysql的springboot网上电商项目(前后端分离+java+vue+springboot+ssm+mysql+maven+redis)

最新推荐文章于 2024-07-15 16:07:19 发布
最新推荐文章于 2024-07-15 16:07:19 发布
阅读量458 收藏 1
点赞数
文章标签： java mysql spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71049690/article/details/132305862
版权

基于javaweb+mysql的springboot网上电商项目(前后端分离+java+vue+springboot+ssm+mysql+maven+redis)

运行环境

Java≥8、MySQL≥5.7、Node.js≥10

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行

前端：WebStorm/VSCode/HBuilderX等均可

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot网上电商项目(前后端分离+java+vue+springboot+ssm+mysql+maven+redis)

一、项目简述

本系统功能包括： 一款基于Springboot+Vue的电商项目，前后端分离项目，前台后台都有，前台商品展示购买，购物车分类，订 单查询等等，后台商品管理，订单管理，信息维护，用户管理等等。

二、项目运行

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

项目技术： Springboot + Maven + Mybatis + Vue + Redis, B/S 模式+ Maven等等，附带支付宝沙箱环境以及支付环节代码。

    private CommonResult findById(Integer supplierId) {
        Supplier supplier = supplierService.selectById(supplierId);
        if(supplier!=null){
            return CommonResult.success("供货商查询成功",supplier);
        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商*/
    @RequestMapping(value = "/supplier/findAll")
    private CommonResult findAll() {
        List<Supplier> suppliers = supplierService.selectAll();
        if(suppliers!=null){
            return CommonResult.success("供货商查询成功",suppliers);
        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商*/
    @RequestMapping(value = "/supplier/findAllUsable")
    private CommonResult findAllUsable() {
        List<Supplier> suppliers = supplierService.selectAllUsable();
        if(suppliers!=null){
            return CommonResult.success("供货商查询成功",suppliers);
        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商名称*/
    @RequestMapping(value = "/supplier/findAllName")
    private CommonResult findAllName() {
        List<String> names = supplierService.selectAllName();
        if(names!=null){
            return CommonResult.success("供货商名称查询成功",names);
        }else{
            return CommonResult.error("供货商名称查询失败");
        }
    }
    /*查询供应商是否存在*/
    @RequestMapping(value = "/supplier/existSupplier")
    private CommonResult existSupplier(Integer supplierId,String supplierName) {

        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商*/
    @RequestMapping(value = "/supplier/findAll")
    private CommonResult findAll() {
        List<Supplier> suppliers = supplierService.selectAll();
        if(suppliers!=null){
            return CommonResult.success("供货商查询成功",suppliers);
        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商*/
    @RequestMapping(value = "/supplier/findAllUsable")
    private CommonResult findAllUsable() {
        List<Supplier> suppliers = supplierService.selectAllUsable();
        if(suppliers!=null){
            return CommonResult.success("供货商查询成功",suppliers);
        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商名称*/
    @RequestMapping(value = "/supplier/findAllName")
    private CommonResult findAllName() {
        List<String> names = supplierService.selectAllName();
        if(names!=null){
            return CommonResult.success("供货商名称查询成功",names);
        }else{
            return CommonResult.error("供货商名称查询失败");
        }
    }
    /*查询供应商是否存在*/
    @RequestMapping(value = "/supplier/existSupplier")
    private CommonResult existSupplier(Integer supplierId,String supplierName) {
        Boolean isExist = supplierService.existsWithSupplierName(supplierId,supplierName);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    /*添加供应商*/
    @RequestMapping(value = "/supplier/addSupplier")
    private CommonResult addSupplier(Supplier supplier) {
        if(supplier!=null){
            if(supplierService.insertData(supplier)){
                return CommonResult.success("添加成功",supplier);
            }else{
                return CommonResult.error("添加失败");
            }

    private CommonResult existSupplier(Integer supplierId,String supplierName) {
        Boolean isExist = supplierService.existsWithSupplierName(supplierId,supplierName);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    /*添加供应商*/
    @RequestMapping(value = "/supplier/addSupplier")
    private CommonResult addSupplier(Supplier supplier) {
        if(supplier!=null){
            if(supplierService.insertData(supplier)){
                return CommonResult.success("添加成功",supplier);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("供应商数据不存在");
    }
    /*修改供应商*/
    @RequestMapping(value = "/supplier/updateSupplier")
    private CommonResult updateSupplier(Supplier supplier) {
        if(supplier!=null){
            if(supplierService.updateById(supplier)){
                return CommonResult.success("更新成功",supplier);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("供应商数据不存在");
    }
    /*删除供应商*/
    @RequestMapping(value = "/supplier/deleteSupplier")
    private CommonResult deleteSupplier(Integer supplierId) {
        if(supplierId!=null){
            if(supplierService.deleteById(supplierId)){
                return CommonResult.success("删除成功",supplierId);
            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("供应商数据不存在");
    }

    @RequestMapping(value = "/returnGoods/dealRefund")
    private CommonResult dealRefund(Integer returnId,String operatorNumber,String operatorName) {
        if(returnId!=null){
            ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
            returnGoods.setReturnState("退款完成");
            returnGoods.setDealTime(new Date());
            returnGoods.setOperatorNumber(operatorNumber);
            returnGoods.setOperatorName(operatorName);
            String orderNo = returnGoods.getOrderNo();
            Integer orderId = orderService.selectIdByKey(orderNo);
            Order order = new Order();
            order.setOrderId(orderId);
            order.setReturnState(true);
            order.setOrderState("已退款");
            Logistics logistics = logisticsService.selectOrderNo(orderNo);
            if(logistics!=null){
                logisticsService.deleteById(logistics.getLogisticId());
            }
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退款数据不存在");
    }

    /*拒绝买家退款申请*/
    @RequestMapping(value = "/returnGoods/rejectRefund")
    private CommonResult rejectRefund(Integer returnId,String operatorNumber,String operatorName) {
        if(returnId!=null){
            ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
            returnGoods.setReturnState("拒绝退款");
            returnGoods.setDealTime(new Date());
            returnGoods.setOperatorNumber(operatorNumber);
            returnGoods.setOperatorName(operatorName);
            String orderNo = returnGoods.getOrderNo();
            Integer orderId = orderService.selectIdByKey(orderNo);
            Order order = new Order();

        }
    }
    @RequestMapping(value = "/product/findAllByType")
    private CommonResult findAllByType() {
        List<Map<String, Object>> maps = productService.selectAllByType();
        if(maps!=null){
            return CommonResult.success("商品分类信息查询成功",maps);
        }else{
            return CommonResult.error("商品分类信息查询失败");
        }
    }

    @RequestMapping(value = "/product/add")
    private CommonResult add(Product product) {
        System.out.println(product);
        if(productService.insertData(product)){
            return CommonResult.success("添加商品成功",product);
        }else{
            return CommonResult.error("添加商品失败");
        }
    }

    @RequestMapping(value = "/product/update")
    private CommonResult update(Product product) {
        if(product.getIsNew()!=null && product.getIsNew()){
            product.setSaleTime(new Date());
        }
        if(productService.updateById(product)){
            return CommonResult.success("修改商品成功",product);
        }else{
            return CommonResult.error("修改商品失败");
        }
    }

    @RequestMapping(value = "/product/delete")
    private CommonResult delete(Integer productId) {
        if(productService.deleteById(productId)){
            return CommonResult.success("商品删除成功","productId：" + productId);
        }else{
            return CommonResult.error("商品删除失败");
        }
    }

    /*商品类别*/
    @RequestMapping(value = "/productType/add")
    private CommonResult addType(ProductType productType) {
        if(productTypeService.insertData(productType)){
            return CommonResult.success("商品分类添加成功",productType);
        }else{
            return CommonResult.error("商品分类添加失败");
        }
    }


 */

@RestController
@CrossOrigin
public class UserController {
    final RoleService roleService;
    final UserService userService;
    final UserRoleService userRoleService;
    final VipService vipService;
    public UserController(UserService userService, RoleService roleService,VipService vipService, UserRoleService userRoleService) {
        this.userService = userService;
        this.roleService = roleService;
        this.userRoleService = userRoleService;
        this.vipService = vipService;
    }

    /*根据id查询用户*/
    @RequestMapping(value = "/user/findById")
    private CommonResult findById(Integer id) {
        User user = userService.selectById(id);
        if(user!=null){
            return CommonResult.success("查询成功",user);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*根据帐号查询用户*/
    @RequestMapping(value = "/user/findByKey")
    private CommonResult findByKey(String key) {
        User user = userService.selectByKey(key);
        if(user!=null){
            return CommonResult.success("查询成功",user);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询所有用户*/
    @RequestMapping(value = "/user/findAll")
    private CommonResult findAll() {
        List<User> users = userService.selectAll();

            return CommonResult.success("退货订单数量查询成功",count);
        }else{
            return CommonResult.error("退货订单数量查询失败");
        }
    }

    @RequestMapping(value = "/returnGoods/addReturn")
    private CommonResult addReturn(ReturnGoods returnGoods) {
        if(returnGoods!=null){
            Integer orderId = orderService.selectIdByKey(returnGoods.getOrderNo());
            System.out.println(returnGoods);
            System.out.println(orderId);
            Order order = new Order();
            order.setOrderId(orderId);
            order.setOrderState("待处理");
            if (orderService.updateById(order)){
                if(returnGoodsService.insertData(returnGoods)){
                    return CommonResult.success("添加成功",returnGoods);
                }else{
                    return CommonResult.error("添加失败");
                }
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    @RequestMapping(value = "/returnGoods/updateReturn")
    private CommonResult updateReturn(ReturnGoods returnGoods) {
        if(returnGoods!=null){
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }


            data.put("year", Calendar.getInstance().get(Calendar.YEAR));
            mailService.sendTemplateMail(sendTo, "权限管理", "role", data);
            return CommonResult.success("授权信息发送成功");
        } catch (Exception e) {
            return CommonResult.error("授权信息发送失败");
        }
    }

    @RequestMapping(value = "/allow/sendHtmlResetPwd")
    public CommonResult sendResetPwd(String sendTo, String pwd) {
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("password", pwd);
            data.put("year", Calendar.getInstance().get(Calendar.YEAR));
            mailService.sendTemplateMail(sendTo, "重置密码", "resetpwd", data);
            return CommonResult.success("新密码信息发送成功");
        } catch (Exception e) {
            return CommonResult.error("新密码信息发送失败");
        }
    }

    /**
     * 发送一个邮箱附件
     *
     * @param sendTo 收件人
     */
    @RequestMapping(value = "/util/sendFile")
    public String sendmailFile(String sendTo, String content) {
        try {
            String filePath = "F:\\IDEA\\JAVA_Program\\Springboot-Mall\\src\\main\\resources\\static\\1.zip";
            mailService.sendAttachmentsMail(sendTo, "文件操作", content, filePath);
            return "发送成功！";
        } catch (Exception e) {
            e.printStackTrace();
            return "发送邮件时发生异常,稍后请重新发送！";
        }
    }

    /**
     * 验证输入的验证码是否正确
     *
     * @param key  验证的依据
     * @param code 验证码
     */
    @RequestMapping(value = "/allow/checkCode")
    public CommonResult checkCode(String key, String code) {
        String codeK = redisTemplate.opsForValue().get(key);
        if (codeK == null) {
            return CommonResult.error("验证码不存在或已过期，请重新发送！");
        }

            //更新最后登录时间
            user.setLoginTime(new Date());
            userService.updateById(user);
            //存放sessionId, 即 token
            info.put("sessionId", authorization);
            List<Role> roles = roleService.selectAll();
            List<String> rs = new ArrayList<>();    // rs 存放的是role的名称
            List<String> rsInfo = new ArrayList<>();    //rsInfo 存放role的描述
            for (Role role : roles) {
                rs.add(role.getRoleName());
                rsInfo.add(role.getRoleName());
            }
            boolean[] booleans = subject.hasRoles(rs);
            for (int i = booleans.length - 1; i >= 0; i--) {
                if (!booleans[i]) {
                    rs.remove(i);
                    rsInfo.remove(i);
                }
            }
            info.put("role", rs);
            info.put("roleInfo", rsInfo);
            return CommonResult.success("登录成功", info);
        }catch (LockedAccountException e){
            return CommonResult.error("您的帐号存在异常行为，已被封停（请联系工作人员）");
        } catch (IncorrectCredentialsException e) {
            return CommonResult.error("密码错误,请重新输入");
        } catch (AuthenticationException e) {
            return CommonResult.error("该用户不存在");
        }
    }

    /**
     * 退出登录操作
     * @param key       用户登录的帐号
     * @param session  前端存储的session（token）
     */
    @RequestMapping(value = "/logout")
    private CommonResult logout(String key,String session) {
        if(key!=null){
            try{
                User user = userService.selectByKey(key);
                Subject subject = SecurityUtils.getSubject();
                //清除用户缓存
                RealmSecurityManager securityManager = (RealmSecurityManager) SecurityUtils.getSecurityManager();
                UserRealm userRealm = (UserRealm) securityManager.getRealms().iterator().next();
                //清空redis中的缓存信息
                userRealm.clearRedis(user,session);
                userRealm.clearCache(SecurityUtils.getSubject().getPrincipals());

    private CommonResult findById(Integer cartId) {
        ShoppingCart shoppingCart = shoppingCartService.selectById(cartId);
        if(shoppingCart!=null){
            return CommonResult.success("购物车查询成功",shoppingCart);
        }else{
            return CommonResult.error("购物车查询失败");
        }
    }

}

/**
 * @email qiudb.top@aliyun.com
 * @description 用户授权类
 */

@RestController
@CrossOrigin
public class UserRoleController {

    final UserRoleService userRoleService;
    public UserRoleController(UserRoleService userRoleService) {
        this.userRoleService = userRoleService;
    }
    /*根据id查询用户*/
    @RequestMapping(value = "/userRole/findById")
    private CommonResult findById(Integer userId) {
        List<UserRole> userRoles = userRoleService.selectByUserId(userId);
        if(userRoles!=null){

    final UserService userService;
    final UserRoleService userRoleService;
    final VipService vipService;
    public UserController(UserService userService, RoleService roleService,VipService vipService, UserRoleService userRoleService) {
        this.userService = userService;
        this.roleService = roleService;
        this.userRoleService = userRoleService;
        this.vipService = vipService;
    }

    /*根据id查询用户*/
    @RequestMapping(value = "/user/findById")
    private CommonResult findById(Integer id) {
        User user = userService.selectById(id);
        if(user!=null){
            return CommonResult.success("查询成功",user);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*根据帐号查询用户*/
    @RequestMapping(value = "/user/findByKey")
    private CommonResult findByKey(String key) {
        User user = userService.selectByKey(key);
        if(user!=null){
            return CommonResult.success("查询成功",user);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询所有用户*/
    @RequestMapping(value = "/user/findAll")
    private CommonResult findAll() {
        List<User> users = userService.selectAll();
        if(users!=null){
            return CommonResult.success("查询成功",users);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*判断某个用户是否还存在*/
    @RequestMapping(value = "/user/existKey")
    private CommonResult existKey(String key) {
        Boolean isExist = userService.existsWithPrimaryKey(key);

    @RequestMapping(value = "/specs/update")
    private CommonResult updateSpecs(Specs specs) {
        if(specsService.updateById(specs)){
            return CommonResult.success("更新成功",specs);
        }else{
            return CommonResult.error("更新失败");
        }
    }

    @RequestMapping(value = "/specs/delete")
    private CommonResult deleteSpecs(Integer specsId) {
        if(specsService.deleteById(specsId)){
            return CommonResult.success("删除成功",specsId);
        }else{
            return CommonResult.error("删除失败");
        }
    }

    /*商品 与 规格 的关联表*/

    /*查询所有商品规格对应信息*/
    @RequestMapping(value = "/productSpecs/findAll")
    private CommonResult findAll() {
        List<ProductSpecs> productSpecs = productSpecsService.selectAll();
        if(productSpecs!=null){
            return CommonResult.success("查询成功",productSpecs);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/productSpecs/findAllByProId")
    private CommonResult findAllByProId(Integer productId) {
        List<String> specsName = productSpecsService.selectAllByProId(productId);
        if(specsName!=null){
            return CommonResult.success("查询成功",specsName);
        }else{

        Boolean isExist = productService.existsProductBrand(productBrand);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    @RequestMapping(value = "/product/findAll")
    private CommonResult findAll() {
        List<Product> products = productService.selectAll();
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllSale")
    private CommonResult findAllSale() {
        List<Product> products = productService.selectAllSale();
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllLikeName")
    private CommonResult findAllLikeName(String keyWord) {
        List<Product> products = productService.selectAllLikeName(keyWord);
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllLikeType")
    private CommonResult findAllLikeType(String keyWord) {
        List<Product> products = productService.selectAllLikeType(keyWord);
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }

            return CommonResult.error("购物车删除失败");
        }
    }

    @RequestMapping(value = "/shoppingCart/findAll")
    private CommonResult findAllShoppingCart(String accountNumber) {
        List<Map<String, Object>> shoppingInfo = shoppingCartService.selectAll(accountNumber);
        if(shoppingInfo!=null){
            return CommonResult.success("购物车查询成功",shoppingInfo);
        }else{
            return CommonResult.error("购物车查询失败");
        }
    }

    @RequestMapping(value = "/shoppingCart/findById")
    private CommonResult findById(Integer cartId) {
        ShoppingCart shoppingCart = shoppingCartService.selectById(cartId);
        if(shoppingCart!=null){
            return CommonResult.success("购物车查询成功",shoppingCart);
        }else{
            return CommonResult.error("购物车查询失败");
        }
    }

}

/**
 * @email qiudb.top@aliyun.com
 * @description 用户授权类
 */


    @RequestMapping(value = "/productType/findAll")
    private CommonResult findAllType() {
        List<ProductType> productTypes = productTypeService.selectAll();
        if(productTypes!=null){
            return CommonResult.success("商品分类查询成功",productTypes);
        }else{
            return CommonResult.error("商品分类查询失败");
        }
    }

    @RequestMapping(value = "/productType/findAllName")
    private CommonResult findAllTypeName() {
        List<String> names = productTypeService.selectAllName();
        if(names!=null){
            return CommonResult.success("商品分类名称查询成功",names);
        }else{
            return CommonResult.error("商品分类名称查询失败");
        }
    }

    /*商品品牌*/
    @RequestMapping(value = "/productBrand/add")
    private CommonResult addBrand(ProductBrand productBrand) {
        if(productBrandService.insertData(productBrand)){
            return CommonResult.success("商品品牌添加成功",productBrand);
        }else{
            return CommonResult.error("商品品牌添加失败");
        }
    }

    @RequestMapping(value = "/productBrand/update")
    private CommonResult updateBrand(ProductBrand productBrand) {
        if(productBrandService.updateById(productBrand)){
            return CommonResult.success("商品品牌修改成功",productBrand);
        }else{
            return CommonResult.error("商品品牌修改失败");
        }
    }

    @RequestMapping(value = "/productBrand/deleteById")
    private CommonResult deleteBrandById(Integer brandId) {
        if(productBrandService.deleteById(brandId)){
            return CommonResult.success("商品品牌删除成功","brandId: "+brandId);
        }else{
            return CommonResult.error("商品品牌删除失败");
        }
    }

    @RequestMapping(value = "/productBrand/deleteByName")
    private CommonResult deleteBrandByName(String brandName) {
        if(productBrandService.deleteByName(brandName)){
            return CommonResult.success("商品品牌删除成功","brandName: "+brandName);
        }else{
            return CommonResult.error("商品品牌删除失败");

        }else{
            return CommonResult.error("商品id查询失败");
        }
    }
    @RequestMapping(value = "/product/findCount")
    private CommonResult findCount() {
        Integer count = productService.selectCount();
        if(count!=null){
            return CommonResult.success("商品数量查询成功",count);
        }else{
            return CommonResult.error("商品数量查询失败");
        }
    }
    @RequestMapping(value = "/product/existsKey")
    private CommonResult existsKey(String productNo) {
        Boolean isExist = productService.existsWithPrimaryKey(productNo);
        if(isExist!=null){
            return CommonResult.success("商品是否存在查询成功",isExist);
        }else{
            return CommonResult.error("商品是否存在查询失败");
        }
    }
    @RequestMapping(value = "/product/existsType")
    private CommonResult existsType(String productType) {
        Boolean isExist = productService.existsProductType(productType);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    @RequestMapping(value = "/product/existsBrand")
    private CommonResult existsBrand(String productBrand) {
        Boolean isExist = productService.existsProductBrand(productBrand);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    @RequestMapping(value = "/product/findAll")
    private CommonResult findAll() {
        List<Product> products = productService.selectAll();

 * @email qiudb.top@aliyun.com
 * @description 数据分析，商品数量，订单数量等分析业务
 */
@CrossOrigin
@RestController
public class OverViewController {
    final OrderService orderService;
    final ProductService productService;
    final ReturnGoodsService returnGoodsService;
    public OverViewController(OrderService orderService,ProductService productService,ReturnGoodsService returnGoodsService) {
        this.orderService = orderService;
        this.productService = productService;
        this.returnGoodsService = returnGoodsService;
    }

    @RequestMapping(value = "/view/dataInfo")
    private CommonResult dataInfo() {
        Map<String, Object> resultMap = new HashMap<>();
        Map<String, Object> productMap = productService.productOverview();
        Map<String, Object> orderMap = orderService.orderOverview();
        Map<String, Object> returnGoodsMap = returnGoodsService.returnGoodsOverview();
        if(productMap!=null){
            resultMap.putAll(productMap);
        }
        if(orderMap!=null){
            resultMap.putAll(orderMap);
        }
        if(returnGoodsMap!=null){
            resultMap.putAll(returnGoodsMap);
        }
        if(resultMap.size()!=0){
            return CommonResult.success("查询成功",resultMap);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/view/orderChartDATE")
    private CommonResult orderChartDATE(String startTime,String endTime) {

                    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)){
                            orderInfo.add(order.getOrderNo());
                            productInfo.add(order.getProductNo());
                        }
                    }
                }
            }
            if(orderInfo.size()!=0){
                String orderNoInfo = StringUtils.join(orderInfo, ",");
                String productNoInfo = StringUtils.join(productInfo, ",");
                redisTemplate.opsForValue().set(orderNo,orderNoInfo,24, TimeUnit.HOURS);
                return CommonResult.success("创建订单成功",productNoInfo);
            }else{
                return CommonResult.success("创建订单失败");
            }
        }else{
            return CommonResult.error("订单数据不完整");
        }
    }

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

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

    @RequestMapping(value = "/order/receipt")
    private CommonResult updateOrder(Integer orderId) {
        Order order = new Order();
        order.setOrderId(orderId);

请添加图片描述

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

m0_71049690
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot电商项目实战
sdfsdfsdds2的博客
11-06 477
SpringBoot Leetcode198 希尔排序
七个开源的 Spring Boot 前后端分离项目，一定要收藏！
热门推荐
江南一点雨的专栏
09-18 9万+
前后端分离已经在慢慢走进各公司的技术栈，根据松哥了解到的消息，不少公司都已经切换到这个技术栈上面了。即使贵司目前没有切换到这个技术栈上面，松哥也非常建议大家学习一下前后端分离开发，以免在公司干了两三年，SSH 框架用的滚瓜烂熟，出来却发现自己依然没有任何优势！ 其实前后端分离本身并不难，后段提供接口，前端做数据展示，关键是这种思想。很多人做惯了前后端不分的开发，在做前后端分离的时候，很容易带进来一...
推荐几个开箱即用的开源管理系统做项目
最新发布
2401_83384536的博客
07-15 777
SCUI Admin 中后台前端解决方案SCUI 是一个中后台前端解决方案，基于 VUE3和 elementPlus 实现。使用最新的前端技术栈，提供各类实用的组件方便在业务开发时的调用，并且持续性的提供丰富的业务模板帮助你快速搭建企业级中后台前端任务。项目地址：https://gitee.com/lolicode/scui。
springboot 电商项目
m0_59392076的博客
05-15 559
前言 使用工具idea编写接口 使用postman进行调试工作 此项目 运用技术 mys...
Springboot电商项目
weixin_51209821的博客
04-15 406
Springboot电商项目 项目初始化 引入sql文件，新建springboot工程，添加web依赖，修改springboot版本 增加依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation
spring boot电商项目实战
lrjajq的博客
06-18 395
一、项目初始化 创建spring boot-->jin
Java项目:在线商城系统(前后端分离+java+vue+Springboot+ssm+mysql+maven+redis)
03-27
一、项目简述 本系统功能包括： 前台展示+后台管理，包括最基本的用户登录注册，下单， 购物车，购买，结算，...项目技术： Springboot + Maven + Mybatis + Vue + Redis + HTML 等 等组成，B/S模式+ Maven管理等等。
基于javaweb的个人博客系统(前后端分离+java+vue+springboot+ssm+mysql+redis)
m0_70011400的博客
10-28 1674
基于javaweb的个人博客系统(前后端分离+java+vue+springboot+ssm+mysql+redis) 运行环境 Java≥8、MySQL≥5.7、Node.js≥10 开发工具 后端：eclipse/idea/myeclipse/sts等均可配置运行 前端：WebStorm/VSCode/HBuilderX等均可 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
基于javaweb的仿小米商城系统(前后端分离+java+vue+springboot+ssm+mysql+redis)
m0_70011400的博客
10-28 913
基于javaweb的仿小米商城系统(前后端分离+java+vue+springboot+ssm+mysql+redis) 运行环境 Java≥8、MySQL≥5.7、Node.js≥10 开发工具 后端：eclipse/idea/myeclipse/sts等均可配置运行 前端：WebStorm/VSCode/HBuilderX等均可 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
基于javaweb的在线小说阅读系统(前后端分离+java+vue+springboot+ssm+mysql+redis)
m0_74524312的博客
10-25 1269
基于javaweb的在线小说阅读系统(前后端分离+java+vue+springboot+ssm+mysql+redis) 运行环境 Java≥8、MySQL≥5.7、Node.js≥10 开发工具 后端：eclipse/idea/myeclipse/sts等均可配置运行 前端：WebStorm/VSCode/HBuilderX等均可 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
JavaWEB项目，基于SSM+mysql框架构建的在线商城系统.zip
08-12
这是一个基于JavaWeb技术栈，使用SSM（Spring、SpringMVC、MyBatis）和MySQL数据库构建的在线商城系统项目。下面将详细讲解这个系统的关键知识点。 1. **Spring框架**：Spring是Java开发中的核心框架，它提供了一个...
SpringBoot实战微服务电商项目
06-08
SpringBoot实战微服务电商项目完整项目视频，对于学习springboot以及应用，是不错的学习资料
基于Springboot的小型电商项目(个人开发)
08-12
此项目主要为个人店铺设计的网站，支持模糊查询，分页查询， 商品分类明确，顾客没登录只能浏览商品，不能加入购物车和结算 新顾客需要注册，通过邮箱验证实现注册功能，注册成功会向顾客展示个人页面， 后台分为三部分，处理订单后台，补货发货后台，员工管理后台， 不同的角色有不同的账号登录不同的后台 处理订单后台：负责接单和人工客服(人工客服通过邮箱发信息实现) 补货发货后台：负责发货和补货 员工管理后台，负责管理员工的基本信息，个人绩效和工资发放（待开发）
基于SpringBoot的网上商城.zip
11-28
基于SpringBoot的网上商城，压缩包，打开即可运行，简单方便行之有效，可用于毕设参考，课程设计参考
Vue+Springboot电商实战
03-08
基于Vue的完整电商系统，所利用技术Spring boot, Spring MVC, Redis, Mysql, Nginx, Vue vuex iview等相关技术
Spring Boot电商项目
weixin_50216991的博客
04-06 6261
Spring Boot电商项目一.概述1.电商项目整体介绍(1)前台模块具体分析(2)后台模块具体分析(3) 项目演示2 . 项目开发所需工具准备二. 数据库设计于项目初始化1.表设计2. 项目的初始化3.配置log4j2日志组件4. AOP统一处理web请求日志三.用户模块的开发1.用户模块整体介绍2.API统一返回对象3.注册接口的开发4.对密码进行MD5保护5.登录、登出、更新接口的开发四.商品分类管理模块的开发1.分类模块地主要功能2.后台新增分类功能的实现3. 使用@Valid注解进行参数校验4.
Spring Boot电商项目：概述；
小枯林的博客
01-22 2962
说明： （1）强调：该SpringBoot电商项目中，会有大量的以前接触过的内容；但是，当我们遇到的时候，也会重新啰嗦、重复解释；以达到该专栏形成一个比较好的闭环的目的； 目录 一：Spring Boot电商项目：项目特点； 二：SpringBoot电商项目：内容概述； 一：Spring Boot电商项目：项目特点； （1）该项目是前后端彻底分离的； （2）这个项目完全贴合企业级的开发流程，包括：需求分析、设计（技术设计）、编码、测试、上线； （3）包含的模块有：用户管理、商品分类...
Spring Boot 电商项目-1_基本架构
weixin_44562304的博客
05-23 712
非必需，类型处理器，在数据库类型和。指定映射配置文件的扫描路径。包括字段名，避免字段名与。映射接口的扫描基础包路径。中的所有映射接口添加注解。数据库链接地址账号密码。收到请求，记录请求内容。找到插件的本地安装包。指定的级别以上信息（），其他的直接拒绝（表示任意类的任意方法。处理完请求，返回内容。
SpringBoot电商项目实战Day5
sdfsdfsdds2的博客
10-31 146
SpringBoot电商项目实战——用户模块开发
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值