Java 实战练习之网上电商项目的实现

一、项目简述

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

二、项目运行

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

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

商品相关业务代码：

/**
* @author Qiu
* @description 商品相关业务
*/

@RestController
@CrossOrigin
public class ProductController {
   final ProductTypeService productTypeService;
   final ProductBrandService productBrandService;
   final ProductService productService;
   public ProductController(ProductService productService, ProductTypeService productTypeService,ProductBrandService productBrandService) {
       this.productTypeService = productTypeService;
       this.productBrandService = productBrandService;
       this.productService = productService;
   }

/*商品类别*/
   @RequestMapping(value = "/product/findById")
   private CommonResult findById(Integer productId) {
       Product product = productService.selectById(productId);
       if(product!=null){
           return CommonResult.success("商品查询成功",product);
       }else{
           return CommonResult.error("商品查询失败");
       }
   }
   @RequestMapping(value = "/product/findByKey")
   private CommonResult findByKey(String productNo) {
       Product product = productService.selectByKey(productNo);
       if(product!=null){
           return CommonResult.success("商品查询成功",product);
       }else{
           return CommonResult.error("商品查询失败");
       }
   }
   @RequestMapping(value = "/product/findIdByKey")
   private CommonResult findIdByKey(String productNo) {
       Integer productId = productService.selectIdByKey(productNo);
       if(productId!=null){
           return CommonResult.success("商品id查询成功",productId);
       }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();
       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("全部商品信息查询失败");
       }
   }
   @RequestMapping(value = "/product/findAllLikeBrand")
   private CommonResult findAllLikeBrand(String keyWord) {
       List<Product> products = productService.selectAllLikeBrand(keyWord);
       if(products!=null){
           return CommonResult.success("全部商品信息查询成功",products);
       }else{
           return CommonResult.error("全部商品信息查询失败");
       }
   }
   @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("商品分类添加失败");
       }
   }

@RequestMapping(value = "/productType/update")
   private CommonResult updateType(ProductType productType) {
       if(productTypeService.updateById(productType)){
           return CommonResult.success("商品分类修改成功",productType);
       }else{
           return CommonResult.error("商品分类修改失败");
       }
   }

@RequestMapping(value = "/productType/deleteById")
   private CommonResult deleteTypeById(Integer typeId) {
       if(productTypeService.deleteById(typeId)){
           return CommonResult.success("商品分类删除成功","typeId: "+typeId);
       }else{
           return CommonResult.error("商品分类删除失败");
       }
   }

@RequestMapping(value = "/productType/deleteByName")
   private CommonResult deleteTypeByName(String typeName) {
       if(productTypeService.deleteByName(typeName)){
           return CommonResult.success("商品分类删除成功","typeName: "+typeName);
       }else{
           return CommonResult.error("商品分类删除失败");
       }
   }

@RequestMapping(value = "/productType/existsTypeName")
   private CommonResult existsTypeName(Integer typeId,String typeName) {
       Boolean isExist = productTypeService.existsWithTypeName(typeId,typeName);
       if(isExist!=null){
           return CommonResult.success("查询成功",isExist);
       }else{
           return CommonResult.error("查询失败");
       }
   }

@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("商品品牌删除失败");
       }
   }

@RequestMapping(value = "/productBrand/findAll")
   private CommonResult findAllBrand() {
       List<ProductBrand> productBrands = productBrandService.selectAll();
       if(productBrands!=null){
           return CommonResult.success("商品品牌查询成功",productBrands);
       }else{
           return CommonResult.error("商品品牌查询失败");
       }
   }

@RequestMapping(value = "/productBrand/existsBrandName")
   private CommonResult existsBrandName(Integer brandId,String brandName) {
       Boolean isExist = productBrandService.existsWithBrandName(brandId,brandName);
       if(isExist!=null){
           return CommonResult.success("查询成功",isExist);
       }else{
           return CommonResult.error("查询失败");
       }
   }

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

