商品发布

一、介绍
二、概念
三、神器介绍
四、商品发布
五、测试
六、添加商品
七、根据id查询商品详情
八、修改商品
九、商品的审核与上架下架
十、完整代码

一、介绍

SPU：某一款商品的公共属性
SKU：某款商品的不同参数对应的商品信息
新增商品：增加SPU和SKU
修改商品：修改SPU和SKU
商品审核：修改审核状态
上架下架：修改上架下架状态
删除商品：修改删除状态（逻辑删除）、真实删除数据（物理删除）
找回商品：一定是属于逻辑删除的商品

数据表：
tb_template 模板表
tb_spec 规格表
tb_para 参数表
tb_spu 某款商品的公共属性
tb_sku 某款商品中某类商品的信息

二、概念

SPU：Standard Product Unit (标准产品单位) 是商品信息聚合的最小单位，是一组可复用、易检索的标准化信息的集合，该集合描述了一个产品的特性。
通俗点讲，属性值、特性相同的货品就可以成为一个SPU
同款商品的公共属性抽取
例如：华为P30就是一个SPU

Stock Keeping Unit（库存量单位），即库存进出计量单位，可以是件盒、托盘等为单位。是物理上不可分割的最小存货单元，在使用时要根据不同业态，不同管理模式来处理。
某个库存单位的商品独有的属性。
例如：华为P30 红色 128G 就是一个SKU

例如：
在这里插入图片描述
SPU：（公共属性）

