其他分享
首页 > 其他分享> > 第4章.商品管理

第4章.商品管理

作者:互联网

第4章 商品管理

学习目标

1. 分布式ID生成解决方案

1.1 分布式ID生成解决方案

1.1.1 UUID

常见的方式。可以利用数据库也可以利用程序生成,一般来说全局唯一。

优点:

1)简单,代码方便。

2)生成ID性能非常好,基本不会有性能问题。

3)全局唯一,在遇见数据迁移,系统数据合并,或者数据库变更等情况下,可以从容应对。

缺点:

1)没有排序,无法保证趋势递增。

2)UUID往往是使用字符串存储,查询的效率比较低。

3)存储空间比较大,如果是海量数据库,就需要考虑存储量的问题。

4)传输数据量大

5)不可读。

1.1.2 Redis

当使用数据库来生成ID性能不够要求的时候,我们可以尝试使用Redis来生成ID。这主要依赖于Redis是单线程的,所以也可以用生成全局唯一的ID。可以用Redis的原子操作 INCR和INCRBY来实现。

优点:

1)不依赖于数据库,灵活方便,且性能优于数据库。

2)数字ID天然排序,对分页或者需要排序的结果很有帮助。

缺点:

1)如果系统中没有Redis,还需要引入新的组件,增加系统复杂度。

2)需要编码和配置的工作量比较大。

3)网络传输造成性能下降。

1.1.3 开源算法snowflake

snowflake是Twitter开源的分布式ID生成算法,结果是一个long型的ID。其核心思想是:使用41bit作为毫秒数,10bit作为机器的ID(5个bit是数据中心,5个bit的机器ID),12bit作为毫秒内的流水号(意味着每个节点在每毫秒可以产生 4096 个 ID),最后还有一个符号位,永远是0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ieOgTuTR-1620310115903)(image/4-2.png)]

我们在《畅购》系统中采用的就是开源算法snowflake

1.2 snowflake快速入门

1.2.1 快速入门

(1)新建工程,将资料/工具类下的IdWorker.java拷贝到工程中。

(2)编写代码

        IdWorker idWorker=new IdWorker(1,1);

        for(int i=0;i<10000;i++){
            long id = idWorker.nextId();
            System.out.println(id);
        }

1.2.2 配置分布式ID生成器

(1)IdWorker.java拷贝到changgou_common工程com.changgou.util包中

(2)changgou_service_goods的application.yml添加配置

workerId: 0
datacenterId: 0

(3)修改GoodsApplication,增加代码

    @Value("${workerId}")
    private Integer workerId;

    @Value("${datacenterId}")
    private Integer datacenterId;

    @Bean
    public IdWorker idWorker(){
        return new IdWorker(workerId,datacenterId);
    }

2 新增和修改商品

2.1 概念与表结构分析

2.1.1 SPU与SKU概念

SPU = Standard Product Unit  (标准产品单位)

SKU=stock keeping unit( 库存量单位)

2.1.2 表结构分析

tb_spu 表 (SPU表)

字段名称字段含义字段类型字段长度备注
id主键VARCHAR
sn货号VARCHAR
nameSPU名VARCHAR
caption副标题VARCHAR
brand_id品牌IDINT
category1_id一级分类INT
category2_id二级分类INT
category3_id三级分类INT
template_id模板IDINT
freight_id运费模板idINT
image图片VARCHAR
images图片列表VARCHAR
sale_service售后服务VARCHAR
introduction介绍TEXT
spec_items规格列表VARCHAR
para_items参数列表VARCHAR
sale_num销量INT
comment_num评论数INT
is_marketable是否上架CHAR
is_enable_spec是否启用规格CHAR
is_delete是否删除CHAR
status审核状态CHAR

tb_sku 表(SKU商品表)

