通用型产品发布解决方案(基于分布式微服务技术栈:SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven+Linux+Docker+Nginx - 《03》
- GitHub：github.com/China-Rainb...
- Gitee：gitee.com/Rainbow--Se...
@[toc]
Mybatis-plus 分页插件
补充：renren 的分页插件
java
/**
* 列表
* 说明:
* 1. 根据业务需求，增加根据分类(第3级分类) + 查询条件+ 分页的API接口/方法
*/
@RequestMapping("/list/{categoryId}")
//@RequiresPermissions("commodity:attrgroup:list")
public R list(@RequestParam Map<String, Object> params, @PathVariable("categoryId") Long categoryId){
PageUtils page = attrgroupService.queryPage(params,categoryId);
return R.ok().put("page", page);
}
java
/**
* 增加根据家居分类(第三级的)+查询条件+分页 API接口
* 可以通过 debug来查看后台的 SQL语句，一目了然
*
* @param params
* @param categoryId
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params, Long categoryId) {
// 获取用户进行查询时的关键字
String key = (String) params.get("key");
// QueryWrapper是 renren相关提供的，是用于封装查询条件 /参数
QueryWrapper<AttrgroupEntity> wrapper =
new QueryWrapper<AttrgroupEntity>();
//如果是带条件查询,将条件分组到 wrapper,
//这里的 id和 name是指的 commodity_attrgroup表的字段
// 判断 key 是否携带的有查询条件
//if (!StringUtils.isEmpty(key)) {
// wrapper.and((obj) -> {
// obj.eq("id", key).or().like("name", key);
// });
//}
// 判断 key 是否携带的有查询添加-希望他是一组独立检索条件。
if (!StringUtils.isEmpty(key)) {
wrapper.and((obj) -> {
obj.eq("id", key).or().like("name", key);
});
}
// IPage是 renren提供的工具类,用于分页查询
//categoryId为 0表示,查询分类属性组时,不加入 categoryId
//(是我设置的业务逻辑,目前调用,传的 categoryId都不为 0)
// 否则就加入 And categoryId = xxx
if (categoryId != 0) {
wrapper.eq("category_id", categoryId);
}
IPage<AttrgroupEntity> page = this.page(
new Query<AttrgroupEntity>().getPage(params),
wrapper
);
return new PageUtils(page);
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.alibaba.cloud.context.utils.StringUtils;
import org.springframework.stereotype.Service;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.AttrgroupDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.AttrgroupEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.AttrgroupService;
@Service("attrgroupService")
public class AttrgroupServiceImpl extends ServiceImpl<AttrgroupDao, AttrgroupEntity> implements AttrgroupService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<AttrgroupEntity> page = this.page(
new Query<AttrgroupEntity>().getPage(params),
new QueryWrapper<AttrgroupEntity>()
);
return new PageUtils(page);
}
/**
* 增加根据家居分类(第三级的)+查询条件+分页 API接口
* 可以通过 debug来查看后台的 SQL语句，一目了然
*
* @param params
* @param categoryId
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params, Long categoryId) {
// 获取用户进行查询时的关键字
String key = (String) params.get("key");
// QueryWrapper是 renren相关提供的，是用于封装查询条件 /参数
QueryWrapper<AttrgroupEntity> wrapper =
new QueryWrapper<AttrgroupEntity>();
//如果是带条件查询,将条件分组到 wrapper,
//这里的 id和 name是指的 commodity_attrgroup表的字段
// 判断 key 是否携带的有查询条件
//if (!StringUtils.isEmpty(key)) {
// wrapper.and((obj) -> {
// obj.eq("id", key).or().like("name", key);
// });
//}
// 判断 key 是否携带的有查询添加-希望他是一组独立检索条件。
if (!StringUtils.isEmpty(key)) {
wrapper.and((obj) -> {
obj.eq("id", key).or().like("name", key);
});
}
// IPage是 renren提供的工具类,用于分页查询
//categoryId为 0表示,查询分类属性组时,不加入 categoryId
//(是我设置的业务逻辑,目前调用,传的 categoryId都不为 0)
// 否则就加入 And categoryId = xxx
if (categoryId != 0) {
wrapper.eq("category_id", categoryId);
}
IPage<AttrgroupEntity> page = this.page(
new Query<AttrgroupEntity>().getPage(params),
wrapper
);
return new PageUtils(page);
}
}打括号的查询提供，分组，括号查询
java
if (!StringUtils.isEmpty(key)) {
wrapper.and((obj) -> {
obj.eq("id", key).or().like("name", key);
});
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.alibaba.cloud.context.utils.StringUtils;
import org.springframework.stereotype.Service;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.AttrgroupDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.AttrgroupEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.AttrgroupService;
@Service("attrgroupService")
public class AttrgroupServiceImpl extends ServiceImpl<AttrgroupDao, AttrgroupEntity> implements AttrgroupService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<AttrgroupEntity> page = this.page(
new Query<AttrgroupEntity>().getPage(params),
new QueryWrapper<AttrgroupEntity>()
);
return new PageUtils(page);
}
/**
* 增加根据家居分类(第三级的)+查询条件+分页 API接口
* 可以通过 debug来查看后台的 SQL语句，一目了然
*
* @param params
* @param categoryId
* @return
*/
@Override
public PageUtils queryPage(Map<String, Object> params, Long categoryId) {
// 获取用户进行查询时的关键字
String key = (String) params.get("key");
// QueryWrapper是 renren相关提供的，是用于封装查询条件 /参数
QueryWrapper<AttrgroupEntity> wrapper =
new QueryWrapper<AttrgroupEntity>();
//如果是带条件查询,将条件分组到 wrapper,
//这里的 id和 name是指的 commodity_attrgroup表的字段
// 判断 key 是否携带的有查询条件
//if (!StringUtils.isEmpty(key)) {
// wrapper.and((obj) -> {
// obj.eq("id", key).or().like("name", key);
// });
//}
if (!StringUtils.isEmpty(key)) {
wrapper.and((obj) -> {
obj.eq("id", key).or().like("name", key);
});
}
// IPage是 renren提供的工具类,用于分页查询
//categoryId为 0表示,查询分类属性组时,不加入 categoryId
//(是我设置的业务逻辑,目前调用,传的 categoryId都不为 0)
// 否则就加入 And categoryId = xxx
if (categoryId != 0) {
wrapper.eq("category_id", categoryId);
}
IPage<AttrgroupEntity> page = this.page(
new Query<AttrgroupEntity>().getPage(params),
wrapper
);
return new PageUtils(page);
}
}配置类(引入分页插件)
在对应项目，或者微服务当中的 config 配置目录下创建，MyB
atisConfig.java，MyBatis-plus 的分页插件的配置类
java
package com.rainbowsea.rainbowsealiving.commodity.config;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration // 标识是一个配置类
@EnableTransactionManagement //开启事务
@MapperScan("com.rainbowsea.rainbowsealiving.commodity.dao") // 扫描的 dao 目录包位置
public class MyBatisConfig {
// 引入分页插件
@Bean
public PaginationInterceptor paginationInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
// 设置请求的页面大于最大页后操作，
// true 调回到首页，false 继续请求 默认 false
paginationInterceptor.setOverflow(true);
//设置最大单页限制数量，默认 500条，-1不受限制
paginationInterceptor.setLimit(100);
return paginationInterceptor;
}
}层级定位
可以省略
前端搜索检索功能
可以省略
关联表-而不是使用外键
写
BeanUtils 的使用
java
BeanUtils.copyProperties(test1,test2); // 将 test1对象属性拷贝大宋 test2 当中SPU 和 SKU 的概念和实现
SPU 的概述
- SPU(**(**Stock keeping Unit)：标准化产品单元
- 用简单的话来说就是一类商品，比如：手机里的一种牌子，如：小米，苹果，都是一类。然后，加入具体的类型，如：小米 15，苹果 16 等等。那么它就是一个 spu
SKU 的概述：
- SKU(Stock keeping Unit)：库存保有单位。
- SKU 简单的来说就是在 spu 原有的基础上加入具体的类型，如(小米 15，白色，8+252G) 。组合起来就是一个完整地 SKU，所以 SKU 就是一类商品的各种样式的组合。
- SKU 的组合会影响该商品的价格。
SPU 和 SKU 的关系：
- SPU 和 SKU 就是上下级关系，没有 SPU 就没有 SKU，因为假如没有这一类商品，就没法谈这件商品具体的颜色尺寸。
- 如下图：假如没有选择任何类型那么他就是一个单独的 SPU，但是当它选择了具体的颜色，版本，购买方式等等，那么他就是一个 SKU。
- 保存商品 spu 信息
- 1 个 spu 信息可能对于多个 sku
- 1 个 spu + 1 个 sku 就是一个商品的组合关系()
JSON 转换为 Java 实体类
写，特别的
P550
P564
- 当目前的实体类/对象，格式不能满足我们的需求时，可以使用上 VO
**View Object**** 对象。VO 可以根据需求组合已有**的实体类的字段，或者增加，或者删除一些字段。 - 如果返回的 JSON 数据的当前实体类，不能满足需求，则定义一个 VO(View Object) 对象，在该对象，可以根据需求组合实体类字段，或者增加，或者删除一些字段。
vue
submitSkus() {
console.log("要提交保存的商品信息(spu=) " , JSON.stringify(this.spu)); //将 json 对象转
成字符串输出
this.$confirm("将要提交商品数据, 是否继续?", "提示", {
confirmButtonText: "确定", cancelButtonText: "取消",
type: "warning"
})//其它
vue
<el-button type="success" @click="submitSkus">下一步：保存商品信息</el-button>
submitSkus() {
console.log("要提交保存的商品信息(spu=) " , JSON.stringify(this.spu))
this.$confirm("将要提交商品数据，需要一小段时间，是否继续?", "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning"
})
.then(() => {
this.$http({
//url: "http://localhost:9090/commodity/spuinfo/save",
url: this.$http.adornUrl("/commodity/spuinfo/save"),
method: "post",
data: this.$http.adornData(this.spu, false)
}).then(({data}) => {
if (data.code == 0) {
this.$message({
type: "success",
message: "新增商品成功!"
});
this.step = 4;
} else {
this.$message({
type: "error",
message: "保存失败，原因【" + data.msg + "】"
});
}
});
})
.catch(e => {
console.log(e);
this.$message({
type: "info",
message: "已取消"
});
});
},分析一个 JSON 格式内容，将 console 输出的 json 字符串，格式化一下好看: www.json.cn/
为了能够在服务端接收提交的数据，我们使用 json 在线工具，转成 entity 对象(实际是一组)，作为 VO实体类。
- 点击 JSON 生成 Java 实体
- 把 console 输出的 JSON 字符串拷贝到左侧。
- 指定类名，包名，点击生成即可。
把生成好的 VO 实体类(我已经改好了, 可以直接使用(在资料文件夹))
注意：编写对应的 Cotroller 当中的编码信息。
分 析 一 下 json 格 式 内 容 , 将 console 输 出 的 json 字 符 串 ， 格 式 化 一 下 好 看 www.json.cn/
- 为了能够在服务端接收提交的数据，我们使用 json 在线工具，转成 entity 对象(实际是 一组), 作为 VO 实体类
- 点击 JSON 生成 JAVA 实体
对生成好的 VO 实体类进行简化和定制，比如 int 改成 Long , double 改成 BigDecimal
这样更符合我们的要求, 我已经改好了, 可以直接使用(在资料文件夹)，并增加了两个 VO
类 , Images.java 和 MemberPrice.java, 直接替换一下即可
- 增加 Images.java 和 MemberPrice.java
- 修改 int ---> long，double ------>BigDecimal
- 使用
@Data 注解简化 entity 类
梳理 VO 实体类和提交的 Json 数据关系
- 保存商品 spu 信息
- 1 个 spu 信息可能对于多个 sku
- 1 个 spu + 1 个 sku 就是一个商品的组合关系()
保存商品信息，涉及到的表非常多，不是一个 SpulnfoEntityh 实体类能包括的，将 SpulnfoEntity 改成我们前面生成的 SpuSaveVo 包含了 JSON 提交所有信息。
我们这里是通过一个定制的方法 saveSpulnfo 来完成。
保存 SKU 的图片信息表的设置
java
package com.rainbowsea.rainbowsealiving.commodity.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
* 商品 spu 信息介绍
*
* @author rainbowsea
* @email [email protected]
* @date 2025-03-24 20:46:13
*/
@Data
@TableName("commodity_spu_info_desc")
public class SpuInfoDescEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 商品 id
* 因为 commodity_spu_info_desc 表的 id 不是自增长的，而是我们指定的
* 因此，我们这里给 spuId 标识上 @TableId(type = IdType.INPUT)
* , 否则底层的 sql 语句时不会生成添加 supId 的 sql 语句(可以通过日志输出看看)
*/
@TableId(type = IdType.INPUT)
private Long spuId;
/**
* 商品介绍图片
*/
private String decript;
}
java
package com.rainbowsea.rainbowsealiving.commodity.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.vo.SpuSaveVO;
import java.util.Map;
/**
* 商品 spu 信息
*
* @author rainbowsea
* @email [email protected]
* @date 2025-03-24 20:31:43
*/
public interface SpuInfoService extends IService<SpuInfoEntity> {
PageUtils queryPage(Map<String, Object> params);
void saveSpuInfo(SpuSaveVO spuSaveVO);
void saveBaseSpuInfo(SpuInfoEntity spuInfoEntity);
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuInfoDescDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
@Service("spuInfoDescService")
public class SpuInfoDescServiceImpl extends ServiceImpl<SpuInfoDescDao, SpuInfoDescEntity> implements SpuInfoDescService {
@Override
public void saveSpuInfoDesc(SpuInfoDescEntity spuInfoDescEntity) {
this.baseMapper.insert(spuInfoDescEntity);
}
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SpuInfoDescEntity> page = this.page(
new Query<SpuInfoDescEntity>().getPage(params),
new QueryWrapper<SpuInfoDescEntity>()
);
return new PageUtils(page);
}
}
java
package com.rainbowsea.rainbowsealiving.commodity.controller;
import java.util.Arrays;
import java.util.Map;
//import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.R;
/**
* 商品 spu 信息介绍
*
* @author rainbowsea
* @email [email protected]
* @date 2025-03-24 20:46:13
*/
@RestController
@RequestMapping("commodity/spuinfodesc")
public class SpuInfoDescController {
@Autowired
private SpuInfoDescService spuInfoDescService;
/**
* 列表
*/
@RequestMapping("/list")
//@RequiresPermissions("commodity:spuinfodesc:list")
public R list(@RequestParam Map<String, Object> params){
PageUtils page = spuInfoDescService.queryPage(params);
return R.ok().put("page", page);
}
/**
* 信息
*/
@RequestMapping("/info/{spuId}")
//@RequiresPermissions("commodity:spuinfodesc:info")
public R info(@PathVariable("spuId") Long spuId){
SpuInfoDescEntity spuInfoDesc = spuInfoDescService.getById(spuId);
return R.ok().put("spuInfoDesc", spuInfoDesc);
}
/**
* 保存
*/
@RequestMapping("/save")
//@RequiresPermissions("commodity:spuinfodesc:save")
public R save(@RequestBody SpuInfoDescEntity spuInfoDesc){
spuInfoDescService.save(spuInfoDesc);
return R.ok();
}
/**
* 修改
*/
@RequestMapping("/update")
//@RequiresPermissions("commodity:spuinfodesc:update")
public R update(@RequestBody SpuInfoDescEntity spuInfoDesc){
spuInfoDescService.updateById(spuInfoDesc);
return R.ok();
}
/**
* 删除
*/
@RequestMapping("/delete")
//@RequiresPermissions("commodity:spuinfodesc:delete")
public R delete(@RequestBody Long[] spuIds){
spuInfoDescService.removeByIds(Arrays.asList(spuIds));
return R.ok();
}
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
import com.rainbowsea.rainbowsealiving.commodity.vo.SpuSaveVO;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuInfoDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service("spuInfoService")
public class SpuInfoServiceImpl extends ServiceImpl<SpuInfoDao, SpuInfoEntity> implements SpuInfoService {
@Resource
SpuInfoDescService spuInfoDescService;
//因为有多个添加操作，使用事务控制
@Transactional
@Override
public void saveSpuInfo(SpuSaveVO spuSaveVO) {
//1、保存 spu 基本信息 , 对应的表 commodity_spu_info
SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
spuInfoEntity.setCreateTime(new Date());
spuInfoEntity.setUpdateTime(new Date());
//SpuInfoEntity 信息保存到 commodity_spu_info
this.saveBaseSpuInfo(spuInfoEntity);
//2、保存 Spu 的描述图片路径 commodity_spu_info_desc
List<String> decript = spuSaveVO.getDecript();
SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
//获取到刚刚保存的 spu 基本信息对应的 id
spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
//注意：这里有可能没有图片, 可以设置一个默认图片
if(decript.size() == 0) {
spuInfoDescEntity.setDecript("default.jpg");
}else {
spuInfoDescEntity.setDecript(String.join(",", decript));
}
//保存到 commodity_spu_info_desc, 这个方法时我们完成
spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
}
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SpuInfoEntity> page = this.page(
new Query<SpuInfoEntity>().getPage(params),
new QueryWrapper<SpuInfoEntity>()
);
return new PageUtils(page);
}
/**
* 保存 spu 的基本信息到 commodity_spu_info
* @param spuInfoEntity
*/
@Override
public void saveBaseSpuInfo(SpuInfoEntity spuInfoEntity) {
this.baseMapper.insert(spuInfoEntity);
}
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////2. 将 SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
// }
}完成功能说明: 提示: 这里我们先暂时不选择图片, 主要测试 保存默认图片信息
是否能记录到 commodity_spu_images 表(后面操作批量保存图片到阿里云)
保存到阿里云操作：具体代码实现：
sql
/*======================================================*/
/* 1. 保存商品 spu 的介绍图片集, 就是商品最前面的按一组图片来展示图片的集合 , 点
击可以切换图片
/*======================================================*/
USE hspliving_commodity
CREATE TABLE commodity_spu_images
(
id BIGINT NOT NULL AUTO_INCREMENT COMMENT 'id', spu_id BIGINT COMMENT 'spu_id',
img_name VARCHAR(200) COMMENT '图片名',
img_url VARCHAR(255) COMMENT '图片地址',
img_sort INT COMMENT '顺序', default_img TINYINT COMMENT '是否默认图', PRIMARY KEY (id)
)CHARSET=utf8mb4 COMMENT='spu 图片集';
SELECT * FROM commodity_spu_images
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuImagesService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
import com.rainbowsea.rainbowsealiving.commodity.vo.SpuSaveVO;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuInfoDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service("spuInfoService")
public class SpuInfoServiceImpl extends ServiceImpl<SpuInfoDao, SpuInfoEntity> implements SpuInfoService {
@Resource
SpuImagesService imagesService;
@Resource
SpuInfoDescService spuInfoDescService;
//因为有多个添加操作，使用事务控制
@Transactional
@Override
public void saveSpuInfo(SpuSaveVO spuSaveVO) {
//1、保存 spu 基本信息 , 对应的表 commodity_spu_info
SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
spuInfoEntity.setCreateTime(new Date());
spuInfoEntity.setUpdateTime(new Date());
//SpuInfoEntity 信息保存到 commodity_spu_info
this.saveBaseSpuInfo(spuInfoEntity);
//2、保存 Spu 的描述图片路径 commodity_spu_info_desc
List<String> decript = spuSaveVO.getDecript();
SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
//获取到刚刚保存的 spu 基本信息对应的 id
spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
//注意：这里有可能没有图片, 可以设置一个默认图片
if(decript.size() == 0) {
spuInfoDescEntity.setDecript("default.jpg");
}else {
spuInfoDescEntity.setDecript(String.join(",", decript));
}
//保存到 commodity_spu_info_desc, 这个方法时我们完成
spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//3、保存 spu 的图片集 commodity_spu_images
List<String> images = spuSaveVO.getImages();
//获取到刚刚保存的 spu 基本信息对应的 id
imagesService.saveImages(spuInfoEntity.getId(), images);
}
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SpuInfoEntity> page = this.page(
new Query<SpuInfoEntity>().getPage(params),
new QueryWrapper<SpuInfoEntity>()
);
return new PageUtils(page);
}
/**
* 保存 spu 的基本信息到 commodity_spu_info
* @param spuInfoEntity
*/
@Override
public void saveBaseSpuInfo(SpuInfoEntity spuInfoEntity) {
this.baseMapper.insert(spuInfoEntity);
}
}
java
package com.rainbowsea.rainbowsealiving.commodity.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuImagesEntity;
import java.util.List;
import java.util.Map;
/**
* spu 图片集
*
* @author rainbowsea
* @email [email protected]
* @date 2025-03-24 21:02:53
*/
public interface SpuImagesService extends IService<SpuImagesEntity> {
PageUtils queryPage(Map<String, Object> params);
void saveImages(Long id, List<String> images);
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuImagesDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuImagesEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuImagesService;
import javax.annotation.Resource;
@Service("spuImagesService")
public class SpuImagesServiceImpl extends ServiceImpl<SpuImagesDao, SpuImagesEntity> implements SpuImagesService {
@Resource
SpuImagesService imagesService;
/**
* 保存某个 spu 的图片集，就是商品最前面的按一组图片来展示图片的集合
* @param id
* @param images
*/
@Override
public void saveImages(Long id, List<String> images) {
System.out.println("saveImage...");
if(images == null || images.size() == 0){//设置默认图片集
SpuImagesEntity spuImagesEntity = new SpuImagesEntity();
spuImagesEntity.setSpuId(id);
spuImagesEntity.setImgUrl("default1.jpg");
spuImagesEntity.setDefaultImg(1);
this.save(spuImagesEntity);
} else { //如果有，就遍历，批量添加即可
List<SpuImagesEntity> collect = images.stream().map(img -> {
SpuImagesEntity spuImagesEntity = new SpuImagesEntity();
spuImagesEntity.setSpuId(id);
spuImagesEntity.setImgUrl(img);
return spuImagesEntity;
}).collect(Collectors.toList());
this.saveBatch(collect);
}
}
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SpuImagesEntity> page = this.page(
new Query<SpuImagesEntity>().getPage(params),
new QueryWrapper<SpuImagesEntity>()
);
return new PageUtils(page);
}
}保存 spu 的基本属性/规格参数
创建保存 spu 的基本属性/规格参数的表
sql
/*====================================================*/
/* 1. 保存商品 spu 基本属性值, 有多个
/*====================================================*/
USE hspliving_commodity
CREATE TABLE commodity_product_attr_value
(
id BIGINT NOT NULL AUTO_INCREMENT COMMENT 'id',
spu_id BIGINT COMMENT '商品 id',
attr_id BIGINT COMMENT '属性 id',
attr_name VARCHAR(200) COMMENT '属性名',
attr_value VARCHAR(200) COMMENT '属性值',
attr_sort INT COMMENT '顺序',
quick_show TINYINT COMMENT '快速展示【是否展示在介绍上；0-否 1-是】',
PRIMARY KEY (id)
)CHARSET=utf8mb4 COMMENT='spu 基本属性值';
java
package com.rainbowsea.rainbowsealiving.commodity.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.rainbowsealiving.commodity.entity.ProductAttrValueEntity;
import java.util.List;
import java.util.Map;
/**
* spu 基本属性值
*
* @author rainbowsea
* @email [email protected]
* @date 2025-03-24 21:40:59
*/
public interface ProductAttrValueService extends IService<ProductAttrValueEntity> {
PageUtils queryPage(Map<String, Object> params);
void saveProductAttr(List<ProductAttrValueEntity> collect);
}
java
package com.rainbowsea.rainbowsealiving.commodity.entity;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.util.Date;
import lombok.Data;
/**
* spu 基本属性值
*
* @author rainbowsea
* @email [email protected]
* @date 2025-03-24 21:40:59
*/
@Data
@TableName("commodity_product_attr_value")
public class ProductAttrValueEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId
private Long id;
/**
* 商品 id
*/
private Long spuId;
/**
* 属性 id
*/
private Long attrId;
/**
* 属性名
*/
private String attrName;
/**
* 属性值
*/
private String attrValue;
/**
* 顺序
*/
private Integer attrSort;
/**
* 快速展示【是否展示在介绍上；0-否 1-是】
*/
private Integer quickShow;
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.ProductAttrValueDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.ProductAttrValueEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.ProductAttrValueService;
@Service("productAttrValueService")
public class ProductAttrValueServiceImpl extends ServiceImpl<ProductAttrValueDao, ProductAttrValueEntity> implements ProductAttrValueService {
@Override
public void saveProductAttr(List<ProductAttrValueEntity> collect) {
this.saveBatch(collect);
}
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<ProductAttrValueEntity> page = this.page(
new Query<ProductAttrValueEntity>().getPage(params),
new QueryWrapper<ProductAttrValueEntity>()
);
return new PageUtils(page);
}
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.rainbowsea.rainbowsealiving.commodity.entity.AttrEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.ProductAttrValueEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.AttrService;
import com.rainbowsea.rainbowsealiving.commodity.service.ProductAttrValueService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuImagesService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
import com.rainbowsea.rainbowsealiving.commodity.vo.BaseAttrs;
import com.rainbowsea.rainbowsealiving.commodity.vo.SpuSaveVO;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuInfoDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service("spuInfoService")
public class SpuInfoServiceImpl extends ServiceImpl<SpuInfoDao, SpuInfoEntity> implements SpuInfoService {
@Resource
AttrService attrService;
@Resource
ProductAttrValueService productAttrValueService;
@Transactional
@Override
public void saveSpuInfo(SpuSaveVO spuSaveVO) {
//1、保存 spu 基本信息 , 对应的表 commodity_spu_info
SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
spuInfoEntity.setCreateTime(new Date());
spuInfoEntity.setUpdateTime(new Date());
//SpuInfoEntity 信息保存到 commodity_spu_info
this.saveBaseSpuInfo(spuInfoEntity);
//2、保存 Spu 的描述图片路径 commodity_spu_info_desc
List<String> decript = spuSaveVO.getDecript();
SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
//获取到刚刚保存的 spu 基本信息对应的 id
spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
//注意：这里有可能没有图片, 可以设置一个默认图片
if (decript.size() == 0) {
spuInfoDescEntity.setDecript("default.jpg");
} else {
spuInfoDescEntity.setDecript(String.join(",", decript));
}
//保存到 commodity_spu_info_desc, 这个方法时我们完成
spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//3、保存 spu 的图片集 commodity_spu_images
List<String> images = spuSaveVO.getImages();
//获取到刚刚保存的 spu 基本信息对应的 id
imagesService.saveImages(spuInfoEntity.getId(), images);
//4、保存 spu 的基本属性(一个 spu 可以有多个基本属性/规格参数):
// commodity_product_attr_value
List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
valueEntity.setAttrId(attr.getAttrId());
AttrEntity id = attrService.getById(attr.getAttrId());
valueEntity.setAttrName(id.getAttrName());
valueEntity.setAttrValue(attr.getAttrValues());
valueEntity.setQuickShow(attr.getShowDesc());
valueEntity.setSpuId(spuInfoEntity.getId());
return valueEntity;
}).collect(Collectors.toList());
productAttrValueService.saveProductAttr(collect);
}
@Resource
SpuImagesService imagesService;
@Resource
SpuInfoDescService spuInfoDescService;
//因为有多个添加操作，使用事务控制
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if(decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// }else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
// }
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SpuInfoEntity> page = this.page(
new Query<SpuInfoEntity>().getPage(params),
new QueryWrapper<SpuInfoEntity>()
);
return new PageUtils(page);
}
/**
* 保存 spu 的基本信息到 commodity_spu_info
* @param spuInfoEntity
*/
@Override
public void saveBaseSpuInfo(SpuInfoEntity spuInfoEntity) {
this.baseMapper.insert(spuInfoEntity);
}
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////2. 将 SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
// }
}保存 SKU 的基本信息
完成保存商品信息功能-有难度-比较综合-涉及解决方案
解决方案分析：
- 因为在保存商品信息时，涉及到的信息很多。
- 可以通过拆解，创建多个 VO 层的 JavaBean，将商品信息保存到对应的各个表中。
- 梳理下（重要！开发中，前端和后端是配合的，有时我们后端人员需要根据前端的业务需求来设计程序）
整理上面的图：
分析前端发送的 JSON(很复杂)---> 创建 VO 对象/类(多个，可能还有组合/包含关系)------> 创建对应的数据表，保存数据(入库)。
- 可以理解成是一种通用的设计和解决方案。
- 这个功能的业务相对比较繁琐，这个需要耐心。
先分析要提交的 json 数据
创建数据表-根据自己的业务设计[考虑前端的要求]
sql
USE hspliving_commodity
CREATE TABLE commodity_sku_info
(
sku_id BIGINT NOT NULL AUTO_INCREMENT COMMENT 'skuId',
spu_id BIGINT COMMENT 'spuId',
sku_name VARCHAR(255) COMMENT 'sku 名称',
sku_desc VARCHAR(2000) COMMENT 'sku 介绍描述',
catalog_id BIGINT COMMENT '所属分类 id',
brand_id BIGINT COMMENT '品牌 id',
sku_default_img VARCHAR(255) COMMENT '默认图片',
sku_title VARCHAR(255) COMMENT '标题',
sku_subtitle VARCHAR(2000) COMMENT '副标题',
price DECIMAL(18,4) COMMENT '价格',
sale_count BIGINT COMMENT '销量', PRIMARY KEY (sku_id)
)CHARSET=utf8mb4 COMMENT='sku 信息';
SELECT * FROM commodity_sku_info仍 然 使 用 renren-generator 逆 向 工 程 生 成 对 应 的 代 码 (CRUD)， 并 拷 贝 到
hspliving-commodity, 这个我们已经做过好几次了，请自己完成
java
package com.rainbowsea.rainbowsealiving.commodity.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuInfoEntity;
import java.util.Map;
/**
* sku 信息
*
* @author rainbowsea
* @email [email protected]
* @date 2025-03-24 22:01:45
*/
public interface SkuInfoService extends IService<SkuInfoEntity> {
PageUtils queryPage(Map<String, Object> params);
void saveSkuInfo(SkuInfoEntity skuInfoEntity);
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SkuInfoDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SkuInfoService;
@Service("skuInfoService")
public class SkuInfoServiceImpl extends ServiceImpl<SkuInfoDao, SkuInfoEntity> implements SkuInfoService {
@Override
public void saveSkuInfo(SkuInfoEntity skuInfoEntity) {
this.baseMapper.insert(skuInfoEntity);
}
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SkuInfoEntity> page = this.page(
new Query<SkuInfoEntity>().getPage(params),
new QueryWrapper<SkuInfoEntity>()
);
return new PageUtils(page);
}
}
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.rainbowsea.rainbowsealiving.commodity.entity.AttrEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.ProductAttrValueEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.AttrService;
import com.rainbowsea.rainbowsealiving.commodity.service.ProductAttrValueService;
import com.rainbowsea.rainbowsealiving.commodity.service.SkuInfoService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuImagesService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
import com.rainbowsea.rainbowsealiving.commodity.vo.BaseAttrs;
import com.rainbowsea.rainbowsealiving.commodity.vo.Images;
import com.rainbowsea.rainbowsealiving.commodity.vo.Skus;
import com.rainbowsea.rainbowsealiving.commodity.vo.SpuSaveVO;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuInfoDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service("spuInfoService")
public class SpuInfoServiceImpl extends ServiceImpl<SpuInfoDao, SpuInfoEntity> implements SpuInfoService {
@Resource
AttrService attrService;
@Resource
ProductAttrValueService productAttrValueService;
@Resource
SkuInfoService skuInfoService;
@Transactional
@Override
public void saveSpuInfo(SpuSaveVO spuSaveVO) {
//1、保存 spu 基本信息 , 对应的表 commodity_spu_info
SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
spuInfoEntity.setCreateTime(new Date());
spuInfoEntity.setUpdateTime(new Date());
//SpuInfoEntity 信息保存到 commodity_spu_info
this.saveBaseSpuInfo(spuInfoEntity);
//2、保存 Spu 的描述图片路径 commodity_spu_info_desc
List<String> decript = spuSaveVO.getDecript();
SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
//获取到刚刚保存的 spu 基本信息对应的 id
spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
//注意：这里有可能没有图片, 可以设置一个默认图片
if (decript.size() == 0) {
spuInfoDescEntity.setDecript("default.jpg");
} else {
spuInfoDescEntity.setDecript(String.join(",", decript));
}
//保存到 commodity_spu_info_desc, 这个方法时我们完成
spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//3、保存 spu 的图片集 commodity_spu_images
List<String> images = spuSaveVO.getImages();
//获取到刚刚保存的 spu 基本信息对应的 id
imagesService.saveImages(spuInfoEntity.getId(), images);
//4、保存 spu 的基本属性(一个 spu 可以有多个基本属性/规格参数):
// commodity_product_attr_value
List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
valueEntity.setAttrId(attr.getAttrId());
AttrEntity id = attrService.getById(attr.getAttrId());
valueEntity.setAttrName(id.getAttrName());
valueEntity.setAttrValue(attr.getAttrValues());
valueEntity.setQuickShow(attr.getShowDesc());
valueEntity.setSpuId(spuInfoEntity.getId());
return valueEntity;
}).collect(Collectors.toList());
productAttrValueService.saveProductAttr(collect);
//5、保存当前 spu 对应的所有 sku 信息；一个 spu 可以 对应多个 sku,
// 组成一个可以销售的商品信息
//注意 Images 类在 vo 包下, 确保有@Data 修饰
List<Skus> skus = spuSaveVO.getSkus();
if(skus!=null && skus.size()>0){
skus.forEach(item->{
String defaultImg = "default.jpg";
//json 会提交很多图片，如果是当前这个 sku 的默认图片就先保存下 url
for (Images image : item.getImages()) {
if(image.getDefaultImg() == 1){
defaultImg = image.getImgUrl();
}
}
SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
//把 item 中的信息拷贝给 skuInfoEntity
BeanUtils.copyProperties(item,skuInfoEntity);
//item 中没有信息，但是 skuInfoEntity 需要的信息，
//可以从 spuInfoEntity 中获取
skuInfoEntity.setBrandId(spuInfoEntity.getBrandId());
skuInfoEntity.setCatalogId(spuInfoEntity.getCatalogId());
skuInfoEntity.setSaleCount(0L);//初始化销量为 0
skuInfoEntity.setSpuId(spuInfoEntity.getId());
skuInfoEntity.setSkuDefaultImg(defaultImg);
//1)、保存 sku 的基本信息；到 commodity_sku_info
skuInfoService.saveSkuInfo(skuInfoEntity);
});
}
}
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
// //1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if (decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// } else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
////4、保存 spu 的基本属性(一个 spu 可以有多个基本属性/规格参数):
//// commodity_product_attr_value
// List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
// List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
// ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
// valueEntity.setAttrId(attr.getAttrId());
// AttrEntity id = attrService.getById(attr.getAttrId());
// valueEntity.setAttrName(id.getAttrName());
// valueEntity.setAttrValue(attr.getAttrValues());
// valueEntity.setQuickShow(attr.getShowDesc());
// valueEntity.setSpuId(spuInfoEntity.getId());
// return valueEntity;
// }).collect(Collectors.toList());
// productAttrValueService.saveProductAttr(collect);
// }
@Resource
SpuImagesService imagesService;
@Resource
SpuInfoDescService spuInfoDescService;
//因为有多个添加操作，使用事务控制
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if(decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// }else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
// }
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SpuInfoEntity> page = this.page(
new Query<SpuInfoEntity>().getPage(params),
new QueryWrapper<SpuInfoEntity>()
);
return new PageUtils(page);
}
/**
* 保存 spu 的基本信息到 commodity_spu_info
* @param spuInfoEntity
*/
@Override
public void saveBaseSpuInfo(SpuInfoEntity spuInfoEntity) {
this.baseMapper.insert(spuInfoEntity);
}
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////2. 将 SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
// }
}保存 spu 和 sku 的 图片信息
可 以 添 加 spu 和 sku 图 片 信 息 保 存 到 了 对 应 的 表 中 , 比 如 :
commodity_sku_images(一步一步来)
完成功能**:**** 只测试是否可以添加 spu 的基本信息到 ****commodity_spu_info (**一步一步来****),
提示****: 如果运行过程中, 提示找不到 VO, Rebuild Project 即可
sql
/*==============================================================*/
/* 1. 保存 某一个 sku 对应的图片[1 个 sku 可能有多个图片]
/*=====================================================*/
USE hspliving_commodity
CREATE TABLE commodity_sku_images
(
id BIGINT NOT NULL AUTO_INCREMENT COMMENT 'id',
sku_id BIGINT COMMENT 'sku_id',
img_url VARCHAR(255) COMMENT '图片地址',
img_sort INT COMMENT '排序',
default_img INT COMMENT '默认图[0 - 不是默认图，1 - 是默认图]',
PRIMARY KEY (id)
)CHARSET=utf8mb4 COMMENT='sku 图片';
SELECT * FROM commodity_sku_images
vue
<el-upload
action="http://hspliving-10000.oss-cn-beijing.aliyuncs.com"
:data="dataObj"
:list-type="listType"
:file-list="fileList"
:before-upload="beforeUpload"
:on-remove="handleRemove"
:on-success="handleUploadSuccess"
:on-preview="handlePreview"
:limit="maxCount"
:on-exceed="handleExceed"
:show-file-list="showFile"
>
<i class="el-icon-plus"></i>
</el-upload>
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.rainbowsea.rainbowsealiving.commodity.entity.AttrEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.ProductAttrValueEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuImagesEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.AttrService;
import com.rainbowsea.rainbowsealiving.commodity.service.ProductAttrValueService;
import com.rainbowsea.rainbowsealiving.commodity.service.SkuImagesService;
import com.rainbowsea.rainbowsealiving.commodity.service.SkuInfoService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuImagesService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
import com.rainbowsea.rainbowsealiving.commodity.vo.BaseAttrs;
import com.rainbowsea.rainbowsealiving.commodity.vo.Images;
import com.rainbowsea.rainbowsealiving.commodity.vo.Skus;
import com.rainbowsea.rainbowsealiving.commodity.vo.SpuSaveVO;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuInfoDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service("spuInfoService")
public class SpuInfoServiceImpl extends ServiceImpl<SpuInfoDao, SpuInfoEntity> implements SpuInfoService {
@Resource
AttrService attrService;
@Resource
ProductAttrValueService productAttrValueService;
@Resource
SkuInfoService skuInfoService;
@Resource
SkuImagesService skuImagesService;
@Resource
SpuImagesService imagesService;
@Resource
SpuInfoDescService spuInfoDescService;
@Transactional
@Override
public void saveSpuInfo(SpuSaveVO spuSaveVO) {
//1、保存 spu 基本信息 , 对应的表 commodity_spu_info
SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
spuInfoEntity.setCreateTime(new Date());
spuInfoEntity.setUpdateTime(new Date());
//SpuInfoEntity 信息保存到 commodity_spu_info
this.saveBaseSpuInfo(spuInfoEntity);
//2、保存 Spu 的描述图片路径 commodity_spu_info_desc
List<String> decript = spuSaveVO.getDecript();
SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
//获取到刚刚保存的 spu 基本信息对应的 id
spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
//注意：这里有可能没有图片, 可以设置一个默认图片
if (decript.size() == 0) {
spuInfoDescEntity.setDecript("default.jpg");
} else {
spuInfoDescEntity.setDecript(String.join(",", decript));
}
//保存到 commodity_spu_info_desc, 这个方法时我们完成
spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//3、保存 spu 的图片集 commodity_spu_images
List<String> images = spuSaveVO.getImages();
//获取到刚刚保存的 spu 基本信息对应的 id
imagesService.saveImages(spuInfoEntity.getId(), images);
//4 、 保 存 spu 的 基 本 属 性 ( 一 个 spu 可 以 有 多 个 基 本 属 性 / 规 格 参 数 ):commodity_product_attr_value
List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
valueEntity.setAttrId(attr.getAttrId());
AttrEntity id = attrService.getById(attr.getAttrId());
valueEntity.setAttrName(id.getAttrName());
valueEntity.setAttrValue(attr.getAttrValues());
valueEntity.setQuickShow(attr.getShowDesc());
valueEntity.setSpuId(spuInfoEntity.getId());
return valueEntity;
}).collect(Collectors.toList());
productAttrValueService.saveProductAttr(collect);
//5、保存当前 spu 对应的所有 sku 信息；一个 spu 可以 对应多个 sku, 组成一个可以销售的商品信息.
List<Skus> skus = spuSaveVO.getSkus();
if (skus != null && skus.size() > 0) {
skus.forEach(item -> {
String defaultImg = "default.jpg";
//json 会提交很多图片，如果是当前这个 sku 的默认图片就先保存下 url
for (Images image : item.getImages()) {
if (image.getDefaultImg() == 1) {
defaultImg = image.getImgUrl();
}
}
//保存 sku 的基本信息；到 commodity_sku_info start
SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
//把 item 中的信息拷贝给 skuInfoEntity
BeanUtils.copyProperties(item, skuInfoEntity);
//item 中没有信息，但是 skuInfoEntity 需要的信息，可以从 spuInfoEntity 中获取
skuInfoEntity.setBrandId(spuInfoEntity.getBrandId());
skuInfoEntity.setCatalogId(spuInfoEntity.getCatalogId());
skuInfoEntity.setSaleCount(0L);//初始化销量为 0
skuInfoEntity.setSpuId(spuInfoEntity.getId());
skuInfoEntity.setSkuDefaultImg(defaultImg);
skuInfoService.saveSkuInfo(skuInfoEntity);
//保存 sku 的基本信息；到 commodity_sku_info end
//保存 sku 的图片信息；到 commodity_sku_images start
//一个 sku 可以有多张图片
Long skuId = skuInfoEntity.getSkuId();
List<SkuImagesEntity> imagesEntities =
item.getImages().stream().map(img -> {
//取出当前 item (就是一个 spk)的信息，组装成 一个 SkuImagesEntity, 进行保存
SkuImagesEntity skuImagesEntity = new SkuImagesEntity();
skuImagesEntity.setSkuId(skuId);
skuImagesEntity.setImgUrl(img.getImgUrl());
skuImagesEntity.setDefaultImg(img.getDefaultImg());
return skuImagesEntity;
}).filter(entity -> {
//如果 image 为 empty ,就不过滤掉, 返回 true 就是需要，false 就是剔除
return !StringUtils.isEmpty(entity.getImgUrl());
}).collect(Collectors.toList());
skuImagesService.saveBatch(imagesEntities);
//保存 sku 的图片信息；到 commodity_sku_images end
});
}
}
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
// //1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if (decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// } else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
////4、保存 spu 的基本属性(一个 spu 可以有多个基本属性/规格参数):
//// commodity_product_attr_value
// List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
// List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
// ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
// valueEntity.setAttrId(attr.getAttrId());
// AttrEntity id = attrService.getById(attr.getAttrId());
// valueEntity.setAttrName(id.getAttrName());
// valueEntity.setAttrValue(attr.getAttrValues());
// valueEntity.setQuickShow(attr.getShowDesc());
// valueEntity.setSpuId(spuInfoEntity.getId());
// return valueEntity;
// }).collect(Collectors.toList());
// productAttrValueService.saveProductAttr(collect);
//
// //5、保存当前 spu 对应的所有 sku 信息；一个 spu 可以 对应多个 sku,
//// 组成一个可以销售的商品信息
////注意 Images 类在 vo 包下, 确保有@Data 修饰
// List<Skus> skus = spuSaveVO.getSkus();
// if(skus!=null && skus.size()>0){
// skus.forEach(item->{
// String defaultImg = "default.jpg";
////json 会提交很多图片，如果是当前这个 sku 的默认图片就先保存下 url
// for (Images image : item.getImages()) {
// if(image.getDefaultImg() == 1){
// defaultImg = image.getImgUrl();
// }
// }
// SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
////把 item 中的信息拷贝给 skuInfoEntity
// BeanUtils.copyProperties(item,skuInfoEntity);
////item 中没有信息，但是 skuInfoEntity 需要的信息，
////可以从 spuInfoEntity 中获取
// skuInfoEntity.setBrandId(spuInfoEntity.getBrandId());
// skuInfoEntity.setCatalogId(spuInfoEntity.getCatalogId());
// skuInfoEntity.setSaleCount(0L);//初始化销量为 0
// skuInfoEntity.setSpuId(spuInfoEntity.getId());
// skuInfoEntity.setSkuDefaultImg(defaultImg);
////1)、保存 sku 的基本信息；到 commodity_sku_info
// skuInfoService.saveSkuInfo(skuInfoEntity);
// });
// }
// }
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
// //1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if (decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// } else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
////4、保存 spu 的基本属性(一个 spu 可以有多个基本属性/规格参数):
//// commodity_product_attr_value
// List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
// List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
// ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
// valueEntity.setAttrId(attr.getAttrId());
// AttrEntity id = attrService.getById(attr.getAttrId());
// valueEntity.setAttrName(id.getAttrName());
// valueEntity.setAttrValue(attr.getAttrValues());
// valueEntity.setQuickShow(attr.getShowDesc());
// valueEntity.setSpuId(spuInfoEntity.getId());
// return valueEntity;
// }).collect(Collectors.toList());
// productAttrValueService.saveProductAttr(collect);
// }
//因为有多个添加操作，使用事务控制
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if(decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// }else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
// }
@Override
public PageUtils queryPage(Map<String, Object> params) {
IPage<SpuInfoEntity> page = this.page(
new Query<SpuInfoEntity>().getPage(params),
new QueryWrapper<SpuInfoEntity>()
);
return new PageUtils(page);
}
/**
* 保存 spu 的基本信息到 commodity_spu_info
*
* @param spuInfoEntity
*/
@Override
public void saveBaseSpuInfo(SpuInfoEntity spuInfoEntity) {
this.baseMapper.insert(spuInfoEntity);
}
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////2. 将 SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
// }
}
保存 sku 的销售属性
对照 JSON 数据分析
sql
# 创建保存 sku 的销售属性表
/*====================================================*/
/* 1.保存 sku 的销售属性/值, 一个 sku 可以有多个销售属性/值
/* 2.比如 1 个 sku 有颜色(黑色)和尺寸(100*300)两个销售属性
/*=====================================================*/
USE hspliving_commodity
CREATE TABLE commodity_sku_sale_attr_value
(
id BIGINT NOT NULL AUTO_INCREMENT COMMENT 'id',
sku_id BIGINT COMMENT 'sku_id',
attr_id BIGINT COMMENT 'attr_id',
attr_name VARCHAR(200) COMMENT '销售属性名',
attr_value VARCHAR(200) COMMENT '销售属性值',
attr_sort INT COMMENT '顺序', PRIMARY KEY (id)
)CHARSET=utf8mb4 COMMENT='sku 的销售属性/值表';
SELECT * FROM commodity_sku_sale_attr_value
java
package com.rainbowsea.rainbowsealiving.commodity.service.impl;
import com.rainbowsea.rainbowsealiving.commodity.entity.AttrEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.ProductAttrValueEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuImagesEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SkuSaleAttrValueEntity;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoDescEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.AttrService;
import com.rainbowsea.rainbowsealiving.commodity.service.ProductAttrValueService;
import com.rainbowsea.rainbowsealiving.commodity.service.SkuImagesService;
import com.rainbowsea.rainbowsealiving.commodity.service.SkuInfoService;
import com.rainbowsea.rainbowsealiving.commodity.service.SkuSaleAttrValueService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuImagesService;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoDescService;
import com.rainbowsea.rainbowsealiving.commodity.vo.Attr;
import com.rainbowsea.rainbowsealiving.commodity.vo.BaseAttrs;
import com.rainbowsea.rainbowsealiving.commodity.vo.Images;
import com.rainbowsea.rainbowsealiving.commodity.vo.Skus;
import com.rainbowsea.rainbowsealiving.commodity.vo.SpuSaveVO;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rainbowsea.common.utils.PageUtils;
import com.rainbowsea.common.utils.Query;
import com.rainbowsea.rainbowsealiving.commodity.dao.SpuInfoDao;
import com.rainbowsea.rainbowsealiving.commodity.entity.SpuInfoEntity;
import com.rainbowsea.rainbowsealiving.commodity.service.SpuInfoService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
@Service("spuInfoService")
public class SpuInfoServiceImpl extends ServiceImpl<SpuInfoDao, SpuInfoEntity> implements SpuInfoService {
@Resource
AttrService attrService;
@Resource
ProductAttrValueService productAttrValueService;
@Resource
SkuInfoService skuInfoService;
@Resource
SkuImagesService skuImagesService;
@Resource
SpuImagesService imagesService;
@Resource
SpuInfoDescService spuInfoDescService;
@Resource
SkuSaleAttrValueService skuSaleAttrValueService;
@Transactional
@Override
public void saveSpuInfo(SpuSaveVO spuSaveVO) {
//1、保存 spu 基本信息 , 对应的表 commodity_spu_info
SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
spuInfoEntity.setCreateTime(new Date());
spuInfoEntity.setUpdateTime(new Date());
//SpuInfoEntity 信息保存到 commodity_spu_info
this.saveBaseSpuInfo(spuInfoEntity);
//2、保存 Spu 的描述图片路径 commodity_spu_info_desc
List<String> decript = spuSaveVO.getDecript();
SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
//获取到刚刚保存的 spu 基本信息对应的 id
spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
//注意：这里有可能没有图片, 可以设置一个默认图片
if (decript.size() == 0) {
spuInfoDescEntity.setDecript("default.jpg");
} else {
spuInfoDescEntity.setDecript(String.join(",", decript));
}
//保存到 commodity_spu_info_desc, 这个方法时我们完成
spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//3、保存 spu 的图片集 commodity_spu_images
List<String> images = spuSaveVO.getImages();
//获取到刚刚保存的 spu 基本信息对应的 id
imagesService.saveImages(spuInfoEntity.getId(), images);
//4 、 保 存 spu 的 基 本 属 性 ( 一 个 spu 可 以 有 多 个 基 本 属 性 / 规 格 参 数 ):commodity_product_attr_value
List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
valueEntity.setAttrId(attr.getAttrId());
AttrEntity id = attrService.getById(attr.getAttrId());
valueEntity.setAttrName(id.getAttrName());
valueEntity.setAttrValue(attr.getAttrValues());
valueEntity.setQuickShow(attr.getShowDesc());
valueEntity.setSpuId(spuInfoEntity.getId());
return valueEntity;
}).collect(Collectors.toList());
productAttrValueService.saveProductAttr(collect);
//5、保存当前 spu 对应的所有 sku 信息；一个 spu 可以 对应多个 sku, 组成一个可以销售的商品信息
List<Skus> skus = spuSaveVO.getSkus();
if (skus != null && skus.size() > 0) {
skus.forEach(item -> {
String defaultImg = "default.jpg";
//json 会提交很多图片，如果是当前这个 sku 的默认图片就先保存下 url
for (Images image : item.getImages()) {
if (image.getDefaultImg() == 1) {
defaultImg = image.getImgUrl();
}
}
//保存 sku 的基本信息；到 commodity_sku_info start
SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
//把 item 中的信息拷贝给 skuInfoEntity
BeanUtils.copyProperties(item, skuInfoEntity);
//item 中没有信息，但是 skuInfoEntity 需要的信息，可以从 spuInfoEntity 中获取
skuInfoEntity.setBrandId(spuInfoEntity.getBrandId());
skuInfoEntity.setCatalogId(spuInfoEntity.getCatalogId());
skuInfoEntity.setSaleCount(0L);//初始化销量为 0
skuInfoEntity.setSpuId(spuInfoEntity.getId());
skuInfoEntity.setSkuDefaultImg(defaultImg);
skuInfoService.saveSkuInfo(skuInfoEntity);
//保存 sku 的基本信息；到 commodity_sku_info end
//保存 sku 的图片信息；到 commodity_sku_images start
//一个 sku 可以有多张图片
Long skuId = skuInfoEntity.getSkuId();
List<SkuImagesEntity> imagesEntities = item.getImages().stream().map(img ->
{
//取出当前 item (就是一个 spk)的信息，组装成 一个 SkuImagesEntity, 进行保存
SkuImagesEntity skuImagesEntity = new SkuImagesEntity();
skuImagesEntity.setSkuId(skuId);
skuImagesEntity.setImgUrl(img.getImgUrl());
skuImagesEntity.setDefaultImg(img.getDefaultImg());
return skuImagesEntity;
}).filter(entity -> {
//如果 image 为 empty ,就不过滤掉, 返回 true 就是需要，false 就是剔除
return !StringUtils.isEmpty(entity.getImgUrl());
}).collect(Collectors.toList());
skuImagesService.saveBatch(imagesEntities);
//保存 sku 的图片信息；到 commodity_sku_images end
//保存 sku 的销售属性-值到 commodity_sku_sale_attr_value start
List<Attr> attr = item.getAttr();
List<SkuSaleAttrValueEntity> skuSaleAttrValueEntities =
attr.stream().map(a -> {
SkuSaleAttrValueEntity attrValueEntity = new
SkuSaleAttrValueEntity();
BeanUtils.copyProperties(a, attrValueEntity);
attrValueEntity.setSkuId(skuId);
return attrValueEntity;
}).collect(Collectors.toList());
skuSaleAttrValueService.saveBatch(skuSaleAttrValueEntities);
//保存 sku 的销售属性-值到 commodity_sku_sale_attr_value end
});
}
}
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
// //1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if (decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// } else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
////4 、 保 存 spu 的 基 本 属 性 ( 一 个 spu 可 以 有 多 个 基 本 属 性 / 规 格 参 数 ):commodity_product_attr_value
// List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
// List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
// ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
// valueEntity.setAttrId(attr.getAttrId());
// AttrEntity id = attrService.getById(attr.getAttrId());
// valueEntity.setAttrName(id.getAttrName());
// valueEntity.setAttrValue(attr.getAttrValues());
// valueEntity.setQuickShow(attr.getShowDesc());
// valueEntity.setSpuId(spuInfoEntity.getId());
// return valueEntity;
// }).collect(Collectors.toList());
// productAttrValueService.saveProductAttr(collect);
//
// //5、保存当前 spu 对应的所有 sku 信息；一个 spu 可以 对应多个 sku, 组成一个可以销售的商品信息.
// List<Skus> skus = spuSaveVO.getSkus();
// if (skus != null && skus.size() > 0) {
// skus.forEach(item -> {
// String defaultImg = "default.jpg";
////json 会提交很多图片，如果是当前这个 sku 的默认图片就先保存下 url
// for (Images image : item.getImages()) {
// if (image.getDefaultImg() == 1) {
// defaultImg = image.getImgUrl();
// }
// }
////保存 sku 的基本信息；到 commodity_sku_info start
// SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
////把 item 中的信息拷贝给 skuInfoEntity
// BeanUtils.copyProperties(item, skuInfoEntity);
////item 中没有信息，但是 skuInfoEntity 需要的信息，可以从 spuInfoEntity 中获取
// skuInfoEntity.setBrandId(spuInfoEntity.getBrandId());
// skuInfoEntity.setCatalogId(spuInfoEntity.getCatalogId());
// skuInfoEntity.setSaleCount(0L);//初始化销量为 0
// skuInfoEntity.setSpuId(spuInfoEntity.getId());
// skuInfoEntity.setSkuDefaultImg(defaultImg);
// skuInfoService.saveSkuInfo(skuInfoEntity);
////保存 sku 的基本信息；到 commodity_sku_info end
////保存 sku 的图片信息；到 commodity_sku_images start
////一个 sku 可以有多张图片
// Long skuId = skuInfoEntity.getSkuId();
// List<SkuImagesEntity> imagesEntities =
// item.getImages().stream().map(img -> {
////取出当前 item (就是一个 spk)的信息，组装成 一个 SkuImagesEntity, 进行保存
//
// SkuImagesEntity skuImagesEntity = new SkuImagesEntity();
// skuImagesEntity.setSkuId(skuId);
// skuImagesEntity.setImgUrl(img.getImgUrl());
// skuImagesEntity.setDefaultImg(img.getDefaultImg());
// return skuImagesEntity;
// }).filter(entity -> {
////如果 image 为 empty ,就不过滤掉, 返回 true 就是需要，false 就是剔除
// return !StringUtils.isEmpty(entity.getImgUrl());
// }).collect(Collectors.toList());
// skuImagesService.saveBatch(imagesEntities);
////保存 sku 的图片信息；到 commodity_sku_images end
// });
// }
// }
//
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
// //1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if (decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// } else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
////4、保存 spu 的基本属性(一个 spu 可以有多个基本属性/规格参数):
//// commodity_product_attr_value
// List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
// List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
// ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
// valueEntity.setAttrId(attr.getAttrId());
// AttrEntity id = attrService.getById(attr.getAttrId());
// valueEntity.setAttrName(id.getAttrName());
// valueEntity.setAttrValue(attr.getAttrValues());
// valueEntity.setQuickShow(attr.getShowDesc());
// valueEntity.setSpuId(spuInfoEntity.getId());
// return valueEntity;
// }).collect(Collectors.toList());
// productAttrValueService.saveProductAttr(collect);
//
// //5、保存当前 spu 对应的所有 sku 信息；一个 spu 可以 对应多个 sku,
//// 组成一个可以销售的商品信息
////注意 Images 类在 vo 包下, 确保有@Data 修饰
// List<Skus> skus = spuSaveVO.getSkus();
// if(skus!=null && skus.size()>0){
// skus.forEach(item->{
// String defaultImg = "default.jpg";
////json 会提交很多图片，如果是当前这个 sku 的默认图片就先保存下 url
// for (Images image : item.getImages()) {
// if(image.getDefaultImg() == 1){
// defaultImg = image.getImgUrl();
// }
// }
// SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
////把 item 中的信息拷贝给 skuInfoEntity
// BeanUtils.copyProperties(item,skuInfoEntity);
////item 中没有信息，但是 skuInfoEntity 需要的信息，
////可以从 spuInfoEntity 中获取
// skuInfoEntity.setBrandId(spuInfoEntity.getBrandId());
// skuInfoEntity.setCatalogId(spuInfoEntity.getCatalogId());
// skuInfoEntity.setSaleCount(0L);//初始化销量为 0
// skuInfoEntity.setSpuId(spuInfoEntity.getId());
// skuInfoEntity.setSkuDefaultImg(defaultImg);
////1)、保存 sku 的基本信息；到 commodity_sku_info
// skuInfoService.saveSkuInfo(skuInfoEntity);
// });
// }
// }
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
// //1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO, spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if (decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// } else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
////4、保存 spu 的基本属性(一个 spu 可以有多个基本属性/规格参数):
//// commodity_product_attr_value
// List<BaseAttrs> baseAttrs = spuSaveVO.getBaseAttrs();
// List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
// ProductAttrValueEntity valueEntity = new ProductAttrValueEntity();
// valueEntity.setAttrId(attr.getAttrId());
// AttrEntity id = attrService.getById(attr.getAttrId());
// valueEntity.setAttrName(id.getAttrName());
// valueEntity.setAttrValue(attr.getAttrValues());
// valueEntity.setQuickShow(attr.getShowDesc());
// valueEntity.setSpuId(spuInfoEntity.getId());
// return valueEntity;
// }).collect(Collectors.toList());
// productAttrValueService.saveProductAttr(collect);
// }
//因为有多个添加操作，使用事务控制
// @Transactional
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
////2、保存 Spu 的描述图片路径 commodity_spu_info_desc
// List<String> decript = spuSaveVO.getDecript();
// SpuInfoDescEntity spuInfoDescEntity = new SpuInfoDescEntity();
////获取到刚刚保存的 spu 基本信息对应的 id
// spuInfoDescEntity.setSpuId(spuInfoEntity.getId());
////注意：这里有可能没有图片, 可以设置一个默认图片
// if(decript.size() == 0) {
// spuInfoDescEntity.setDecript("default.jpg");
// }else {
// spuInfoDescEntity.setDecript(String.join(",", decript));
// }
////保存到 commodity_spu_info_desc, 这个方法时我们完成
// spuInfoDescService.saveSpuInfoDesc(spuInfoDescEntity);
//
// //3、保存 spu 的图片集 commodity_spu_images
// List<String> images = spuSaveVO.getImages();
////获取到刚刚保存的 spu 基本信息对应的 id
// imagesService.saveImages(spuInfoEntity.getId(), images);
// }
@Override
public PageUtils queryPage (Map < String, Object > params){
IPage<SpuInfoEntity> page = this.page(
new Query<SpuInfoEntity>().getPage(params),
new QueryWrapper<SpuInfoEntity>()
);
return new PageUtils(page);
}
/**
* 保存 spu 的基本信息到 commodity_spu_info
*
* @param spuInfoEntity
*/
@Override
public void saveBaseSpuInfo (SpuInfoEntity spuInfoEntity){
this.baseMapper.insert(spuInfoEntity);
}
// @Override
// public void saveSpuInfo(SpuSaveVO spuSaveVO) {
////1、保存 spu 基本信息 , 对应的表 commodity_spu_info
// SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
// BeanUtils.copyProperties(spuSaveVO,spuInfoEntity);
// spuInfoEntity.setCreateTime(new Date());
// spuInfoEntity.setUpdateTime(new Date());
////2. 将 SpuInfoEntity 信息保存到 commodity_spu_info
// this.saveBaseSpuInfo(spuInfoEntity);
// }
}使用订阅发布功能的实现
因为要使用到订阅发布功能，所以我们需要做如下操作.
使用 npm 添加依赖：npm install --save pubsub-js(失败的话使用此命令：cnpm install --save pubsub-js)
shell
E:\Java\project\RainbowSealiving\renren-fast-vue>npm install --save pubsub-js