通用型产品发布解决方案(SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven)03

咖猫發表於 2025-4-29 11:10:00

通用型产品发布解决方案(SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven)03

<h1 id="通用型产品发布解决方案基于分布式微服务技术栈springbootspringcloudspring-cloudalibabavueelementuimybatis-plusmysqlgitmavenlinuxdockernginx---03">通用型产品发布解决方案(基于分布式微服务技术栈:SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven+Linux+Docker+Nginx - 《03》</h1>
<ul>
<li>GitHub：https://github.com/China-Rainbow-sea/RainbowSealiving</li>
<li>Gitee：https://gitee.com/Rainbow--Sea/rainbow-sealiving/tree/develop/</li>
</ul>
@<div class="toc"><div class="toc-container-header">目录</div><ul><li>通用型产品发布解决方案(基于分布式微服务技术栈:SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven+Linux+Docker+Nginx - 《03》</li><li>Mybatis-plus 分页插件</li><li>层级定位</li><li>前端搜索检索功能</li><li>关联表-而不是使用外键</li><li>BeanUtils 的使用</li><li>SPU 和 SKU 的概念和实现<ul><li>null</li><li>JSON 转换为 Java 实体类</li><li>保存 SKU 的图片信息表的设置</li><li>保存 SKU 的基本信息</li><li>保存 spu 和 sku 的图片信息</li></ul></li><li>使用订阅发布功能的实现</li></ul></div>
<h1 id="mybatis-plus-分页插件">Mybatis-plus 分页插件</h1>
补充：renren 的分页插件
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356731-1033249213.png">
<pre><code class="language-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);
}
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356762-1526549752.png">
<pre><code class="language-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);

}
</code></pre>
<pre><code class="language-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);

}
}
</code></pre>
打括号的查询提供，分组，括号查询
<pre><code class="language-java"> if (!StringUtils.isEmpty(key)) {
 wrapper.and((obj) -> {
 obj.eq("id", key).or().like("name", key);
 });
 }
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356764-1887397632.png">
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356687-425171668.png">
<pre><code class="language-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);

}
}
</code></pre>
<hr>
配置类(引入分页插件)
在对应项目，或者微服务当中的 config 配置目录下创建，MyB
atisConfig.java，MyBatis-plus 的分页插件的配置类
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356800-796639045.png">
<pre><code class="language-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;
}
}