CREATE TABLE `tb_spu` (
  `id` bigint(20) NOT NULL COMMENT '主键',
  `sn` varchar(60) DEFAULT NULL COMMENT '货号',
  `name` varchar(100) DEFAULT NULL COMMENT 'SPU名',
  `caption` varchar(100) DEFAULT NULL COMMENT '副标题',
  `brand_id` int(11) DEFAULT NULL COMMENT '品牌ID',
  `category1_id` int(20) DEFAULT NULL COMMENT '一级分类',
  `category2_id` int(10) DEFAULT NULL COMMENT '二级分类',
  `category3_id` int(10) DEFAULT NULL COMMENT '三级分类',
  `template_id` int(20) DEFAULT NULL COMMENT '模板ID',
  `freight_id` int(11) DEFAULT NULL COMMENT '运费模板id',
  `image` varchar(100) DEFAULT NULL COMMENT '图片',
  `images` varchar(1000) DEFAULT NULL COMMENT '图片列表',
  `sale_service` varchar(50) DEFAULT NULL COMMENT '售后服务',
  `introduction` text COMMENT '介绍',
  `spec_items` varchar(3000) DEFAULT NULL COMMENT '规格列表',
  `para_items` varchar(3000) DEFAULT NULL COMMENT '参数列表',
  `sale_num` int(11) DEFAULT '0' COMMENT '销量',
  `comment_num` int(11) DEFAULT '0' COMMENT '评论数',
  `is_marketable` char(1) DEFAULT '0' COMMENT '是否上架,0已下架，1已上架',
  `is_enable_spec` char(1) DEFAULT '1' COMMENT '是否启用规格',
  `is_delete` char(1) DEFAULT '0' COMMENT '是否删除,0:未删除，1：已删除',
  `status` char(1) DEFAULT '0' COMMENT '审核状态，0：未审核，1：已审核，2：审核不通过',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;

SKU：（独有属性）

CREATE TABLE `tb_sku` (
  `id` bigint(20) NOT NULL COMMENT '商品id',
  `sn` varchar(100) NOT NULL COMMENT '商品条码',
  `name` varchar(200) NOT NULL COMMENT 'SKU名称',
  `price` int(20) NOT NULL COMMENT '价格（分）',
  `num` int(10) NOT NULL COMMENT '库存数量',
  `alert_num` int(11) DEFAULT NULL COMMENT '库存预警数量',
  `image` varchar(200) DEFAULT NULL COMMENT '商品图片',
  `images` varchar(2000) DEFAULT NULL COMMENT '商品图片列表',
  `weight` int(11) DEFAULT NULL COMMENT '重量（克）',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `spu_id` bigint(20) DEFAULT NULL COMMENT 'SPUID',
  `category_id` int(10) DEFAULT NULL COMMENT '类目ID',
  `category_name` varchar(200) DEFAULT NULL COMMENT '类目名称',
  `brand_name` varchar(100) DEFAULT NULL COMMENT '品牌名称',
  `spec` varchar(200) DEFAULT NULL COMMENT '规格',
  `sale_num` int(11) DEFAULT '0' COMMENT '销量',
  `comment_num` int(11) DEFAULT '0' COMMENT '评论数',
  `status` char(1) DEFAULT '1' COMMENT '商品状态 1-正常，2-下架，3-删除',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `cid` (`category_id`) USING BTREE,
  KEY `status` (`status`) USING BTREE,
  KEY `updated` (`update_time`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='商品表';

分类表：

CREATE TABLE `tb_category` (
  `id` int(20) NOT NULL AUTO_INCREMENT COMMENT '分类ID',
  `name` varchar(50) DEFAULT NULL COMMENT '分类名称',
  `goods_num` int(11) DEFAULT '0' COMMENT '商品数量',
  `is_show` char(1) DEFAULT NULL COMMENT '是否显示',
  `is_menu` char(1) DEFAULT NULL COMMENT '是否导航',
  `seq` int(11) DEFAULT NULL COMMENT '排序',
  `parent_id` int(20) DEFAULT NULL COMMENT '上级ID',
  `template_id` int(11) DEFAULT NULL COMMENT '模板ID',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `parent_id` (`parent_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=11157 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='商品类目';

parent_id 为 0就是一级分类
# 查询一级分类
SELECT * FROM tb_category WHERE parent_id = 0;
# 查询二级分类   将选中的一级分类的id作为父节点 查询对应的子分类
SELECT * FROM tb_category Where parent_id = 963;
# 查询三级分类 将选中的二级分类的id作为父节点 查询对应的子类
SELECT * FROM tb_category WHERE parent_id  = 1000;

品牌表：

CREATE TABLE `tb_brand` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '品牌id',
  `name` varchar(100) NOT NULL COMMENT '品牌名称',
  `image` varchar(1000) DEFAULT '' COMMENT '品牌图片地址',
  `letter` char(1) DEFAULT '' COMMENT '品牌的首字母',
  `seq` int(11) DEFAULT NULL COMMENT '排序',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=325417 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='品牌表';

分类与品牌关联表：

CREATE TABLE `tb_category_brand` (
  `category_id` int(11) NOT NULL COMMENT '分类ID',
  `brand_id` int(11) NOT NULL COMMENT '品牌ID',
  PRIMARY KEY (`category_id`,`brand_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;

# 分类对应的品牌查询
# 查询出对应的分类和品牌的映射关系  tb_category_brand中查询
SELECT * FROM tb_category_brand WHERE category_id = 11156;
# 根据查询的映射关系查询对应品牌 tb_brand 中查询
SELECT * FROM tb_brand WHERE id in (18372,352414)
# 合并查询
SELECT tb.* FROM tb_brand tb,tb_category_brand tcb WHERE tb.id = tcb.brand_id AND tcb.category_id = 11156;

规格表：

CREATE TABLE `tb_spec` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `name` varchar(50) DEFAULT NULL COMMENT '名称',
  `options` varchar(2000) DEFAULT NULL COMMENT '规格选项',
  `seq` int(11) DEFAULT NULL COMMENT '排序',
  `template_id` int(11) DEFAULT NULL COMMENT '模板ID',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=40 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;
# 规格查询：tb_spec   --->template_id  根据用户选中的三级分类的template_id 来决定查询哪个temolate_id对应的规格数据
SELECT * FROM tb_category WHERE id = 11156;
SELECT * FROM tb_spec WHERE template_id = 42;

参数表：

CREATE TABLE `tb_para` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `name` varchar(50) DEFAULT NULL COMMENT '名称',
  `options` varchar(2000) DEFAULT NULL COMMENT '选项',
  `seq` int(11) DEFAULT NULL COMMENT '排序',
  `template_id` int(11) DEFAULT NULL COMMENT '模板ID',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;

# 根据之前选择的三级分类的template_id查询 
SELECT * FROM tb_para WHERE template_id = 42;

三、神器介绍

黑马代码生成器。
在这里插入图片描述
启动运行，即可生成Controller、Service、ServiceImpl、DAO代码。
数据库：

效果：
在这里插入图片描述
生成的Controller：

生成的Server：

业务层接口实现类：

dao层：

拷走即可用。

四、商品发布

根据父节点ID查询子分类（集合）

# Controller
  /**
     * 根据父节点id查询子分类
     * @param pid
     * @return
     */
    @GetMapping("/list/{pid}")
    public Result<Category> findByParentId(@PathVariable("pid") Integer pid){
    
    
        List<Category> byParentId = categoryService.findByParentId(pid);
        return new Result(true,StatusCode.OK,"查询子分类成功",byParentId);
    }
   #  Service：
    /**
     * 根据父节点ID查询子节点集合
     */
    public List<Category> findByParentId(Integer pid);

    /***
     * Category多条件分页查询
     * @param category
     * @param page
     * @param size
     * @return
     */
    PageInfo<Category> findPage(Category category, int page, int size);
# Impl：
 /**
     * 根据父ID查询子分类集合
     * @param pid
     * @return
     *SELECT * FROM tb_category WHERE parent_id = #{pid}
     * 构造一个javaBeen  如果该指定属性不为空就将那个属性作为查询条件
     */
    @Override
    public List<Category> findByParentId(Integer pid) {
    
    
        Category category = new Category();
        category.setParentId(pid);
        return categoryMapper.select(category);
    }

根据分类id查询品牌信息（集合）

# Controller：
/**
     * 根据分类id查询品牌信息
     * @param id
     * @return
     */
    @GetMapping("/category/{id}")
    public Result<Brand> findByCategoryID(@PathVariable("id") Integer id){
    
    
        List<Brand> byCategory = brandService.findByCategory(id);
        return new Result<Brand>(true, StatusCode.OK,"根据分类ID查询品牌成功",byCategory) ;

    }
# Service:
 /**
     * 根据分类id查询品牌集合
     * @param categoryId
     * @return
     */
    List<Brand> findByCategory(Integer categoryId);

# Impl:
@Override
    public List<Brand> findByCategory(Integer categoryId) {
    
    
        return brandMapper.findByCategory(categoryId);
    }
# DAO:
public interface BrandMapper extends Mapper<Brand> {
    
    
    @Select("SELECT tb.* FROM tb_brand tb,tb_category_brand tcb WHERE tb.id = tcb.brand_id AND tcb.category_id = #{categoryId}")
    List<Brand> findByCategory(Integer categoryId);
}

根据分类id查询规格信息（集合）

# Controller:
 @GetMapping("/category/{id}")
    public Result findByCategoryID(@PathVariable("id") Integer id){
    
    
        List<Spec> byCategoryID = specService.findByCategoryID(id);
        return new Result(true,StatusCode.OK,"查询规格信息成功",byCategoryID);
    }
# Service:
List<Spec> findByCategoryID(Integer id);
# Impl:
    @Autowired
    private CategoryMapper categoryMapper;

    @Override
    public List<Spec> findByCategoryID(Integer id) {
    
    
        Category category = categoryMapper.selectByPrimaryKey(id);
        Spec spec = new Spec();
        spec.setTemplateId(category.getTemplateId());
        List<Spec> select = specMapper.select(spec);
        return select;

    }

根据分类id查询参数信息（集合）

# Controller:
 /**
     * 根据分类id  查询  模板id
     * 在根据模板id 查询 参数信息 集合
     * @param id
     * @return
     */
    @GetMapping("/category/{id}")
    public Result<Para> findByCategoryId(@PathVariable("id") Integer id){
    
    
        List<Para> byCategory = paraService.findByCategory(id);
        return new Result(true,StatusCode.OK,"根据分类信息查询参数信息集合成功",byCategory);

    }
# Service:

    List<Para> findByCategory(Integer categoryId);
# Impl:
    @Autowired
    private CategoryMapper categoryMapper;

    @Override
    public List<Para> findByCategory(Integer categoryId) {
    
    
        //根据分类信息 查询模板id
        Category category = categoryMapper.selectByPrimaryKey(categoryId);
        //在根据模板id查询参数信息
        Para para = new Para();
        para.setTemplateId(category.getTemplateId());
        List<Para> select = paraMapper.select(para);
        return select;
    }

五、测试

查询：珠宝/水晶玛瑙/手机配件
查询分类信息http://localhost:18081/category/list/0
查询一级目录：
在这里插入图片描述

查询二级目录：
在这里插入图片描述

查询品牌信息：http://localhost:18081/brand/category/11156
在这里插入图片描述
查询规格信息：http://localhost:18081/spec/category/11156

查询参数：http://localhost:18081/para/category/11156

六、添加商品

新建一个Goods实体类用来接收参数
在这里插入图片描述

sku的名称就是spu的名称加上规格信息
在这里插入图片描述

七、根据id查询商品详情

根据 spuID查询spu 也根据spuID查询List sku 封装Goods 返回。

八、修改商品

修改和新增共用一个方法
如果spuID存在就是修改商品，将之前的sku删除并新增修改后的sku
如果spuID不存在，则就是新增商品

九、商品的审核与上架下架

修改对应状态即可，
isDelete 0 未删除 1 已删除
isMaketable 0 未上架已上架
status 0 审核未通过 1 审核已通过

十、完整代码

SpuController

package com.mychanggou.goods.controller;

import com.github.pagehelper.PageInfo;
import com.mychanggou.goods.pojo.Goods;
import com.mychanggou.goods.pojo.Spu;
import com.mychanggou.goods.service.SpuService;
import entity.Result;
import entity.StatusCode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/****
 * @Author:admin
 * @Description:
 * @Date 2019/6/14 0:18
 *****/

@RestController
@RequestMapping("/spu")
@CrossOrigin
public class SpuController {
    
    

    @Autowired
    private SpuService spuService;

    @PutMapping("/put/many")
    public Result putMany(Long[] ids){
    
    
        spuService.putMany(ids);
        return new Result(true,StatusCode.OK,"商品批量上架成功");
    }

    @PutMapping("/put/{id}")
    public Result put(@PathVariable("id") Long id){
    
    
        spuService.put(id);
        return new Result(true,StatusCode.OK,"商品上架成功");
    }

    @PutMapping("/pull/{id}")
    public Result pull(@PathVariable("id") Long id){
    
    
        spuService.pull(id);
        return new Result(true,StatusCode.OK,"商品下架成功");
    }


    @PutMapping("audit/{id}")
    public Result audit(@PathVariable("id") Long id){
    
    
        spuService.audit(id);
        return new Result(true,StatusCode.OK,"商品审核成功");
    }


    @GetMapping("/goods/{id}")
    public Result findGoodsById(@PathVariable("id") Long id){
    
    

        Goods goods = spuService.findGoodsById(id);

        return new Result(true,StatusCode.OK,"查询Goods成功",goods);
    }

    @PostMapping("/save")
    public Result save(@RequestBody Goods goods){
    
    
        spuService.saveGoods(goods);
        return new Result(true,StatusCode.OK,"新增商品成功");
    }

    /***
     * Spu分页条件搜索实现
     * @param spu
     * @param page
     * @param size
     * @return
     */
    @PostMapping(value = "/search/{page}/{size}" )
    public Result<PageInfo> findPage(@RequestBody(required = false)  Spu spu, @PathVariable  int page, @PathVariable  int size){
    
    
        //调用SpuService实现分页条件查询Spu
        PageInfo<Spu> pageInfo = spuService.findPage(spu, page, size);
        return new Result(true,StatusCode.OK,"查询成功",pageInfo);
    }

    /***
     * Spu分页搜索实现
     * @param page:当前页
     * @param size:每页显示多少条
     * @return
     */
    @GetMapping(value = "/search/{page}/{size}" )
    public Result<PageInfo> findPage(@PathVariable  int page, @PathVariable  int size){
    
    
        //调用SpuService实现分页查询Spu
        PageInfo<Spu> pageInfo = spuService.findPage(page, size);
        return new Result<PageInfo>(true,StatusCode.OK,"查询成功",pageInfo);
    }

    /***
     * 多条件搜索品牌数据
     * @param spu
     * @return
     */
    @PostMapping(value = "/search" )
    public Result<List<Spu>> findList(@RequestBody(required = false)  Spu spu){
    
    
        //调用SpuService实现条件查询Spu
        List<Spu> list = spuService.findList(spu);
        return new Result<List<Spu>>(true,StatusCode.OK,"查询成功",list);
    }

    /***
     * 根据ID删除品牌数据
     * @param id
     * @return
     */
    @DeleteMapping(value = "/{id}" )
    public Result delete(@PathVariable Long id){
    
    
        //调用SpuService实现根据主键删除
        spuService.delete(id);
        return new Result(true,StatusCode.OK,"删除成功");
    }

    /***
     * 修改Spu数据
     * @param spu
     * @param id
     * @return
     */
    @PutMapping(value="/{id}")
    public Result update(@RequestBody  Spu spu,@PathVariable Long id){
    
    
        //设置主键值
        spu.setId(id);
        //调用SpuService实现修改Spu
        spuService.update(spu);
        return new Result(true,StatusCode.OK,"修改成功");
    }

    /***
     * 新增Spu数据
     * @param spu
     * @return
     */
    @PostMapping
    public Result add(@RequestBody   Spu spu){
    
    
        //调用SpuService实现添加Spu
        spuService.add(spu);
        return new Result(true,StatusCode.OK,"添加成功");
    }

    /***
     * 根据ID查询Spu数据
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public Result<Spu> findById(@PathVariable Long id){
    
    
        //调用SpuService实现根据主键查询Spu
        Spu spu = spuService.findById(id);
        return new Result<Spu>(true,StatusCode.OK,"查询成功",spu);
    }

    /***
     * 查询Spu全部数据
     * @return
     */
    @GetMapping
    public Result<List<Spu>> findAll(){
    
    
        //调用SpuService实现查询所有Spu
        List<Spu> list = spuService.findAll();
        return new Result<List<Spu>>(true, StatusCode.OK,"查询成功",list) ;
    }
}

SpuService

package com.mychanggou.goods.service;

import com.github.pagehelper.PageInfo;
import com.mychanggou.goods.pojo.Goods;
import com.mychanggou.goods.pojo.Spu;

import java.util.List;

/****
 * @Author:admin
 * @Description:Spu业务层接口
 * @Date 2019/6/14 0:16
 *****/
public interface SpuService {
    
    

    /**
     * 批量上架
     * @param ids
     */
    void putMany(Long[] ids);

    /**
     * 商品上架
     * @param id
     */
    void put (long id );

    /**
     * 商品下架
     * @param id
     */
    void pull (long id );

    /**
     * 商品审核
     * @param spuid
     */
     void audit(long spuid);

    /**
     * 根据id查询Goods
     * @param id  spu id
     * @return
     */
    Goods findGoodsById(Long id);




    /**
     * 添加商品  添加 spu   添加sku
     * @param goods
     */
    void saveGoods(Goods goods);

    /***
     * Spu多条件分页查询
     * @param spu
     * @param page
     * @param size
     * @return
     */
    PageInfo<Spu> findPage(Spu spu, int page, int size);

    /***
     * Spu分页查询
     * @param page
     * @param size
     * @return
     */
    PageInfo<Spu> findPage(int page, int size);

    /***
     * Spu多条件搜索方法
     * @param spu
     * @return
     */
    List<Spu> findList(Spu spu);

    /***
     * 删除Spu
     * @param id
     */
    void delete(Long id);

    /***
     * 修改Spu数据
     * @param spu
     */
    void update(Spu spu);

    /***
     * 新增Spu
     * @param spu
     */
    void add(Spu spu);

    /**
     * 根据ID查询Spu
     * @param id
     * @return
     */
     Spu findById(Long id);

    /***
     * 查询所有Spu
     * @return
     */
    List<Spu> findAll();
}

SpuServiceImpl

package com.mychanggou.goods.service.impl;

import com.alibaba.fastjson.JSON;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mychanggou.goods.dao.BrandMapper;
import com.mychanggou.goods.dao.CategoryMapper;
import com.mychanggou.goods.dao.SkuMapper;
import com.mychanggou.goods.dao.SpuMapper;
import com.mychanggou.goods.pojo.*;
import com.mychanggou.goods.service.SpuService;
import entity.IdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

/****
 * @Author:admin
 * @Description:Spu业务层接口实现类
 * @Date 2019/6/14 0:16
 *****/
@Service
public class SpuServiceImpl implements SpuService {
    
    

    @Autowired
    private SpuMapper spuMapper;
    @Autowired
    private SkuMapper skuMapper;
    @Autowired
    private IdWorker idWorker;
    @Autowired
    private CategoryMapper categoryMapper;
    @Autowired
    private BrandMapper brandMapper;

    @Override
    public void putMany(Long[] ids) {
    
    
        Example example = new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andIn("id", Arrays.asList(ids));
        criteria.andEqualTo("isDelete","0");//未删除
        criteria.andEqualTo("status","1");//通过审核
        //准备修改的数据
        Spu spu = new Spu();
        spu.setIsMarketable("1");//上架
        spuMapper.updateByExampleSelective(spu,example);

    }

    @Override
    public void put(long id) {
    
    
        Spu spu = spuMapper.selectByPrimaryKey(id);
        if("1".equals(spu.getIsDelete())){
    
    
            throw new RuntimeException("不能上架已删除的商品！");
        }
        if("1".equals(spu.getStatus())){
    
    
            throw new RuntimeException("不能上架未通过审核的商品！");
        }
        spu.setIsMarketable("1");//上架
        spuMapper.updateByPrimaryKeySelective(spu);
    }

    @Override
    public void pull(long id) {
    
    
        Spu spu = spuMapper.selectByPrimaryKey(id);
        if("1".equals(spu.getIsDelete())){
    
    
            throw new RuntimeException("不能下架已删除的商品！");
        }
        spu.setIsMarketable("0");//下架
        spuMapper.updateByPrimaryKeySelective(spu);
    }

    @Override
    public void audit(long spuid) {
    
    
        Spu spu = spuMapper.selectByPrimaryKey(spuid);
        if("1".equals(spu.getIsDelete())){
    
    
            throw new RuntimeException("不能对已删除的商品进行审核！");
        }
        spu.setStatus("1");//审核通过
        spu.setIsMarketable("1");//上架
        spuMapper.updateByPrimaryKeySelective(spu);
    }

    @Override
    public Goods findGoodsById(Long id) {
    
    
        //先查询 spu
        Spu spu = spuMapper.selectByPrimaryKey(id);
        //在查询 sku  集合  List<SKU>  select * from tb_sku where spu_id = id
        Sku sku = new Sku();
        sku.setSpuId(id);
        List<Sku> skus = skuMapper.select(sku);
        Goods goods = new Goods();
        goods.setSpu(spu);
        goods.setSkuList(skus);

        return goods;
    }

    /**
     * 添加商品信息
     * SPU  一个
     * SKU 集合
     * @param goods
     * 逻辑：
     * 如果 存在 spuID  就是修改  修改的话就更新 spu  并且全部删除之前的sku
     * 如果不存在spuID   就是新增   正常新增即可
     */
    @Override
    public void saveGoods(Goods goods) {
    
    
        Spu spu = goods.getSpu();
        //如果id 为空  就是新增  否则为修改
        if(spu.getId() == null){
    
    
            spu.setId(idWorker.nextId());
            spuMapper.insertSelective(spu);
        }else {
    
    
            spuMapper.updateByPrimaryKeySelective(spu);
            //删除List<Sku>
            Sku sku = new Sku();
            sku.setSpuId(spu.getId());
            skuMapper.delete(sku);
        }

        List<Sku> skuList = goods.getSkuList();
        Category category = categoryMapper.selectByPrimaryKey(spu.getCategory3Id());
        Brand brand = brandMapper.selectByPrimaryKey(spu.getBrandId());
        Date date = new Date();
        for (Sku sku : skuList) {
    
    
            sku.setId(idWorker.nextId());
            String name = spu.getName();
            //防止空指针异常
            if(StringUtils.isEmpty(sku.getSpec())){
    
    
                sku.setSpec("{}");
            }
            Map<String ,String > skuMap = JSON.parseObject(sku.getSpec(), Map.class);
            for (Map.Entry<String, String> entry : skuMap.entrySet()) {
    
    
                name += entry.getValue();
            }
            sku.setName(name);//sku商品名称  spuName +规格信息
            sku.setCreateTime(date);//添加时间
            sku.setUpdateTime(date);//更新时间
            sku.setSpuId(spu.getId());//spu的id
            sku.setCategoryId(spu.getCategory3Id());//三级分类的id  需要通过spu  查询三级分类id 查询分类信息
            sku.setCategoryName(category.getName());//三级分类的名称
            sku.setBrandName(brand.getName());//品牌名称


        }

    }

    /**
     * Spu条件+分页查询
     * @param spu 查询条件
     * @param page 页码
     * @param size 页大小
     * @return 分页结果
     */
    @Override
    public PageInfo<Spu> findPage(Spu spu, int page, int size){
    
    
        //分页
        PageHelper.startPage(page,size);
        //搜索条件构建
        Example example = createExample(spu);
        //执行搜索
        return new PageInfo<Spu>(spuMapper.selectByExample(example));
    }

    /**
     * Spu分页查询
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageInfo<Spu> findPage(int page, int size){
    
    
        //静态分页
        PageHelper.startPage(page,size);
        //分页查询
        return new PageInfo<Spu>(spuMapper.selectAll());
    }

    /**
     * Spu条件查询
     * @param spu
     * @return
     */
    @Override
    public List<Spu> findList(Spu spu){
    
    
        //构建查询条件
        Example example = createExample(spu);
        //根据构建的条件查询数据
        return spuMapper.selectByExample(example);
    }


    /**
     * Spu构建查询对象
     * @param spu
     * @return
     */
    public Example createExample(Spu spu){
    
    
        Example example=new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();
        if(spu!=null){
    
    
            // 主键
            if(!StringUtils.isEmpty(spu.getId())){
    
    
                    criteria.andEqualTo("id",spu.getId());
            }
            // 货号
            if(!StringUtils.isEmpty(spu.getSn())){
    
    
                    criteria.andEqualTo("sn",spu.getSn());
            }
            // SPU名
            if(!StringUtils.isEmpty(spu.getName())){
    
    
                    criteria.andLike("name","%"+spu.getName()+"%");
            }
            // 副标题
            if(!StringUtils.isEmpty(spu.getCaption())){
    
    
                    criteria.andEqualTo("caption",spu.getCaption());
            }
            // 品牌ID
            if(!StringUtils.isEmpty(spu.getBrandId())){
    
    
                    criteria.andEqualTo("brandId",spu.getBrandId());
            }
            // 一级分类
            if(!StringUtils.isEmpty(spu.getCategory1Id())){
    
    
                    criteria.andEqualTo("category1Id",spu.getCategory1Id());
            }
            // 二级分类
            if(!StringUtils.isEmpty(spu.getCategory2Id())){
    
    
                    criteria.andEqualTo("category2Id",spu.getCategory2Id());
            }
            // 三级分类
            if(!StringUtils.isEmpty(spu.getCategory3Id())){
    
    
                    criteria.andEqualTo("category3Id",spu.getCategory3Id());
            }
            // 模板ID
            if(!StringUtils.isEmpty(spu.getTemplateId())){
    
    
                    criteria.andEqualTo("templateId",spu.getTemplateId());
            }
            // 运费模板id
            if(!StringUtils.isEmpty(spu.getFreightId())){
    
    
                    criteria.andEqualTo("freightId",spu.getFreightId());
            }
            // 图片
            if(!StringUtils.isEmpty(spu.getImage())){
    
    
                    criteria.andEqualTo("image",spu.getImage());
            }
            // 图片列表
            if(!StringUtils.isEmpty(spu.getImages())){
    
    
                    criteria.andEqualTo("images",spu.getImages());
            }
            // 售后服务
            if(!StringUtils.isEmpty(spu.getSaleService())){
    
    
                    criteria.andEqualTo("saleService",spu.getSaleService());
            }
            // 介绍
            if(!StringUtils.isEmpty(spu.getIntroduction())){
    
    
                    criteria.andEqualTo("introduction",spu.getIntroduction());
            }
            // 规格列表
            if(!StringUtils.isEmpty(spu.getSpecItems())){
    
    
                    criteria.andEqualTo("specItems",spu.getSpecItems());
            }
            // 参数列表
            if(!StringUtils.isEmpty(spu.getParaItems())){
    
    
                    criteria.andEqualTo("paraItems",spu.getParaItems());
            }
            // 销量
            if(!StringUtils.isEmpty(spu.getSaleNum())){
    
    
                    criteria.andEqualTo("saleNum",spu.getSaleNum());
            }
            // 评论数
            if(!StringUtils.isEmpty(spu.getCommentNum())){
    
    
                    criteria.andEqualTo("commentNum",spu.getCommentNum());
            }
            // 是否上架,0已下架，1已上架
            if(!StringUtils.isEmpty(spu.getIsMarketable())){
    
    
                    criteria.andEqualTo("isMarketable",spu.getIsMarketable());
            }
            // 是否启用规格
            if(!StringUtils.isEmpty(spu.getIsEnableSpec())){
    
    
                    criteria.andEqualTo("isEnableSpec",spu.getIsEnableSpec());
            }
            // 是否删除,0:未删除，1：已删除
            if(!StringUtils.isEmpty(spu.getIsDelete())){
    
    
                    criteria.andEqualTo("isDelete",spu.getIsDelete());
            }
            // 审核状态，0：未审核，1：已审核，2：审核不通过
            if(!StringUtils.isEmpty(spu.getStatus())){
    
    
                    criteria.andEqualTo("status",spu.getStatus());
            }
        }
        return example;
    }

    /**
     * 删除
     * @param id
     */
    @Override
    public void delete(Long id){
    
    
        spuMapper.deleteByPrimaryKey(id);
    }

    /**
     * 修改Spu
     * @param spu
     */
    @Override
    public void update(Spu spu){
    
    
        spuMapper.updateByPrimaryKey(spu);
    }

    /**
     * 增加Spu
     * @param spu
     */
    @Override
    public void add(Spu spu){
    
    
        spuMapper.insert(spu);
    }

    /**
     * 根据ID查询Spu
     * @param id
     * @return
     */
    @Override
    public Spu findById(Long id){
    
    
        return  spuMapper.selectByPrimaryKey(id);
    }

    /**
     * 查询Spu全部数据
     * @return
     */
    @Override
    public List<Spu> findAll() {
    
    
        return spuMapper.selectAll();
    }
}

注意：
使用IdWork 要在主启动类中注入
在这里插入图片描述

@SpringBootApplication
@EnableEurekaClient//开启Eureka客户端
@MapperScan(basePackages = "com.mychanggou.goods.dao")
public class GoodsApplication {
    
    
    @Value("${workerId}")
    private Integer workerId;
    @Value("${datacenterId}")
    private Integer datacenterId;

    public static void main(String[] args) {
    
    
        SpringApplication.run(GoodsApplication.class);
    }
    @Bean
    public IdWorker idWorker(){
    
    
        return new IdWorker(workerId,datacenterId);
    }
}

畅购电商项目_商品发布（三）