商品发布
一、介绍
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);
}
}