</code></pre>
<hr>
<h1 id="层级定位">层级定位</h1>
可以省略
<h1 id="前端搜索检索功能">前端搜索检索功能</h1>
可以省略
<h1 id="关联表-而不是使用外键">关联表-而不是使用外键</h1>
写
<h1 id="beanutils-的使用">BeanUtils 的使用</h1>
<pre><code class="language-java">BeanUtils.copyProperties(test1,test2); // 将 test1对象属性拷贝大宋test2 当中
</code></pre>
<hr>
<h1 id="spu-和-sku-的概念和实现">SPU 和 SKU 的概念和实现</h1>
SPU 的概述
<ol>
<li>SPU((Stock keeping Unit)：标准化产品单元</li>
<li>用简单的话来说就是一类商品，比如：手机里的一种牌子，如：小米，苹果，都是一类。然后，加入具体的类型，如：小米 15，苹果 16 等等。那么它就是一个 spu</li>
</ol>
SKU 的概述：
<ol>
<li>SKU(Stock keeping Unit)：库存保有单位。</li>
<li>SKU 简单的来说就是在 spu 原有的基础上加入具体的类型，如(小米 15，白色，8+252G) 。组合起来就是一个完整地 SKU，所以 SKU 就是一类商品的各种样式的组合。</li>
<li>SKU 的组合会影响该商品的价格。</li>
</ol>


SPU 和 SKU 的关系：
<ol>
<li>SPU 和 SKU 就是上下级关系，没有 SPU 就没有 SKU，因为假如没有这一类商品，就没法谈这件商品具体的颜色尺寸。</li>
<li>如下图：假如没有选择任何类型那么他就是一个单独的 SPU，但是当它选择了具体的颜色，版本，购买方式等等，那么他就是一个 SKU。</li>
</ol>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356774-1425790932.png">
<blockquote>
<ul>
<li>保存商品spu 信息</li>
<li>1 个 spu 信息可能对于多个 sku</li>
<li>1 个 spu + 1 个 sku 就是一个商品的组合关系()</li>
</ul>
</blockquote>
<h2 id="_"></h2>
<h2 id="json-转换为-java-实体类">JSON 转换为 Java 实体类</h2>
写，特别的
P550
P564
<ol>
<li>当目前的实体类/对象，格式不能满足我们的需求时，可以使用上 VO<code>**ViewObject**</code>** 对象。VO 可以根据需求组合已有**的实体类的字段，或者增加，或者删除一些字段。</li>
<li>如果返回的 JSON 数据的当前实体类，不能满足需求，则定义一个 VO(View Object) 对象，在该对象，可以根据需求组合实体类字段，或者增加，或者删除一些字段。</li>
</ol>
<pre><code class="language-vue">submitSkus() {
console.log("要提交保存的商品信息(spu=) " , JSON.stringify(this.spu)); //将 json 对象转
成字符串输出
this.$confirm("将要提交商品数据, 是否继续?", "提示", {
confirmButtonText: "确定", cancelButtonText: "取消",
type: "warning"
})//其它
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356796-115366297.png">
<pre><code class="language-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: "已取消"
 });
 });
},
</code></pre>
分析一个 JSON 格式内容，将 console 输出的 json 字符串，格式化一下好看: https://www.json.cn/
为了能够在服务端接收提交的数据，我们使用 json 在线工具，转成 entity 对象(实际是一组)，作为 VO实体类。
<ol>
<li>点击 JSON 生成 Java 实体</li>
<li>把 console 输出的 JSON 字符串拷贝到左侧。</li>
</ol>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356757-2057306710.png">
<ol start="3">
<li>指定类名，包名，点击生成即可。</li>
</ol>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356688-686976416.png">
把生成好的 VO 实体类(我已经改好了, 可以直接使用(在资料文件夹))
注意：编写对应的 Cotroller 当中的编码信息。
分析一下 json 格式内容 ,将 console 输出的 json 字符串，格式化一下好看 https://www.json.cn/
<ul>
<li>为了能够在服务端接收提交的数据，我们使用 json 在线工具，转成 entity 对象(实际是一组),作为 VO 实体类</li>
<li>点击 JSON生成 JAVA 实体</li>
</ul>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356688-752164811.png"> <img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356782-197582656.png">
对生成好的 VO 实体类进行简化和定制，比如 int 改成 Long , double 改成 BigDecimal 
这样更符合我们的要求, 我已经改好了, 可以直接使用(在资料文件夹)，并增加了两个 VO 
类 , Images.java 和 MemberPrice.java, 直接替换一下即可
<ol>
<li>增加 Images.java 和 MemberPrice.java</li>
<li>修改 int —> long，double ——>BigDecimal</li>
<li>使用 <code>@Data 注解 </code> 简化 entity 类</li>
</ol>
梳理 VO 实体类和提交的 Json 数据关系
<blockquote>
<ul>
<li>保存商品spu 信息</li>
<li>1 个 spu 信息可能对于多个 sku</li>
<li>1 个 spu + 1 个 sku 就是一个商品的组合关系()</li>
</ul>
</blockquote>
保存商品信息，涉及到的表非常多，不是一个 SpulnfoEntityh 实体类能包括的，将 SpulnfoEntity 改成我们前面生成的 SpuSaveVo 包含了 JSON 提交所有信息。
我们这里是通过一个定制的方法saveSpulnfo 来完成。
<h2 id="保存-sku-的图片信息表的设置">保存 SKU 的图片信息表的设置</h2>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356763-299826758.png">
<pre><code class="language-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 rainbowsea@gmail.com
* @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;

}

</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356709-1832434594.png">
<pre><code class="language-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 rainbowsea@gmail.com
* @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);
}

</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356773-2049434588.png">
<pre><code class="language-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);
}

}
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356785-684603115.png">
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356769-1219656143.png">
<pre><code class="language-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 rainbowsea@gmail.com
* @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();
}

}

</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356785-88240741.png">
<pre><code class="language-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);
// }

}
</code></pre>
完成功能说明: 提示: 这里我们先暂时不选择图片, 主要测试保存默认图片信息 
是否能记录到 commodity_spu_images 表(后面操作批量保存图片到阿里云)
保存到阿里云操作：具体代码实现：
<pre><code class="language-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
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356774-1345910416.png">
<pre><code class="language-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);
}

}
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356784-147880939.png">
<pre><code class="language-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 rainbowsea@gmail.com
* @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);
}

