通用型产品发布解决方案(SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven)03
通用型产品发布解决方案(基于分布式微服务技术栈:SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven+Linux+Docker+Nginx - 《03》
- GitHub：https://github.com/China-Rainbow-sea/RainbowSealiving
- Gitee：https://gitee.com/Rainbow--Sea/rainbow-sealiving/tree/develop/
@
目录
Mybatis-plus 分页插件
补充：renren 的分页插件
/**
* 列表
* 说明:
* 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);
}
/**
* 增加根据家居分类(第三级的)+查询条件+分页 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);
}
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);
}
}
打括号的查询提供，分组，括号查询
if (!StringUtils.isEmpty(key)) {
wrapper.and((obj) -> {
obj.eq("id", key).or().like("name", key);
});
}
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 的分页插件的配置类
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 的使用
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) 对象，在该对象，可以根据需求组合实体类字段，或者增加，或者删除一些字段。
submitSkus() {
console.log("要提交保存的商品信息(spu=) " , JSON.stringify(this.spu)); //将 json 对象转
成字符串输出
this.$confirm("将要提交商品数据, 是否继续?", "提示", {
confirmButtonText: "确定", cancelButtonText: "取消",
type: "warning"
})//其它
<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 字符串，格式化一下好看: https://www.json.cn/
为了能够在服务端接收提交的数据，我们使用 json 在线工具，转成 entity 对象(实际是一组)，作为 VO实体类。
- 点击 JSON 生成 Java 实体
- 把 console 输出的 JSON 字符串拷贝到左侧。
- 指定类名，包名，点击生成即可。
把生成好的 VO 实体类(我已经改好了, 可以直接使用(在资料文件夹))
注意：编写对应的 Cotroller 当中的编码信息。
分 析 一 下 json 格 式 内 容 , 将 console 输 出 的 json 字 符 串 ， 格 式 化 一 下 好 看 https://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 的图片信息表的设置
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;
}
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);
}
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);
}
}
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();
}
}
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 表(后面操作批量保存图片到阿里云)
保存到阿里云操作：具体代码实现：
/*======================================================*/
/* 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
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);
}
}
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);
}
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 的基本属性/规格参数的表
/*====================================================*/
/* 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 基本属性值';
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);
}
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;
}
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);
}
}
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 数据
创建数据表-根据自己的业务设计[考虑前端的要求]
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, 这个我们已经做过好几次了，请自己完成
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);
}
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);
}
}
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 即可
/*==============================================================*/
/* 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
<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>
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 数据分析
# 创建保存 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
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)
E:\Java\project\RainbowSealiving\renren-fast-vue>npm install --save pubsub-js
通用型产品发布解决方案(SpringBoot+SpringCloud+Spring CloudAlibaba+Vue+ElementUI+MyBatis-Plus+MySQL+Git+Maven)03的更多相关文章
- spring boot + vue + element-ui全栈开发入门——基于Electron桌面应用开发
前言 Electron是由Github开发,用HTML,CSS和JavaScript来构建跨平台桌面应用程序的一个开源库. Electron通过将Chromium和Node.js合并到同一个运行时环 ...
- spring boot + vue + element-ui全栈开发入门——开篇
最近经常看到很多java程序员朋友还在使用Spring 3.x,Spring MVC(struts),JSP.jQuery等这样传统技术.其实,我并不认为这些传统技术不好,而我想表达的是,技术的新旧程 ...
- spring boot + vue + element-ui全栈开发入门
今天想弄弄element-ui 然后就在网上找了个例子 感觉还是可以用的 第一步是完成了 果断 拿过来 放到我这里这 下面直接是连接 点进去 就可以用啊 本想着不用vue 直接导入连接 ...
- spring boot + vue + element-ui
spring boot + vue + element-ui 一.页面 1.布局 假设,我们要开发一个会员列表的页面. 首先,添加vue页面文件“src\pages\Member.vue” 参照文档h ...
- Spring，Struts2，MyBatis，Activiti，Maven，H2，Tomcat集成（三）——H2，MyBatis集成
1.配置h2,连接池,MyBatis Maven依赖: <!-- spring与数据库访问集成(非Hibernate) --> <dependency> <groupId ...
- springBoot整合spring、springMVC、mybatis
前文 1.为什么使用springBoot 众所周知,spring是Java在搭建后台时非常实用的框架,其整合了市场上几乎所有的主流框架于一体,使后端编程更加高效.快速: 而SpringBoot更是把s ...
- 一文搞定Spring Boot + Vue 项目在Linux Mysql环境的部署（强烈建议收藏）
本文介绍Spring Boot.Vue .Vue Element编写的项目,在Linux下的部署,系统采用Mysql数据库.按照本文进行项目部署,不迷路. 1. 前言 典型的软件开发,经过" ...
- spring boot + vue + element-ui全栈开发入门——项目部署
前言 常用的部署方式有两种: 1.是把生成好的静态页面放到spring boot的static目录下,与打包后的spring boot项目一起发布,当spring boot运行起来后,自然而然就能访 ...
- Spring，Struts2，MyBatis，Activiti，Maven，H2，Tomcat集成（四）——Activiti集成
1.添加Activiti Maven依赖: <!-- ==============================activiti=========================== --&g ...
- Spring，Struts2，MyBatis，Activiti，Maven，H2，Tomcat集成（二）——Struts2集成
1. pom.xml文件添struts2依赖jar包: <!-- 与Struts2集成必须使用 --> <dependency> <groupId>org.spri ...
随机推荐
- Q：Linux符号连接的层数过多
创建符号链接的时候源文件一定要使用绝对路径,尤其是链接不在同一目录时候,用相对路径会出现这种bug,具体是红色闪烁状态.:正常应该是青绿色 例如: 安装zabbix_agent遇到的问题,在root ...
- P3092 [USACO13NOV] No Change G 题解
传送门 题解 思路 看到 \(1\le k\le16\),我们想到状压DP. 以每枚硬币是否被使用为状态,对其进行枚举. 令 \(dp_i\) 表示状态 \(i\) 下最多能支付到第 \(dp_i\) ...
- 本地部署DeepSeek后，没有好看的交互界面怎么行！
大家好,我是晓凡. 写在前面 在前面的文章中手摸手的带小伙伴们在本地部署了DeepSeek.但是,部署完之后,我们要与之交互,只能在命令行中进行. 忘记怎么部署的小伙伴,来这儿复习一下~ 命令行交互如 ...
- ESP32-S3-WROOM-1-N16R8
ESP32-S3-WROOM-1-N16R8 基于立创实战派S3 参考链接:实战派开发板S3介绍 | 立创开发板技术文档中心 硬件和代码,(大部分图片)基于立创文档,在此基础上进行个人的学习记录和理解 ...
- UpdateHub-一款好看且免费开源的Windows软件更新检测工具
UpdateHub 是一款简化计算机上软件更新的应用程序.用户友好的界面允许您快速检查和安装操作系统和应用程序的可用更新. 通过这个应用,你可以快速地查看设备上安装的所有软件的更新,包括操作系统和应用 ...
- Java进阶 - [1-1] 六大设计原则
不要因为某本书而去读,而是因为这本书让你读起来时常有共鸣而去读. 一.单一职责原则 [术语]:SRP,Single Reposibility Principle [定义]:一个类或者模块只负责完成一个 ...
- MyCat分库分表-主从
一.MySQL数据同步 1.主节点配置,log-bin,指定文件名称 2.主节点配置server-id,默认为1 vim /etc/my.cof 在[mysqld]下添加如下配置 log-bin=im ...
- manim边学边做--向量相关的场景类
VectorScene是Manim动画库中专门用于向量空间可视化的场景类,继承自基础 Scene 类. 它通过封装一系列向量操作方法,使数学教育.物理模拟等领域的动画制作更加高效. 本文主要介绍Vec ...
- class com.ttsx.activity.item.dao.entity.RoleMenu ,Not found @TableId annotation, Cannot use Mybatis-Plus 'xxById' Method. 报错解决办法
启动项目的时候,有几条WARN警告,如图: 引起原因: 是因为数据表实体类 没有di导致的. 例如: 解决办法: 增加实体id字段!或可以忽略!不影响程序!
- Netty基础—4.NIO的使用简介
大纲 1.Buffer缓冲区 2.Channel通道 3.BIO编程 4.伪异步IO编程 5.改造程序以支持长连接 6.NIO三大核心组件 7.NIO服务端的创建流程 8.NIO客户端的创建流程 9. ...