字段名称字段含义字段类型字段长度备注
id商品idVARCHAR
sn商品条码VARCHAR
nameSKU名称VARCHAR
price价格(分)INT
num库存数量INT
alert_num库存预警数量INT
image商品图片VARCHAR
images商品图片列表VARCHAR
weight重量(克)INT
create_time创建时间DATETIME
update_time更新时间DATETIME
spu_idSPUIDBIGINT
category_id类目IDINT
category_name类目名称VARCHAR
brand_name品牌名称VARCHAR
spec规格VARCHAR
sale_num销量INT
comment_num评论数INT
status商品状态 1-正常,2-下架,3-删除CHAR

2.2 实现思路

前端传递给后端的数据格式 是一个spu对象和sku列表组成的对象。

{
    "spu": {
      	"name": "这个是商品名称",
      	"caption": "这个是副标题",
		"brandId": 1115,
		"category1Id": 558,
		"category2Id": 559,
		"category3Id": 560,
		"freightId": 10,
		"image": "http://www.changgou.com/image/1.jpg",
         "images": "http://www.changgou.com/image/1.jpg,http://www.changgou.com/image/2.jpg",
		"introduction": "这个是商品详情,html代码",
         "paraItems": "{'出厂年份':'2019','赠品':'充电器'}",
		"saleService": "七天包退,闪电退货",
		"sn": "020102331",
		"specItems":  "{'颜色':['红','绿'],'机身内存':['64G','8G']}",
		"templateId": 42
	},
	"skuList": [{
		"sn": "10192010292",
         "num": 100,
      	 "alertNum": 20,
		 "price": 900000,
         "spec": "{'颜色':'红','机身内存':'64G'}",
         "image": "http://www.changgou.com/image/1.jpg",
         "images": "http://www.changgou.com/image/1.jpg,http://www.changgou.com/image/2.jpg",
		"status": "1",
		"weight": 130
	},
    {
		"sn": "10192010293",
         "num": 100,
      	 "alertNum": 20,
		 "price": 600000,
         "spec": "{'颜色':'蓝','机身内存':'128G'}",
         "image": "http://www.changgou.com/image/1.jpg",
         "images": "http://www.changgou.com/image/1.jpg,http://www.changgou.com/image/2.jpg",
		"status": "1",
		"weight": 130
	}
  ]
}

这里我们需要定义一个Goods实体对前端传过来的参数进行封装:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LnbjaZSX-1620310115906)(C:\Users\gao\AppData\Roaming\Typora\typora-user-images\1574418879507.png)]

2.3 代码实现

2.3.1 SPU与SKU列表的保存

代码实现:

(1)changgou_service_goods_api工程创建组合实体类Goods

/**
 * 商品组合实体类
 */
public class Goods implements Serializable {

    private Spu spu;
    private List<Sku> skuList;

    public Spu getSpu() {
        return spu;
    }

    public void setSpu(Spu spu) {
        this.spu = spu;
    }

    public List<Sku> getSkuList() {
        return skuList;
    }

    public void setSkuList(List<Sku> skuList) {
        this.skuList = skuList;
    }
}

(2)changgou_service_goods工程SpuService新增方法add(Goods goods)

    /***
     * 新增
     * @param goods
     */
    void add(Goods goods);