商品规格、商品与商品规格的关联代码：

/**
* @author Qiu
* @description 商品规格、商品与商品规格的关联
*/

@RestController
@CrossOrigin
public class SpecsController {
   final SpecsService specsService;
   final ProductSpecsService productSpecsService;
   public SpecsController(SpecsService specsService,ProductSpecsService productSpecsService) {
       this.specsService = specsService;
       this.productSpecsService = productSpecsService;
   }
   /*根据id查询规格*/
   @RequestMapping(value = "/specs/findById")
   private CommonResult findById(Integer specsId) {
       Specs specs = specsService.selectById(specsId);
       if(specs!=null){
           return CommonResult.success("查询成功",specs);
       }else{
           return CommonResult.error("查询失败");
       }
   }

/*查询所有规格信息*/
   @RequestMapping(value = "/specs/findAll")
   private CommonResult findAllSpecs() {
       List<Specs> specs = specsService.selectAll();
       if(specs!=null){
           return CommonResult.success("查询成功",specs);
       }else{
           return CommonResult.error("查询失败");
       }
   }

@RequestMapping(value = "/specs/existsSpecsName")
   private CommonResult existsSpecsName(Integer specsId, String specsName, String productType) {
       Boolean isExist = specsService.existsWithSpecsName(specsId,specsName,productType);
       if(isExist!=null){
           return CommonResult.success("查询成功",isExist);
       }else{
           return CommonResult.error("查询失败");
       }
   }

@RequestMapping(value = "/specs/findAllByType")
   private CommonResult findAllSpecsByType(String productType) {
       List<Specs> specs = specsService.selectAllByType(productType);
       if(specs!=null){
           return CommonResult.success("查询成功",specs);
       }else{
           return CommonResult.error("查询失败");
       }
   }

@RequestMapping(value = "/specs/add")
   private CommonResult addSpecs(Specs specs) {
       if(specs!=null){
           if(specsService.insertData(specs)){
               return CommonResult.success("添加成功",specs);
           }else{
               return CommonResult.error("添加失败");
           }
       }
       return CommonResult.error("数据不存在");
   }

@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{
           return CommonResult.error("查询失败");
       }
   }

@RequestMapping(value = "/productSpecs/add")
   private CommonResult add(ProductSpecs productSpecs) {
       if(productSpecs!=null){
           if(productSpecsService.insertData(productSpecs)){
               return CommonResult.success("添加成功",productSpecs);
           }else{
               return CommonResult.error("添加失败");
           }
       }
       return CommonResult.error("数据不存在");
   }

@RequestMapping(value = "/productSpecs/addBatch")
   private CommonResult addBatch(Integer productId,Integer[] specsIds) {
       System.out.println(productId);
       System.out.println(Arrays.toString(specsIds));
       if(specsIds!=null){
           ProductSpecs productSpecs;
           List<ProductSpecs> productSpecsList = new ArrayList<>();
           for (Integer specsId : specsIds) {
               productSpecs = new ProductSpecs();
               productSpecs.setProductId(productId);
               productSpecs.setSpecsId(specsId);
               productSpecsList.add(productSpecs);
           }
           for (ProductSpecs specs : productSpecsList) {
               System.out.println(specs);
           }
           if(productSpecsService.insertBatch(productSpecsList)){
               return CommonResult.success("添加成功",productSpecsList);
           }else{
               return CommonResult.error("添加失败");
           }
       }
       return CommonResult.error("数据不存在");
   }

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

@RequestMapping(value = "/productSpecs/delete")
   private CommonResult delete(ProductSpecs productSpecs) {
       if(productSpecsService.deleteById(productSpecs)){
           return CommonResult.success("删除成功",productSpecs);
       }else{
           return CommonResult.error("删除失败");
       }
   }
}

来源：https://blog.csdn.net/m0_59687645/article/details/121203108