</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356781-44392436.png">
<pre><code class="language-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);
}

}
</code></pre>
保存 spu 的基本属性/规格参数
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356791-898020507.png">
创建保存 spu 的基本属性/规格参数的表
<pre><code class="language-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 基本属性值';
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356771-1164610937.png">
<pre><code class="language-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 rainbowsea@gmail.com
* @date 2025-03-24 21:40:59
*/
public interface ProductAttrValueService extends IService<ProductAttrValueEntity> {

PageUtils queryPage(Map<String, Object> params);

void saveProductAttr(List<ProductAttrValueEntity> collect);
}

</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356780-332635279.png">
<pre><code class="language-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 rainbowsea@gmail.com
* @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;

}

</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356763-1297180641.png">
<pre><code class="language-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);
}

}
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356785-2098595842.png">
<pre><code class="language-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);
// }

}
</code></pre>
<h2 id="保存-sku-的基本信息">保存 SKU 的基本信息</h2>
完成保存商品信息功能-有难度-比较综合-涉及解决方案
解决方案分析：
<ol>
<li>因为在保存商品信息时，涉及到的信息很多。</li>
<li>可以通过拆解，创建多个 VO 层的 JavaBean，将商品信息保存到对应的各个表中。</li>
<li>梳理下（重要！开发中，前端和后端是配合的，有时我们后端人员需要根据前端的业务需求来设计程序）</li>
</ol>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356686-1394195826.png"> 整理上面的图：
分析前端发送的 JSON(很复杂)—> 创建 VO 对象/类(多个，可能还有组合/包含关系)——> 创建对应的数据表，保存数据(入库)。
<ul>
<li>可以理解成是一种通用的设计和解决方案。</li>
<li>这个功能的业务相对比较繁琐，这个需要耐心。</li>
</ul>
先分析要提交的 json 数据
创建数据表-根据自己的业务设计[考虑前端的要求] 
<pre><code class="language-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
</code></pre>
仍然使用 renren-generator 逆向工程生成对应的代码 (CRUD) ，并拷贝到 
hspliving-commodity, 这个我们已经做过好几次了，请自己完成
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356770-818293802.png">
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356720-427605013.png">
<pre><code class="language-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 rainbowsea@gmail.com
* @date 2025-03-24 22:01:45
*/
public interface SkuInfoService extends IService<SkuInfoEntity> {

PageUtils queryPage(Map<String, Object> params);

void saveSkuInfo(SkuInfoEntity skuInfoEntity);
}

</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356695-1253533507.png">
<pre><code class="language-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);
}

}
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356772-789099085.png">
<pre><code class="language-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);
// }

}
</code></pre>
<h2 id="保存-spu-和-sku-的-图片信息">保存 spu 和 sku 的图片信息</h2>
可以添加 spu 和 sku 图片信息保存到了对应的表中 , 比如 : 
commodity_sku_images(一步一步来)
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356757-1594462248.png">
完成功能: 只测试是否可以添加 spu 的基本信息到 commodity_spu_info (一步一步来****), 
提示****: 如果运行过程中, 提示找不到 VO, Rebuild Project 即可
<pre><code class="language-sql">/*==============================================================*/
/* 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 '默认图',
PRIMARY KEY (id)
)CHARSET=utf8mb4 COMMENT='sku 图片';
SELECT * FROM commodity_sku_images
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356756-431373970.png">
<pre><code class="language-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"
>
 
</el-upload>
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356711-697537046.png">
<pre><code class="language-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);
// }

}
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356730-177818897.png">
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356740-1025478629.png">
保存 sku 的销售属性
对照 JSON 数据分析

<pre><code class="language-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
</code></pre>
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356795-1446756936.png">
<pre><code class="language-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);
// }

}
</code></pre>
<h1 id="使用订阅发布功能的实现">使用订阅发布功能的实现</h1>
因为要使用到订阅发布功能，所以我们需要做如下操作. 
使用 npm 添加依赖：npm install --save pubsub-js(失败的话使用此命令：cnpm install --save pubsub-js)
<img src="https://img2024.cnblogs.com/blog/3084824/202504/3084824-20250429105356791-57403957.png">
<pre><code class="language-shell">E:\Java\project\RainbowSealiving\renren-fast-vue>npm install --save pubsub-js
</code></pre> 
来源：https://www.cnblogs.com/TheMagicalRainbowSea/p/18853323

頁: [1]

琼殿技术论坛's Archiver

通用型产品发布解决方案(SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven)03