(3)changgou_service_goods工程SpuServiceImpl实现此方法

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private SkuMapper skuMapper;

    @Autowired
    private BrandMapper brandMapper;

    @Autowired
    private IdWorker idWorker;

    /**
     * 保存商品 SPU+SKU列表
     * @param goods 商品组合实体类
     */
    @Transactional
    @Override
    public void add(Goods goods) {
        Spu spu = goods.getSpu();
        long spuId = idWorker.nextId();
        spu.setId(String.valueOf(spuId));
        spu.setIsDelete("0");
        spu.setIsMarketable("0");
        spu.setStatus("0");
        spuMapper.insertSelective(spu);

        //保存sku集合数据到数据库
        saveSkuList(goods);
    }

    /**
     * 保存sku列表
     * @param goods
     */
    private void saveSkuList(Goods goods){
        //获取spu对象
        Spu spu = goods.getSpu();
        //当前日期
        Date date = new Date();
        //获取品牌对象
        Brand brand = brandMapper.selectByPrimaryKey(spu.getBrandId());
        //获取分类对象
        Category category = categoryMapper.selectByPrimaryKey(spu.getCategory3Id());
        //获取sku集合对象
        List<Sku> skuList = goods.getSkuList();
        if (skuList != null) {
            for (Sku sku : skuList) {
                //设置sku主键ID
                sku.setId(String.valueOf(idWorker.nextId()));
                //设置sku规格
                if (sku.getSpec() == null || "".equals(sku.getSpec())) {
                    sku.setSpec("{}");
                }
                //设置sku名称(商品名称 + 规格)
                String name = spu.getName();
                //将规格json字符串转换成Map
                Map<String, String> specMap = JSON.parseObject(sku.getSpec(), Map.class);
                if (specMap != null && specMap.size() > 0) {
                    for(String value : specMap.values()){
                        name += " "+ value;
                    }
                }

                sku.setName(name);//名称
                sku.setSpuId(spu.getId());//设置spu的ID
                sku.setCreateTime(date);//创建日期
                sku.setUpdateTime(date);//修改日期
                sku.setCategoryId(category.getId());//商品分类ID
                sku.setCategoryName(category.getName());//商品分类名称
                sku.setBrandName(brand.getName());//品牌名称
                skuMapper.insertSelective(sku);//插入sku表数据
            }
        }
    }

(3)修改SpuController的add方法

    /***
     * 新增数据
     * @param goods
     * @return
     */
    @PostMapping
    public Result add(@RequestBody Goods goods){
        spuService.add(goods);
        return new Result(true,StatusCode.OK,"添加成功");
    }

2.3.2 品牌与分类关联

实现思路:

将分类ID与SPU的品牌ID 一起插入到tb_category_brand表中

(1)创建实体类

@Table(name="tb_category_brand")
public class CategoryBrand implements Serializable {

    @Id
    private Integer categoryId;

    @Id
    private Integer brandId;


    public Integer getCategoryId() {
        return categoryId;
    }

    public void setCategoryId(Integer categoryId) {
        this.categoryId = categoryId;
    }

    public Integer getBrandId() {
        return brandId;
    }

    public void setBrandId(Integer brandId) {
        this.brandId = brandId;
    }
}

这个表是联合主键,所以templateId和brandId都有@Id注解

(2)新建数据访问接口

public interface CategoryBrandMapper extends Mapper<CategoryBrand> {
  
}

(3)SpuServiceImpl引入

    @Autowired
    private CategoryBrandMapper categoryBrandMapper;

(4)修改SpuServiceImpl的saveSkuList方法,添加分类与品牌之间的关联, 修改后代码如下:

private void saveSkuList(Goods goods) {
        //获取spu对象
        Spu spu = goods.getSpu();
        //当前日期
        Date date = new Date();
        //获取品牌对象
        Brand brand = brandMapper.selectByPrimaryKey(spu.getBrandId());
        //获取分类对象
        Category category = categoryMapper.selectByPrimaryKey(spu.getCategory3Id());

        /**
         * 添加分类与品牌之间的关联
         */
        CategoryBrand categoryBrand = new CategoryBrand();
        categoryBrand.setBrandId(spu.getBrandId());
        categoryBrand.setCategoryId(spu.getCategory3Id());
        int count = categoryBrandMapper.selectCount(categoryBrand);
        //判断是否有这个品牌和分类的关系数据
        if(count == 0) {
            //如果没有关系数据则添加品牌和分类关系数据
            categoryBrandMapper.insert(categoryBrand);
        }

        //获取sku集合对象
        List<Sku> skuList = goods.getSkuList();
        if (skuList != null) {
            for (Sku sku : skuList) {
                //设置sku主键ID
                sku.setId(String.valueOf(idWorker.nextId()));
                //设置sku规格
                if (sku.getSpec() == null || "".equals(sku.getSpec())) {
                    sku.setSpec("{}");
                }
                //设置sku名称(商品名称 + 规格)
                String name = spu.getName();
                //将规格json字符串转换成Map
                Map<String, String> specMap = JSON.parseObject(sku.getSpec(), Map.class);
                if (specMap != null && specMap.size() > 0) {
                    for(String value : specMap.values()){
                        name += " "+ value;
                    }
                }

                sku.setName(name);//名称
                sku.setSpuId(spu.getId());//设置spu的ID
                sku.setCreateTime(date);//创建日期
                sku.setUpdateTime(date);//修改日期
                sku.setCategoryId(category.getId());//商品分类ID
                sku.setCategoryName(category.getName());//商品分类名称
                sku.setBrandName(brand.getName());//品牌名称
                skuMapper.insertSelective(sku);//插入sku表数据
            }
        }
    }

2.3.3 根据ID查询商品

需求:根据id 查询SPU和SKU列表 ,显示效果如下:

{
    "spu": {
		"brandId": 8557,
		"caption": "111",
		"category1Id": 558,
		"category2Id": 559,
		"category3Id": 560,
		"commentNum": 0,
		"freightId": 0,
		"id": 149187842867993,
		"image": "",
		"images": "[{\"color\":\"银白色\",\"url\":\"//img11.360buyimg.com/n7/jfs/t30040/100/1290632710/208879/1f7e2225/5cdd0d92Nb78895a6.jpg\"}]",
		"introduction": "这是测试手机数据",
		"isDelete": 0,
		"isEnableSpec": "0",
		"isMarketable": "0",
		"name": "黑马智能手机",
		"paraItems": "",
		"saleNum": 0,
		"saleService": "",
		"sn": "",
		"specItems": "{\"颜色\":[\"金色\",\"黑色\",\"蓝色\"],\"版本\":[\"6GB+64GB\"]}",
		"status": "0",
		"templateId": 42
	},
	"skuList": [{
		"alertNum": 100,
		"commentNum": 0,
		"image": "https://m.360buyimg.com/mobilecms/s720x720_jfs/t22642/312/2563982615/103706/1398b13d/5b865bb3N0409f0d0.jpg!q70.jpg.webp",
		"images": "https://m.360buyimg.com/mobilecms/s720x720_jfs/t22642/312/2563982615/103706/1398b13d/5b865bb3N0409f0d0.jpg!q70.jpg.webp",
		"num": 100,
		"price": 90000,
		"saleNum": 0,
		"sn": "",
		"spec": "{'颜色': '蓝色'}",
		"status": "1",
		"weight": 10
	},{
		"alertNum": 100,
		"commentNum": 0,
		"image": "https://m.360buyimg.com/mobilecms/s720x720_jfs/t22642/312/2563982615/103706/1398b13d/5b865bb3N0409f0d0.jpg!q70.jpg.webp",
		"images": "https://m.360buyimg.com/mobilecms/s720x720_jfs/t22642/312/2563982615/103706/1398b13d/5b865bb3N0409f0d0.jpg!q70.jpg.webp",
		"num": 100,
		"price": 80000,
		"saleNum": 0,
		"sn": "",
		"spec": "{'颜色': '黑色'}",
		"status": "1",
		"weight": 10
	  }
   ]
}

代码实现:

(1)changgou_service_goods工程SpuService新增方法定义

    /**
     * 根据ID查询商品
     * @param id
     * @return
     */
    public Goods findGoodsById(String id);

