商品服务功能开发
三级分类
导入数据pms_catelog.sql
要实现的功能：查出所有分类以及子分类，以树形结构组装起来
控制器：
/**
* 查出所有分类以及子分类，以树形结构组装起来
*/
@RequestMapping("/list/tree")
public R listWithTree(){
List<CategoryEntity> entities= categoryService.listWithTree();
return R.ok().put("data", entities);
}
逻辑：
@Override
public List<CategoryEntity> listWithTree() {
//1. 查出所有分类
List<CategoryEntity> entities = baseMapper.selectList(null);
//2, 组装成父子的树形结构 先找到所有的一级分类
List<CategoryEntity> level1Menu = entities.stream().filter(categoryEntity -> {
return categoryEntity.getParentCid().equals(0L);
}).map(menu -> {
menu.setChildren(getChildrens(menu, entities));
return menu;
}).sorted((menu1, menu2) -> {
return (menu1.getSort() == null ? 0 : menu1.getSort()) - (menu2.getSort() == null ? 0 : menu2.getSort());
}).collect(Collectors.toList());
return entities;
}
private List<CategoryEntity> getChildrens(CategoryEntity root, List<CategoryEntity> all) {
List<CategoryEntity> children = all.stream().filter(categoryEntity -> {
//找到所有的二级分类
return categoryEntity.getParentCid().equals(root.getCatId());
}).map(categoryEntity -> {
categoryEntity.setChildren(getChildrens(categoryEntity, all));
return categoryEntity;
}).sorted((menu1, menu2) -> {
return (menu1.getSort() == null ? 0 : menu1.getSort()) - (menu2.getSort() == null ? 0 : menu2.getSort());
}).collect(Collectors.toList());
return children;
}
运行结果：
前端开发：
添加一个菜单：
再添加一个分类维护菜单：
创建vue文件，路径需要和菜单路径匹配
这里会有跨域问题，参考跨域问题解决
接着编写分类管理：
先编写product模块的路由规则，注意要放在renrenfast上面，否则会先匹配到renrenfast模块
spring:
cloud:
gateway:
routes:
# - id: test_route
# uri: https://www.baidu.com
# predicates:
# - Query=url, baidu
#
# - id: qq_route
# uri: https://www.qq.com
# predicates:
# - Query=url, qq
- id: product_route # product模块
uri: lb://gulimall-product
predicates:
- Path=/api/product/**
filters:
- RewritePath=/api/(?<segment>.*), /$\{segment}
- id: admin_route # admin模块
uri: lb://renren-fast
predicates:
- Path=/api/**
filters:
- RewritePath=/api/(?<segment>.*), /renren-fast/$\{segment}
前端代码：
<template>
<div>
<h2>商品分类</h2>
<el-tree :data="menus" :props="defaultProps" @node-click="handleNodeClick"></el-tree>
</div>
</template>
<script>
export default {
name: "category",
data() {
return {
menus: [],
defaultProps: {
children: 'children',
label: 'name'
}
};
},
methods: {
handleNodeClick(data) {
console.log(data);
},
getMenus() {
this.$http({
url: this.$http.adornUrl('/product/category/list/tree'),
method: 'get',
}).then(res => {
const {data} = res //解构赋值 data 中 code data msg
this.menus = data.data
})
}
},
created() {
this.getMenus()
}
};
</script>
<style scoped lang="scss">
</style>
效果：
删除分类：
使用逻辑删除，需要配置mybatis-plus
mybatis-plus:
global-config:
db-config:
logic-delete-value: 1
logic-not-delete-value: 0
给categoryEntity类加上TableLogic字段：
上面配置的是全局，这里和上面刚好相反，可以主动配置value和delval
/**
* 是否显示[0-不显示，1显示]
*/
@TableLogic(value = "1", delval = "0")
private Integer showStatus;
拖拽节点，批量修改：
/**
* 批量修改
*/
@RequestMapping("/update/sort")
//@RequiresPermissions("product:category:update")
public R updateSort(@RequestBody CategoryEntity[] category){
categoryService.updateBatchById(Arrays.asList(category));
return R.ok();
}
品牌管理
新增品牌管理菜单：
之前逆向工程生成代码的时候已经生成了页面，可以直接复制过来：
此时页面已经存在增删改查功能：
发现没有增加功能，这是因为没有权限,先始终拥有权限即可
/**
* 是否有权限
* @param {*} key
*/
export function isAuth(key) {
// return JSON.parse(sessionStorage.getItem('permissions') || '[]').indexOf(key) !== -1 || false
return true;
}
商品属性
基本概念：
- SPU：Standard Product Unit（标准化产品单元）（如iPhone）
- SKU：Stock Keeping Unit（库存量单位）（如iPhone 64G，详细）
数据库设计
商品属性表：
create table pms_attr
(
attr_id bigint auto_increment comment '属性id' primary key,
attr_name char(30) null comment '属性名',
search_type tinyint null comment '是否需要检索[0-不需要，1-需要]',
value_type tinyint null comment '值类型[0-为单个值，1-可以选择多个值]',
icon varchar(255) null comment '属性图标',
value_select char(255) null comment '可选值列表[用逗号分隔]',
attr_type tinyint null comment '属性类型[0-销售属性，1-基本属性，2-既是销售属性又是基本属性]',
enable bigint null comment '启用状态[0 - 禁用，1 - 启用]',
catelog_id bigint null comment '所属分类',
show_desc tinyint null comment '快速展示【是否展示在介绍上；0-否 1-是】，在sku中仍然可以调整'
)comment '商品属性';
属性分组表：
create table pms_attr_group
(
attr_group_id bigint auto_increment comment '分组id' primary key,
attr_group_name char(20) null comment '组名',
sort int null comment '排序',
descript varchar(255) null comment '描述',
icon varchar(255) null comment '组图标',
catelog_id bigint null comment '所属分类id'
)comment '属性分组';
将上面两个表关联起来：
属性-分组-关联表：
create table pms_attr_attrgroup_relation
(
id bigint auto_increment comment 'id' primary key,
attr_id bigint null comment '属性id',
attr_group_id bigint null comment '属性分组id',
attr_sort int null comment '属性组内排序'
) comment '属性&属性分组关联';
如 这里的
基本信息就是分组表里的attr_group_name分组名字
机身颜色就是attr_name属性名字
商品属性值表，如上面的魅海蓝，其实也是一张关联表：
create table pms_product_attr_value
(
id bigint auto_increment comment 'id' primary key,
spu_id bigint null comment '商品id',
attr_id bigint null comment '属性id',
attr_name varchar(200) null comment '属性名',
attr_value varchar(200) null comment '属性值',
attr_sort int null comment '顺序',
quick_show tinyint null comment '快速展示【是否展示在介绍上；0-否 1-是】'
) comment 'spu属性值';
商品真正的信息，商品信息表：
create table pms_spu_info
(
id bigint auto_increment comment '商品id' primary key,
spu_name varchar(200) null comment '商品名称',
spu_description varchar(1000) null comment '商品描述',
catalog_id bigint null comment '所属分类id',
brand_id bigint null comment '品牌id',
weight decimal(18, 4) null,
publish_status tinyint null comment '上架状态[0 - 下架，1 - 上架]',
create_time datetime null,
update_time datetime null
) comment 'spu信息';
sku信息表：
create table pms_sku_info
(
sku_id bigint auto_increment comment 'skuId' primary key,
spu_id bigint null comment 'spuId',
sku_name varchar(255) null comment 'sku名称',
sku_desc varchar(2000) null comment 'sku介绍描述',
catalog_id bigint null comment '所属分类id',
brand_id bigint null comment '品牌id',
sku_default_img varchar(255) null comment '默认图片',
sku_title varchar(255) null comment '标题',
sku_subtitle varchar(2000) null comment '副标题',
price decimal(18, 4) null comment '价格',
sale_count bigint null comment '销量'
) comment 'sku信息';
如下图的标题，副标题等信息
sku图片表：
存不同种如手机等图片
create table pms_sku_images
(
id bigint auto_increment comment 'id' primary key,
sku_id bigint null comment 'sku_id',
img_url varchar(255) null comment '图片地址',
img_sort int null comment '排序',
default_img int null comment '默认图[0 - 不是默认图，1 - 是默认图]'
) comment 'sku图片';
颜色，128G，这些信息
存在sku销售属性表里面
create table pms_sku_sale_attr_value
(
id bigint auto_increment comment 'id' primary key,
sku_id bigint null comment 'sku_id',
attr_id bigint null comment 'attr_id',
attr_name varchar(200) null comment '销售属性名',
attr_value varchar(200) null comment '销售属性值',
attr_sort int null comment '顺序'
) comment 'sku销售属性&值';
整个关系如下：
前端页面，我们希望点击左侧的分类，在右侧能查出对应的内容，但是左边是一个子组件，因此我们需要用子组件给父组件传递数据
使用事件机制，类似于冒泡
子组件：
<el-tree :data="menus"
:props="defaultProps"
node-key="catId"
@node-click="modeClick"
ref="tree">
</el-tree>
modeClick(data,node,component){
console.log("子组件被点击",data,node,component)
//向父附件发送事件
this.$emit('tree-node-click',data,node,component)
},
使用
this.$emit来传递事件
在父组件中：
<category @tree-node-click="treeNodeClick"></category>
treeNodeClick(data, node, component) {
console.log("父组件感知", data, node, component)
console.log("被点击的菜单id", data.catId)
},
绑定这个事件
运行结果：
根据categoryId查询组
后端接口：
/**
* 列表
*/
@GetMapping("/list/{categoryId}")
//@RequiresPermissions("product:attrgroup:list")
public R listCategoryById(@RequestParam Map<String, Object> params,
@PathVariable("categoryId") Long categoryId) {
PageUtils page = attrGroupService.queryPage(params, categoryId);
return R.ok().put("page", page);
}
实现类：
@Override
public PageUtils queryPage(Map<String, Object> params, Long categoryId) {
//如果categoryId为0，则查询所有
if (categoryId == 0) {
IPage<AttrGroupEntity> page = this.page(
new Query<AttrGroupEntity>().getPage(params),
new QueryWrapper<AttrGroupEntity>()
);
return new PageUtils(page);
}
// select * from pms_attr_group where catelog_id = ? and (attr_group_id = ? or attr_group_name like %?%)
String key = (String) params.get("key");
LambdaQueryWrapper<AttrGroupEntity> wrapper = new LambdaQueryWrapper<AttrGroupEntity>();
wrapper.eq(AttrGroupEntity::getCatelogId, categoryId);
if (StringUtils.isNotEmpty(key)) {
wrapper.and((obj) -> {
obj.eq(AttrGroupEntity::getAttrGroupId, key)
.or()
.like(AttrGroupEntity::getAttrGroupName, key);
});
}
IPage<AttrGroupEntity> page = this.page(new Query<AttrGroupEntity>().getPage(params), wrapper);
return new PageUtils(page);
}
选择三级分类时：
原因在于三级之后的children为空：
因此我们要做到让这个字段为空的时候不展示给前端,给这个字段设置@JsonInclude(JsonInclude.Include.NON_EMPTY)：
@TableField(exist = false)
@JsonInclude(JsonInclude.Include.NON_EMPTY)
private List <CategoryEntity> children;
修改回显,由于后端返回数据的时候只有一个categoryId，而前端的三级分类是一个数组，因此需要修改后端：
/**
* 信息
*/
@RequestMapping("/info/{attrGroupId}")
//@RequiresPermissions("product:attrgroup:info")
public R info(@PathVariable("attrGroupId") Long attrGroupId) {
AttrGroupEntity attrGroup = attrGroupService.getById(attrGroupId);
Long catelogId = attrGroup.getCatelogId();
//查询完整路径
Long[] path = categoryService.findCatelogPath(catelogId);
attrGroup.setCatelogPath(path);
return R.ok().put("attrGroup", attrGroup);
}
业务逻辑：
@Override
public Long[] findCatelogPath(Long catelogId) {
List<Long> paths = new ArrayList<>();
List<Long> parentPath = findParentPath(catelogId, paths);
Collections.reverse(parentPath);
return parentPath.toArray(new Long[parentPath.size()]);
}
private List<Long> findParentPath(Long catelogId, List<Long> paths) {
paths.add(catelogId);
CategoryEntity categoryEntity = this.getById(catelogId);
if (categoryEntity.getParentCid() != 0) {
findParentPath(categoryEntity.getParentCid(), paths);
}
return paths;
}
MybatisPlus分页插件配置
package com.cxk.gulimall.product.config;
import com.baomidou.mybatisplus.annotation.DbType;
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.cxk.gulimall.product.dao")
public class MybatisConfig {
/**
* 添加分页插件
*/
@Bean
public PaginationInterceptor mybatisPlusInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
paginationInterceptor.setOverflow(true);
paginationInterceptor.setLimit(1000);
// 设置数据库类型为mysql
return paginationInterceptor;
}
}
品牌分类关联
品牌和分类是多对多的问题：
- 一个品牌可能属于多个分类
- 一个分类下面有多个品牌
create table pms_category_brand_relation
(
id bigint auto_increment primary key,
brand_id bigint null comment '品牌id',
catelog_id bigint null comment '分类id',
brand_name varchar(255) null,
catelog_name varchar(255) null
) comment '品牌分类关联';
多对多关系一般都有一张中间表，记录他们的关系，这里还设置了两个冗余字段，提高效率。
根据品牌id查询所有关联关系
/**
* 列表
*/
@GetMapping("/catelog/list")
//@RequiresPermissions("product:categorybrandrelation:list")
public R cateloglist(@RequestParam("brandId") Long brandId) {
LambdaQueryWrapper<CategoryBrandRelationEntity> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(CategoryBrandRelationEntity::getBrandId, brandId);
List<CategoryBrandRelationEntity> data = categoryBrandRelationService.list(wrapper);
return R.ok().put("data", data);
}
保存品牌和分类的关联关系：
@Override
public void saveDetail(CategoryBrandRelationEntity categoryBrandRelation) {
Long brandId = categoryBrandRelation.getBrandId();
Long catelogId = categoryBrandRelation.getCatelogId();
//查询详细名字
BrandEntity brandEntity = brandDao.selectById(brandId);
CategoryEntity categoryEntity = categoryDao.selectById(catelogId);
categoryBrandRelation.setBrandName(brandEntity.getName());
categoryBrandRelation.setCatelogName(categoryEntity.getName());
this.save(categoryBrandRelation);
}
但是这个冗余字段存在问题，就是当品牌名字或者分类名字变化的时候，这里的冗余字段也需要进行更改，因此还需要去修改代码
BrandServiceImpl中：
@Override
@Transactional
public void updateDetail(BrandEntity brand) {
//保证冗余字段的数据一致
this.updateById(brand);
if (StringUtils.isNotEmpty(brand.getName())) {
categoryBrandRelationService.updateBrand(brand.getBrandId(), brand.getName());
//TODO 更新其他关联
}
}
CategoryBrandRelationServiceImpl中
public void updateBrand(Long brandId, String name) {
CategoryBrandRelationEntity relationEntity = new CategoryBrandRelationEntity();
relationEntity.setBrandId(brandId);
relationEntity.setBrandName(name);
LambdaUpdateWrapper<CategoryBrandRelationEntity> wrapper = new LambdaUpdateWrapper<>();
wrapper.eq(CategoryBrandRelationEntity::getBrandId, brandId);
this.update(relationEntity, wrapper);
}
同理分类修改时,注意开启事务：
@Override
@Transactional
public void updateCascade(CategoryEntity category) {
this.updateById(category);
if (StringUtils.isNotEmpty(category.getName())) {
categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());
//TODO 同步更新其他关联表的数据
}
}
这里使用mapper做，学习不同的方式：
@Override
public void updateCategory(Long catId, String name) {
this.baseMapper.updateCategory(catId, name);
}
void updateCategory(@Param("catId") Long catId, @Param("name") String name);
<update id="updateCategory">
update pms_category_brand_relation
set catelog_name = #{name}
where catelog_id = #{catId}
</update>
商品属性
保存：
/**
* 保存
*/
@RequestMapping("/save")
//@RequiresPermissions("product:attr:save")
public R save(@RequestBody AttrVo attr){
attrService.saveAttr(attr);
return R.ok();
}
@Override
@Transactional
public void saveAttr(AttrVo attr) {
AttrEntity attrEntity = new AttrEntity();
BeanUtils.copyProperties(attr, attrEntity);
// 保 存基本数据
this.save(attrEntity);
// 保存关联关系
AttrAttrgroupRelationEntity entity = new AttrAttrgroupRelationEntity();
entity.setAttrGroupId(attr.getAttrGroupId());
entity.setAttrId(attrEntity.getAttrId());
relationDao.insert(entity);
}
关联查询属性分类和分组名称
定义响应类，
@Data
public class AttrRespVo extends AttrVo {
/**
* 所属分类名字
*/
private String catelogName;
/**
* 所属分组名字
*/
private String groupName;
}
查询代码：
@Override
public PageUtils queryBaseAttrPage(Map<String, Object> params, Long catelogId) {
LambdaQueryWrapper<AttrEntity> wrapper = new LambdaQueryWrapper<>();
if (catelogId != 0) {
wrapper.eq(AttrEntity::getCatelogId, catelogId);
}
String key = (String) params.get("key");
if (StringUtils.isNotEmpty(key)) {
wrapper.and((obj) -> {
obj.eq(AttrEntity::getAttrId, key).or().like(AttrEntity::getAttrName, key);
});
}
IPage<AttrEntity> page = this.page(
new Query<AttrEntity>().getPage(params),
wrapper
);
PageUtils pageUtils = new PageUtils(page);
List<AttrEntity> list = page.getRecords();
List<AttrRespVo> collect = list.stream().map(attrEntity -> {
AttrRespVo attrRespVo = new AttrRespVo();
BeanUtils.copyProperties(attrEntity, attrRespVo);
//设置分类和分组名字
//查询分类
CategoryEntity categoryEntity = categoryDao.selectById(attrEntity.getCatelogId());
if (categoryEntity != null) {
attrRespVo.setCatelogName(categoryEntity.getName());
}
//查询分组
AttrAttrgroupRelationEntity attrAttrgroupRelationEntity =
relationDao.selectOne(new LambdaQueryWrapper<AttrAttrgroupRelationEntity>()
.eq(AttrAttrgroupRelationEntity::getAttrId, attrEntity.getAttrId()));
if (attrAttrgroupRelationEntity != null) {
Long groupId = attrAttrgroupRelationEntity.getAttrGroupId();
AttrGroupEntity attrGroupEntity = attrGroupDao.selectById(groupId);
attrRespVo.setGroupName(attrGroupEntity.getAttrGroupName());
}
return attrRespVo;
}).collect(Collectors.toList());
pageUtils.setList(collect);
return pageUtils;
}
修改规格参数：
发现所属分类和分组无法回显
AttrRespVo类中添加catelogPath
@Data
public class AttrRespVo extends AttrVo {
/**
* 所属分类名字
*/
private String catelogName;
/**
* 所属分组名字
*/
private String groupName;
/**
* 分类完整路径
*/
private Long[] catelogPath;
}
@Override
public AttrRespVo getAttrInfo(Long attrId) {
AttrEntity attrEntity = this.getById(attrId);
AttrRespVo attrRespVo = new AttrRespVo();
BeanUtils.copyProperties(attrEntity, attrRespVo);
//还需要设置分组id和分类路径
// attrRespVo.setCatelogPath();
// attrRespVo.setAttrGroupId();
// attrRespVo.setCatelogName();
//1、设置分组信息
AttrAttrgroupRelationEntity relationEntity = relationDao.selectOne(
new LambdaQueryWrapper<AttrAttrgroupRelationEntity>()
.eq(AttrAttrgroupRelationEntity::getAttrId, attrId));
if (relationEntity != null) {
attrRespVo.setAttrGroupId(relationEntity.getAttrGroupId());
AttrGroupEntity attrGroupEntity = attrGroupDao.selectById(relationEntity.getAttrGroupId());
if (attrGroupEntity != null) {
attrRespVo.setGroupName(attrGroupEntity.getAttrGroupName());
}
}
//2、设置分类信息
Long catelogId = attrEntity.getCatelogId();
Long[] catelogPath = categoryService.findCatelogPath(catelogId);
attrRespVo.setCatelogPath(catelogPath);
CategoryEntity categoryEntity = categoryDao.selectById(catelogId);
if (categoryEntity != null) {
attrRespVo.setCatelogName(categoryEntity.getName());
}
return attrRespVo;
}
修改操作：
需要先判断是否存在
@Override
@Transactional
public void updateAttr(AttrVo attr) {
AttrEntity attrEntity = new AttrEntity();
BeanUtils.copyProperties(attr, attrEntity);
//修改基本数据
this.updateById(attrEntity);
AttrAttrgroupRelationEntity relationEntity = new AttrAttrgroupRelationEntity();
relationEntity.setAttrGroupId(attr.getAttrGroupId());
relationEntity.setAttrId(attrEntity.getAttrId());
//统计是否存在
Integer count = relationDao.selectCount(new LambdaQueryWrapper<AttrAttrgroupRelationEntity>()
.eq(AttrAttrgroupRelationEntity::getAttrId, attrEntity.getAttrId()));
if (count > 0) {
//修改关联关系
relationDao.update(relationEntity, new LambdaUpdateWrapper<AttrAttrgroupRelationEntity>()
.eq(AttrAttrgroupRelationEntity::getAttrId, attrEntity.getAttrId()));
} else {
//新增关联关系
relationDao.insert(relationEntity);
}
}
分组关联关系
@PostMapping("/attr/relation/delete")
public R deleteRelation(@RequestBody AttrGroupRelationVo[] vos) {
attrService.deleteRelation(vos);
return R.ok();
}
@Override
public void deleteRelation(AttrGroupRelationVo[] vos) {
List<AttrAttrgroupRelationEntity> entities = Arrays.asList(vos).stream().map((item) -> {
AttrAttrgroupRelationEntity entity = new AttrAttrgroupRelationEntity();
BeanUtils.copyProperties(item, entity);
return entity;
}).collect(Collectors.toList());
relationDao.deleteBatchRelation(entities);
}
void deleteBatchRelation(@Param("entities") List<AttrAttrgroupRelationEntity> entities);
<delete id="deleteBatchRelation">
delete
from gulimall_pms.pms_attr_attrgroup_relation
where
<foreach collection="entities" item="item" separator=" or ">
( attr_id =#{item.attrId} and attr_group_id =#{item.attrGroupId} )
</foreach>
</delete>
获取当前分组还没有关联的属性
一个属性只能被一个一个分组使用，
所以这里新建关联的时候查询的应该是当前分类的其他分组没有使用过的，以及自己没有用过的
@GetMapping("/{attrGroupId}/noattr/relation")
public R attrNoRelation(@PathVariable("attrGroupId") Long attrGroupId,
@RequestParam Map<String, Object> params) {
//获取当前分组没有关联的所有属性
PageUtils page = attrService.getNoRelationAttr(params,attrGroupId);
return R.ok().put("page", page);
}
@Override
public PageUtils getNoRelationAttr(Map<String, Object> params, Long attrGroupId) {
//当前分组只能关联自己所属分组里面的所有属性
AttrGroupEntity attrGroupEntity = attrGroupDao.selectById(attrGroupId);
//当前分类的id
Long catelogId = attrGroupEntity.getCatelogId();
//当前分组只能关联别的分组没有引用的属性
List<AttrGroupEntity> group = attrGroupDao.selectList(new LambdaQueryWrapper<AttrGroupEntity>()
.eq(AttrGroupEntity::getCatelogId, catelogId));
//所有的分组id
List<Long> collect = group.stream().map(AttrGroupEntity::getAttrGroupId).collect(Collectors.toList());
//这些分组的关联属性
List<AttrAttrgroupRelationEntity> groupId = relationDao.selectList(new LambdaQueryWrapper<AttrAttrgroupRelationEntity>()
.in(AttrAttrgroupRelationEntity::getAttrGroupId, collect));
List<Long> attrIds = groupId.stream().map((AttrAttrgroupRelationEntity::getAttrId)).collect(Collectors.toList());
//从当前分类的所有属性中移除这些属性
LambdaQueryWrapper<AttrEntity> wrapper = new LambdaQueryWrapper<AttrEntity>()
.eq(AttrEntity::getCatelogId, catelogId)
.eq(AttrEntity::getAttrType, ProductConstant.AttrEnum.ATTR_TYPE_BASE.getCode());
if (attrIds != null && attrIds.size() > 0) {
wrapper.notIn(AttrEntity::getAttrId, attrIds);
}
//模糊，分页查询
String key = (String) params.get("key");
if (StringUtils.isNotEmpty(key)) {
wrapper.and((obj) -> {
obj.eq(AttrEntity::getAttrId, key).or().like(AttrEntity::getAttrName, key);
});
}
IPage<AttrEntity> page = this.page(new Query<AttrEntity>().getPage(params), wrapper);
return new PageUtils(page);
}
新增商品
前端出现报错PubSub is not definded：
npm install --save pubsub-js
再新加一句话
同时下面删除this
查询指定分类里的所有品牌信息：
/**
*查询指定分类里的所有品牌信息
*/
@GetMapping("/brands/list")
public R relationBrandsList(@RequestParam(value = "catId") Long catId) {
List<BrandEntity> vos = categoryBrandRelationService.getBrandsByCatId(catId);
List<BrandVo> collect = vos.stream().map(item -> {
BrandVo brandVo = new BrandVo();
brandVo.setBrandId(item.getBrandId());
brandVo.setBrandName(item.getName());
return brandVo;
}).collect(Collectors.toList());
return R.ok().put("data", collect);
}
controller一共做三件事情：
- 处理请求，接受和校验数据
- service接受controller传来的数据，进行业务处理
- controller接受service处理完的数据，封装页面指定的vo
保存新增商品
/**
* 保存
*/
@RequestMapping("/save")
//@RequiresPermissions("product:spuinfo:save")
public R save(@RequestBody SpuSaveVo vo){
spuInfoService.saveSpuInfo(vo);
return R.ok();
}
业务逻辑：
@Override
@Transactional
public void saveSpuInfo(SpuSaveVo vo) {
//1.保存spu基本信息 pms_spu_info
SpuInfoEntity spuInfoEntity = new SpuInfoEntity();
BeanUtils.copyProperties(vo, spuInfoEntity);
spuInfoEntity.setCreateTime(new Date());
spuInfoEntity.setUpdateTime(new Date());
this.saveBaseSpInfo(spuInfoEntity);
//2.保存spu描述图片 pms_spu_info_desc
List<String> decript = vo.getDecript();
SpuInfoDescEntity descEntity = new SpuInfoDescEntity();
descEntity.setSpuId(spuInfoEntity.getId());
descEntity.setDecript(String.join(",", decript));
spuInfoDescService.saveSpuInfoDesc(descEntity);
//3.保存spu图片集 pms_spu_images
List<String> images = vo.getImages();
spuImagesService.saveImages(spuInfoEntity.getId(), images);
//4.保存spu规格参数 pms_product_attr_value
List<BaseAttrs> baseAttrs = vo.getBaseAttrs();
List<ProductAttrValueEntity> collect = baseAttrs.stream().map(attr -> {
ProductAttrValueEntity entity = new ProductAttrValueEntity();
entity.setSpuId(spuInfoEntity.getId());
entity.setAttrId(attr.getAttrId());
AttrEntity attrEntity = attrService.getById(attr.getAttrId());
entity.setAttrName(attrEntity.getAttrName());
entity.setAttrValue(attr.getAttrValues());
entity.setQuickShow(attr.getShowDesc());
return entity;
}).collect(Collectors.toList());
productAttrValueService.saveProductAttr(collect);
//5.保存spu的积分信息 gulimall_sms->sms_spu_bounds
Bounds bounds = vo.getBounds();
SpuBoundTo spuBoundTo = new SpuBoundTo();
BeanUtils.copyProperties(bounds, spuBoundTo);
spuBoundTo.setSpuId(spuInfoEntity.getId());
//todo 调用远程服务
R r = couponFeignService.saveSpuBounds(spuBoundTo);
if (r.getCode() != 0) {
log.error("远程保存spu积分信息失败");
}
//5.保存当前spu对应的所有sku信息 pms_sku_info
List<Skus> skus = vo.getSkus();
if (skus != null && skus.size() > 0) {
skus.forEach(item -> {
String defaultImage = "";
for (Images image : item.getImages()) {
if (image.getDefaultImg() == 1) {
defaultImage = image.getImgUrl();
}
}
SkuInfoEntity entity = new SkuInfoEntity();
BeanUtils.copyProperties(item, entity);
entity.setSpuId(spuInfoEntity.getId());
//todo sku介绍描述 skuDesc
entity.setCatalogId(spuInfoEntity.getCatalogId());
entity.setBrandId(spuInfoEntity.getBrandId());
entity.setSkuDefaultImg(defaultImage);
//todo saleCount
//5.1 sku基本信息 pms_sku_info
skuInfoService.saveSkuInfo(entity);
List<SkuImagesEntity> skuImagesEntities = item.getImages().stream().map(img -> {
SkuImagesEntity skuImagesEntity = new SkuImagesEntity();
skuImagesEntity.setSkuId(entity.getSkuId());
skuImagesEntity.setImgUrl(img.getImgUrl());
skuImagesEntity.setDefaultImg(img.getDefaultImg());
return skuImagesEntity;
}).filter(entity2 -> {
return StringUtils.isNotEmpty(entity2.getImgUrl());
}).collect(Collectors.toList());
//5.2 sku的图片信息 pms_sku_images
skuImagesService.saveBatch(skuImagesEntities);
//5.3 sku的销售属性信息 pms_sku_sale_attr_value
List<Attr> attr = item.getAttr();
List<SkuSaleAttrValueEntity> collect1 = attr.stream().map(attr1 -> {
SkuSaleAttrValueEntity skuSaleAttrValueEntity = new SkuSaleAttrValueEntity();
BeanUtils.copyProperties(attr1, skuSaleAttrValueEntity);
skuSaleAttrValueEntity.setSkuId(entity.getSkuId());
return skuSaleAttrValueEntity;
}).collect(Collectors.toList());
skuSaleAttrValueService.saveBatch(collect1);
//5.4 sku的优惠、满减等信息 gms_sku_ladder gms_sku_full_reduction gms_member_price
SkuReductionTo skuReductionTo = new SkuReductionTo();
BeanUtils.copyProperties(item, skuReductionTo);
skuReductionTo.setSkuId(entity.getSkuId());
if (skuReductionTo.getFullCount() > 0 ||
skuReductionTo.getFullPrice().compareTo(new BigDecimal(0)) > 0) {
//满减
R r1 = couponFeignService.saveSkuReductionTo(skuReductionTo);
if (r1.getCode() != 0) {
log.error("远程保存sku优惠信息失败");
}
}
});
}
}
@Override
public void saveBaseSpInfo(SpuInfoEntity spuInfoEntity) {
this.baseMapper.insert(spuInfoEntity);
}
feign调用超时了
第一次调用可能要初始化很多东西，重新试一下即可
spu管理：
总是会出现publish错误： main.js中：
import PubSub from 'pubsub-js'
Vue.prototype.PubSub = PubSub
/**
* 列表
*/
@RequestMapping("/list")
//@RequiresPermissions("product:spuinfo:list")
public R list(@RequestParam Map<String, Object> params){
PageUtils page = spuInfoService.queryPageByCondition(params);
return R.ok().put("page", page);
}
@Override
public PageUtils queryPageByCondition(Map<String, Object> params) {
LambdaQueryWrapper<SpuInfoEntity> wrapper = new LambdaQueryWrapper<>();
String key = (String) params.get("key");
if (StringUtils.isNotEmpty(key)) {
wrapper.and((obj) -> {
obj.eq(SpuInfoEntity::getId, key).or().like(SpuInfoEntity::getSpuName, key);
});
}
String status = (String) params.get("status");
if (StringUtils.isNotEmpty(status)) {
wrapper.eq(SpuInfoEntity::getPublishStatus, status);
}
String brandId = (String) params.get("brandId");
if (StringUtils.isNotEmpty(brandId)) {
wrapper.eq(SpuInfoEntity::getBrandId, brandId);
}
String catelogId = (String) params.get("catelogId");
if (StringUtils.isNotEmpty(catelogId)) {
wrapper.eq(SpuInfoEntity::getCatalogId, catelogId);
}
IPage<SpuInfoEntity> page = this.page(
new Query<SpuInfoEntity>().getPage(params),
wrapper
);
return new PageUtils(page);
}
时间后端来格式化
spring:
jackson:
date-format: yyyy-MM-dd HH:mm:ss
商品管理：
@Override
public PageUtils queryPageByCondition(Map<String, Object> params) {
/**
* key:
* catelogId: 0
* brandId: 0
* min: 0
* max: 0
*/
LambdaQueryWrapper<SkuInfoEntity> wrapper = new LambdaQueryWrapper<>();
String key = (String) params.get("key");
if (StringUtils.isNotEmpty(key)) {
wrapper.and(obj -> {
obj.eq(SkuInfoEntity::getSkuId, key).or().like(SkuInfoEntity::getSkuName, key);
});
}
String catelogId = (String) params.get("catelogId");
if (StringUtils.isNotEmpty(catelogId) && !"0".equals(catelogId)) {
wrapper.eq(SkuInfoEntity::getCatalogId, catelogId);
}
String brandId = (String) params.get("brandId");
if (StringUtils.isNotEmpty(brandId) && !"0".equals(brandId)) {
wrapper.eq(SkuInfoEntity::getBrandId, brandId);
}
String min = (String) params.get("min");
if (StringUtils.isNotEmpty(min)) {
wrapper.ge(SkuInfoEntity::getPrice, min);
}
String max = (String) params.get("max");
if (StringUtils.isNotEmpty(max)) {
try {
BigDecimal bigDecimal = new BigDecimal(max);
if (bigDecimal.compareTo(new BigDecimal("0")) > 0) {
wrapper.le(SkuInfoEntity::getPrice, max);
}
} catch (Exception e) {
e.printStackTrace();
}
}
IPage<SkuInfoEntity> page = this.page(
new Query<SkuInfoEntity>().getPage(params),
wrapper
);
return new PageUtils(page);
}