(2)changgou_service_goods工程SpuServiceImpl实现此方法

    /**
     * 根据ID查询商品
     * @param id
     * @return
     */
    public Goods findGoodsById(String id){
        //查询spu
        Spu spu = spuMapper.selectByPrimaryKey(id);

        //查询SKU 列表
        Example example=new Example(Sku.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("spuId",id);
        List<Sku> skuList = skuMapper.selectByExample(example);

        //封装,返回
        Goods goods=new Goods();
        goods.setSpu(spu);
        goods.setSkuList(skuList);
        return goods;
    }

(3)修改SpuController的findById方法

    @GetMapping("/{id}")
    public Result findById(@PathVariable String id){
        Goods goods = spuService.findGoodsById(id);
        return new Result(true,StatusCode.OK,"查询成功",goods);
    }

2.3.4 保存修改

(1)changgou_service_goods工程SpuService新增方法定义

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

(2)changgou_service_goods工程SpuServiceImpl实现此方法


    @Override
    public void update(Goods goods ) {
        //取出spu部分
        Spu spu = goods.getSpu();
        spuMapper.updateByPrimaryKey(spu);
        //删除原sku列表
        Example example=new Example(Sku.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("spuId",spu.getId());
        skuMapper.deleteByExample(example);

        saveSkuList(goods);//保存sku列表
    }

(3)修改SpuController的update方法

    /***
     * 修改数据
     * @param goods
     * @param id
     * @return
     */
    @PutMapping(value="/{id}")
    public Result update(@RequestBody Goods goods,@PathVariable String id){
        spuService.update(goods);
        return new Result(true,StatusCode.OK,"修改成功");
    }

3 商品审核与上下架

3.1 需求分析

商品新增后,审核状态为0(未审核),默认为下架状态。

审核商品,需要校验是否是被删除的商品,如果未删除则修改审核状态为1,并自动上架

下架商品,需要校验是否是被删除的商品,如果未删除则修改上架状态为0

上架商品,需要审核状态为1,如果为1,则更改上下架状态为1

3.2 实现思路

(1)按照ID查询SPU信息

(2)判断修改审核、上架下架状态

(3)保存SPU

3.3 代码实现

3.3.1 商品审核

需要校验是否是被删除的商品,如果未删除则修改审核状态为1,并自动上架

(1)SpuService新增方法

    /**
     * 审核
     * @param id
     */
    public void audit(String id);

(2)SpuServiceImpl实现方法

@Transactional
    public void audit(String id) {
        //查询spu对象
        Spu spu = spuMapper.selectByPrimaryKey(id);
        if (spu == null){
            throw new RuntimeException("当前商品不存在");
        }
        //判断当前spu是否处于删除状态
        if ("1".equals(spu.getIsDelete())){
            throw new RuntimeException("当前商品处于删除状态");
        }
        //不处于删除状态,修改审核状态为1,上下架状态为1
        spu.setStatus("1");
        spu.setIsMarketable("1");
        //执行修改操作
        spuMapper.updateByPrimaryKeySelective(spu);
    }

(2)SpuController新增方法

    /**
     * 审核
     * @param id
     * @return
     */
    @PutMapping("/audit/{id}")
    public Result audit(@PathVariable String id){
        spuService.audit(id);
        return new Result();
    }

3.3.2 下架商品

校验是否是被删除的商品,如果未删除则修改上架状态为0

(1)SpuService新增方法

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

(2)SpuServiceImpl实现方法

@Transactional
    public void pull(String id) {
        //查询spu
        Spu spu = spuMapper.selectByPrimaryKey(id);
        if (spu == null){
            throw new RuntimeException("当前商品不存在");
        }
        //判断当前商品是否处于删除状态
        if ("1".equals(spu.getIsDelete())){
            throw new RuntimeException("当前商品处于删除状态");
        }
        //商品处于未删除状态的话,则修改上下架状态为已下架(0)
        spu.setIsMarketable("0");
        spuMapper.updateByPrimaryKeySelective(spu);
    }

(2)SpuController新增方法

    /**
     * 下架
     * @param id
     * @return
     */
    @PutMapping("/pull/{id}")
    public Result pull(@PathVariable String id){
        spuService.pull(id);
        return new Result();
    }

3.3.3 上架商品

必须是通过审核的商品才能上架

(1)SpuService新增方法

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

(2)SpuServiceImpl 实现此方法

    /**
     * 上架商品
     * @param id
     */
    @Override
    public void put(String id) {
        Spu spu = spuMapper.selectByPrimaryKey(id);
        if(!spu.getStatus().equals("1")){
            throw new RuntimeException("未通过审核的商品不能上架!");
        }
        spu.setIsMarketable("1");//上架状态
        spuMapper.updateByPrimaryKeySelective(spu);
    }

(3)SpuController新增方法

    /**
     * 上架
     * @param id
     * @return
     */
    @PutMapping("/put/{id}")
    public Result put(@PathVariable String id){
        spuService.put(id);
        return new Result();
    }

4 删除与还原商品

4.1 需求分析

商品列表中的删除商品功能,并非真正的删除(物理删除),而是采用逻辑删除将删除标记的字段设置为1.

在回收站中有还原商品的功能,将删除标记的字段设置为0

在回收站中有删除商品的功能,是真正的物理删除,将数据从数据库中删除掉。

4.2 实现思路

商品列表中的删除商品,执行逻辑删除,修改spu表is_delete字段为1

商品回收站中的还原商品,修改spu表is_delete字段为0

商品回收站中的删除商品,执行delete操作,进行物理删除

4.3 代码实现

4.3.1 逻辑删除商品

修改SpuServiceImpl的delete方法

    /**
     * 删除
     * @param id
     */
    @Override
    public void delete(String id){
        Spu spu = spuMapper.selectByPrimaryKey(id);
        //检查是否下架的商品
        if(!spu.getIsMarketable().equals("0")){
            throw new RuntimeException("必须先下架再删除!");
        }
        spu.setIsDelete("1");//删除
        spu.setStatus("0");//未审核
        spuMapper.updateByPrimaryKeySelective(spu);
    }

4.3.2 还原被删除的商品

(1)SpuService新增方法

    /**
     * 恢复数据
     * @param id
     */
    public void restore(String id);

(2)SpuServiceImpl实现此方法

    /**
     * 恢复数据
     * @param id
     */
    @Override
    public void restore(String id) {
        Spu spu = spuMapper.selectByPrimaryKey(id);
        //检查是否删除的商品
        if(!spu.getIsDelete().equals("1")){
            throw new RuntimeException("此商品未删除!");
        }
        spu.setIsDelete("0");//未删除
        spu.setStatus("0");//未审核
        spuMapper.updateByPrimaryKeySelective(spu);
    }    

(3)SpuController新增方法

    /**
     * 恢复数据
     * @param id
     * @return
     */
    @PutMapping("/restore/{id}")
    public Result restore(@PathVariable String id){
        spuService.restore(id);
        return new Result();
    }

4.3.3 物理删除商品

判断必须逻辑删除商品才能物理删除

(1)SpuService 新增方法

    /**
     * 物理删除
     * @param id
     */
    public void realDelete(String id);

(2)SpuServiceImpl 实现方法

    @Override
    public void realDelete(String id) {
        Spu spu = spuMapper.selectByPrimaryKey(id);
        //检查是否删除的商品
        if(!spu.getIsDelete().equals("1")){
            throw new RuntimeException("此商品未删除!");
        }
        spuMapper.deleteByPrimaryKey(id);
        
    }

(3)SpuController新增方法


    /**
     * 物理删除
     * @param id
     * @return
     */
    @DeleteMapping("/realDelete/{id}")
    public Result realDelete(@PathVariable String id){
        spuService.realDelete(id);
        return new Result();
    }

标签:sku,goods,删除,管理,spu,public,商品,id
来源: https://blog.csdn.net/happy_de_goudan/article/details/116464487