新增商品（商品维护模块）

7、商品维护：SPU管理、发布商品、商品管理

• 将其它前端页面导入项目
  
• pubsub un difined：在src下的main.js添加

import PubSub from 'pubsub-js'

Vue.prototype.PubSub = PubSub

配置member的路由

- id: member_route
          uri: lb://gulimall-member
          predicates:
            - Path=/api/member/**
          filters:
            - RewritePath=/api/(?>.*),/$\{segment}

1、调试会员等级相关接口，测试导入项目后有无报错

测试添加

2、发布商品

1、获取分类关联的品牌

出现报错

• 给商品系统添加方法实现/product/categorybrandrelation/brands/list

/**
     * 获取分类关联的品牌
     */
    /**
     *  /product/categorybrandrelation/brands/list
     *
     *  1、Controller：处理请求，接受和校验数据
     *  2、Service接受controller传来的数据，进行业务处理
     *  3、Controller接受Service处理完的数据，封装页面指定的vo
     */
    @GetMapping("/brands/list")
    public R relationBrandsList(@RequestParam(value = "catId",required = true)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);

    }

• 编写BrandVo

@Data
public class BrandVo {

    /**
     *      "brandId": 0,
     * 		"brandName": "string",
     */

    private Long brandId;
    private String brandName;

}

• impl

	@Autowired
    BrandDao brandDao;

    @Autowired
    CategoryDao categoryDao;

    @Autowired
    CategoryBrandRelationDao relationDao;

    @Autowired
    BrandService brandService;
	@Override
    public List<BrandEntity> getBrandsByCatId(Long catId) {

        List<CategoryBrandRelationEntity> catelogId = relationDao.selectList(new QueryWrapper<CategoryBrandRelationEntity>().eq("catelog_id", catId));
        List<BrandEntity> collect = catelogId.stream().map(item -> {
            Long brandId = item.getBrandId();
            BrandEntity byId = brandService.getById(brandId);
            return byId;
        }).collect(Collectors.toList());
        return collect;
    }

• 测试
  

2、获取分类下所有分组&关联属性

• /product/attrgroup/{catelogId}/withattr

• 新建一个Vo：AttrGroupWithAttrsVo

@Data
public class AttrGroupWithAttrsVo {

    /**
     * 分组id
     */
    private Long attrGroupId;
    /**
     * 组名
     */
    private String attrGroupName;
    /**
     * 排序
     */
    private Integer sort;
    /**
     * 描述
     */
    private String descript;
    /**
     * 组图标
     */
    private String icon;
    /**
     * 所属分类id
     */
    private Long catelogId;

    /**
     * 属性
     */
    private List<AttrEntity> attrs;
}

• AttrGroupController添加方法

/**
     * 获取分类下所有分组&关联属性
     */
    ///product/attrgroup/{catelogId}/withattr
    @GetMapping("/{catelogId}/withattr")
    public R getAttrGroupWithAttrs(@PathVariable("catelogId") Long catelogId){

        //1、查出当前分类下的所有属性分组
        //2、查出每个属性分组的所有属性
        List<AttrGroupWithAttrsVo> vos = attrGroupService.getAttrGroupWithAttrsByCatelogId(catelogId);
        return R.ok().put("data",vos);
    }

• service

List<AttrGroupWithAttrsVo> getAttrGroupWithAttrsByCatelogId(Long catelogId); 

• impl

/**
     * 根据分类id查出所有的分组以及这些组里面的属性
     * @param catelogId
     * @return
     */
    @Override
    public List<AttrGroupWithAttrsVo> getAttrGroupWithAttrsByCatelogId(Long catelogId) {
        //com.atguigu.gulimall.product.vo
        //1、查询分组信息
        List<AttrGroupEntity> attrGroupEntities = this.list(new QueryWrapper<AttrGroupEntity>().eq("catelog_id", catelogId));

        //2、查询所有属性
        List<AttrGroupWithAttrsVo> collect = attrGroupEntities.stream().map(group -> {
            AttrGroupWithAttrsVo attrsVo = new AttrGroupWithAttrsVo();
            BeanUtils.copyProperties(group,attrsVo);
            List<AttrEntity> attrs = attrService.getRelationAttr(attrsVo.getAttrGroupId());
            attrsVo.setAttrs(attrs);
            return attrsVo;
        }).collect(Collectors.toList());

        return collect;
        
    }

• 测试，先把前端效验设置为false

<el-form ref="spuBaseForm" :model="spu" label-width="120px" :rules="spuBaseInfoRules=false">

• 测试，发现某个规格参数明明设置了多选但是还是单选

在数据库的 pms_attr 表加上value_type字段，类型为tinyint就行；
在代码中，AttyEntity.java、AttrVo.java中各添加：private Integer valueType，
在AttrDao.xml中添加：< result property=“valueType” column=“value_type”/ >

• 再查看
  

• 信息成功封装
  

3、录入数据，测试一下商品保存的功能

• 点击下一步保存商品信息，查看控制台的信息
  

• 需要编写保存方法

• 点击copy，复制json信息

• 去https://www.bejson.com/解析json

• 查看
  

• 发现所有信息都有

• 点击json转为java实体类
  

• 查看
  

• 点击下载代码

• 导入项目
  
  

4、修改保存save方法（新增商品）

/product/spuinfo/save

1、修改一下生成的Vo部分字段

@Data
public class SpuSaveVo {

    private String spuName;
    private String spuDescription;
    private Long catalogId;
    private Long brandId;
    private BigDecimal weight;
    private int publishStatus;
    private List<String> decript;
    private List<String> images;
    private Bounds bounds;
    private List<BaseAttrs> baseAttrs;
    private List<Skus> skus;

}

@Data
public class Bounds {

    private BigDecimal buyBounds;
    private BigDecimal growBounds;

}

@Data
public class BaseAttrs {

    private Long attrId;
    private String attrValues;
    private int showDesc;

}

@Data
public class Skus {

    private List<Attr> attr;
    private String skuName;
    private BigDecimal price;
    private String skuTitle;
    private String skuSubtitle;
    private List<Images> images;
    private List<String> descar;
    private int fullCount;
    private BigDecimal discount;
    private int countStatus;
    private BigDecimal fullPrice;
    private BigDecimal reducePrice;
    private int priceStatus;
    private List<MemberPrice> memberPrice;

}

@Data
public class MemberPrice {

    private Long id;
    private String name;
    private BigDecimal price;
    
}

• 将Id改为Long类型，并删除get set 方法 添加上@Data注解

2、SpuInfoController

/**
     * 保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody SpuSaveVo vo){
//		spuInfoService.save(spuInfo);
        spuInfoService.saveSpuInfo(vo);
        return R.ok();
    }

• service

void saveSpuInfo(SpuSaveVo vo);

需要操作的表

三表关系：基本信息、图片描述、图片集

• pms_spu_info
  
• pms_spu_info_desc
  
• pms_spu_images
  
• pms_product_attr_value
  
• pms_sku_info
  

3、分析步骤

@Transactional
    @Override
    public void saveSpuInfo(SpuSaveVo vo) {

        //1、保存spu的基本信息  pms_spu_info

        //2、保存spu的描述图片  pms_spu_info_desc   //表里面只有两个属性spu_id、decript

        //3、保存spu的图片集   pms_spu_images

        //4、保存spu的规格参数  pms_product_attr_value

        //5、保存spu的积分信息  gulimall_sms -> sms_spu_bounds

        //5、保存当前spu对应的所有sku信息
        //5.1）、sku的基本信息         pms_sku_info
        //5.2）、sku的图片信息         pms_sku_images
        //5.3）、sku的销售属性信息      pms_sku_sale_attr_value
        //5.4）、sku的优惠、满减等信息   gulimall_sms -> sms_sku_ladder、sms_sku_full_reduction、sms_member_price

    }

1、保存spu的基本信息 pms_spu_info

//1、保存spu的基本信息  pms_spu_info
        SpuInfoEntity infoEntity = new SpuInfoEntity();
        BeanUtils.copyProperties(vo,infoEntity);
        // 1、设置infoEntity里独有的字段
        infoEntity.setCreateTime(new Date());
        infoEntity.setUpdateTime(new Date());
        this.saveBaseSpuInfo(infoEntity);

• service

void saveBaseSpuInfo(SpuInfoEntity infoEntity);

• impl

@Override
    public void saveBaseSpuInfo(SpuInfoEntity infoEntity) {
        this.baseMapper.insert(infoEntity);
    }

2、保存spu的描述图片 pms_spu_info_desc

	@Autowired
    SpuInfoDescService spuInfoDescService;

//2、保存spu的描述图片  pms_spu_info_desc   //表里面只有两个属性spu_id、decript
        List<String> decript = vo.getDecript();
        SpuInfoDescEntity descEntity = new SpuInfoDescEntity();
        //根据第一步获取的基本信息里面获取到spuid
        descEntity.setSpuId(infoEntity.getId());
        descEntity.setDecript(String.join(",",decript));
        spuInfoDescService.saveSpuInfoDesc(descEntity);

• service

void saveSpuInfoDesc(SpuInfoDescEntity descEntity);

• impl

@Override
    public void saveSpuInfoDesc(SpuInfoDescEntity descEntity) {
        this.baseMapper.insert(descEntity);
    }

3、保存spu的图片集 pms_spu_images

	@Autowired
    SpuImagesService imagesService;
    
	//3、保存spu的图片集   pms_spu_images
        List<String> images = vo.getImages();
        imagesService.saveImages(infoEntity.getId(),images);

• service

void saveImages(Long id, List<String> images);

• impl

@Override
    public void saveImages(Long id, List<String> images) {
        if (CollectionUtils.isEmpty(images)){

        }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);
        }
    }

4、保存spu的规格参数 pms_product_attr_value

	@Autowired
    AttrService attrService;
    @Autowired
    ProductAttrValueService attrValueService;
    
	//4、保存spu的规格参数  pms_product_attr_value
        List<BaseAttrs> baseAttrs = vo.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(infoEntity.getId());

            return valueEntity;
        }).collect(Collectors.toList());

        attrValueService.saveProductAttr(collect);

• service

void saveProductAttr(List<ProductAttrValueEntity> collect);

• impl

@Override
    public void saveProductAttr(List<ProductAttrValueEntity> collect) {
        this.saveBatch(collect);
    }

5、保存当前spu对应的所有sku信息

	@Autowired
    SkuImagesService skuImagesService;
    
    @Autowired
    SkuSaleAttrValueService skuSaleAttrValueService;
    
//5、保存当前spu对应的所有sku信息

        List<Skus> skus = vo.getSkus();
        if (skus!=null && skus.size()>0){
            skus.forEach(item -> {
                String defaultImg = "";
                for (Images image : item.getImages()){
                    if (image.getDefaultImg() == 1){
                        defaultImg = image.getImgUrl();
                    }
                }
//                private String skuName;
//                private BigDecimal price;
//                private String skuTitle;
//                private String skuSubtitle;

                //5.1）、sku的基本信息         pms_sku_info
                SkuInfoEntity skuInfoEntity = new SkuInfoEntity();
                BeanUtils.copyProperties(item,skuInfoEntity);
                skuInfoEntity.setBrandId(infoEntity.getBrandId());
                skuInfoEntity.setCatalogId(infoEntity.getCatalogId());
                skuInfoEntity.setSaleCount(0L);
                skuInfoEntity.setSpuId(infoEntity.getId());
                skuInfoEntity.setSkuDefaultImg(defaultImg);
                //保存sku基本信息
                skuInfoService.saveSkuInfo(skuInfoEntity);


                Long skuId = skuInfoEntity.getSkuId();

                //5.2）、sku的图片信息         pms_sku_images
                List<SkuImagesEntity> imagesEntities = item.getImages().stream().map(img -> {
                    SkuImagesEntity skuImagesEntity = new SkuImagesEntity();
                    skuImagesEntity.setSkuId(skuId);
                    skuImagesEntity.setImgUrl(img.getImgUrl());
                    skuImagesEntity.setDefaultImg(img.getDefaultImg());

                    return skuImagesEntity;
                }).collect(Collectors.toList());
                //保存sku图片信息
                skuImagesService.saveBatch(imagesEntities);


                //5.3）、sku的销售属性信息      pms_sku_sale_attr_value
                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());
                //保存sku的销售属性信息
                skuSaleAttrValueService.saveBatch(skuSaleAttrValueEntities);

• service

void saveSkuInfo(SkuInfoEntity skuInfoEntity);

• impl

@Override
    public void saveSkuInfo(SkuInfoEntity skuInfoEntity) {
        this.baseMapper.insert(skuInfoEntity);
    }

5.1、跨服务

前提：gulimall-coupon，gulimall-member注册到了服务中心

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
  application:
    name: gulimall-coupon	//gulimall-member

• gulimall-coupon主启动类：@EnableDiscoveryClient

• gulimall-member主启动添加：@EnableFeignClients(basePackages = "com.wlq.gulimall.member.feign")

• product新建远程调用的fegin包：com.wlq.gulimall.product.feign

• 这里专门写远程调用的方法

• product 主启动添加fegin注解：@EnableFeignClients(basePackages = "com.wlq.gulimall.product.feign")

• 编写一个fegin接口：CouponFeignService

@FeignClient("gulimall-coupon")
public interface CouponFeignService {
}

5.2、保存spu的积分信息 gulimall_sms -> sms_spu_bounds

这里涉及到TO模式

TO(Transfer 0bject)，数据传输对象传输的对象

不同的应用程序之间传输的对象。微服务

• 新建SpuBoundTo：com.wlq.common.to.SpuBoundTo.java

@Data
public class SpuBoundTo {

    private Long spuId;
    private BigDecimal buyBounds;
    private BigDecimal growBounds;
}

• 修改R.java

public Integer getCode(){
		return Integer.parseInt((String) this.get("code"));
	}

• 接着修改 SpuInfoServiceImpl

@Autowired
    CouponFeignService couponFeignService;

//5、保存spu的积分信息  gulimall_sms -> sms_spu_bounds
        Bounds bounds = vo.getBounds();
        SpuBoundTo spuBoundTo = new SpuBoundTo();
        BeanUtils.copyProperties(bounds,spuBoundTo);
        spuBoundTo.setSpuId(infoEntity.getId());
        R r = couponFeignService.saveSpuBounds(spuBoundTo);
        if(r.getCode() != 0){
            log.error("远程保存spu积分信息失败");
        }

• CouponFeignService

修改SpuBoundsController的save方法，改为@PostMapping("/save")

@FeignClient("gulimall-coupon")
public interface CouponFeignService {

    /**
     * 1、CouponFeignService.saveSpuBounds(spuBoundTo);
     *      1）、@RequestBody将这个对象转为json。
     *      2）、找到gulimall-coupon服务，给/coupon/spubounds/save发送请求。
     *          将上一步转的json放在请求体位置，发送请求；
     *      3）、对方服务收到请求。请求体里有json数据。
     *          (@RequestBody SpuBoundsEntity spuBounds)；将请求体的json转为SpuBoundsEntity；
     * 只要json数据模型是兼容的。双方服务无需使用同一个to
     * @param spuBoundTo
     * @return
     */
    @PostMapping("/coupon/spubounds/save")
    R saveSpuBounds(@RequestBody SpuBoundTo spuBoundTo);
}

• 执行步骤

• 1、先是调用了方法：CouponFeignService.saveSpuBounds(spuBoundTo);
  1）、CouponFeignService的saveSpuBounds@RequestBody将这个对象转为json。
  2）、注册中心找到gulimall-coupon服务，给/coupon/spubounds/save发送请求。
  将上一步转的json放在请求体位置，发送请求；
  3）、对方服务收到请求。请求体里有json数据。
  (@RequestBody SpuBoundsEntity spuBounds)；将请求体的json转为SpuBoundsEntity；进行save保存
  只要json数据模型是兼容的。双方服务无需使用同一个to

这里注意上面发送的请求和下面接受的数据格式不同是因为相传的json数据模型是兼容的，也就是entity都一样

5.3、sku的优惠、满减等信息 gulimall_sms -> sms_sku_ladder、sms_sku_full_reduction、sms_member_price

• sms_sku_ladder
  

• sms_sku_full_reduction
  

• sms_member_price
  

• 新建SkuReductionTo：com.wlq.common.to.SkuReductionTo.java

@Data
public class SkuReductionTo {

    private Long skuId;
    private int fullCount;
    private BigDecimal discount;
    private int countStatus;
    private BigDecimal fullPrice;
    private BigDecimal reducePrice;
    private int priceStatus;
    private List<MemberPrice> memberPrice;
}

• 新建com.wlq.common.to.MemberPrice

@Data
public class MemberPrice {

    private Long id;
    private String name;
    private BigDecimal price;

}

• 接着修改 SpuInfoServiceImpl

//5.4）、sku的优惠、满减等信息   gulimall_sms -> sms_sku_ladder、sms_sku_full_reduction、sms_member_price
                //需要操作远程服务，也就是跨库跨服务
                SkuReductionTo skuReductionTo = new SkuReductionTo();
                BeanUtils.copyProperties(item,skuReductionTo);
                skuReductionTo.setSkuId(skuId);
                if(skuReductionTo.getFullCount() >0 || skuReductionTo.getFullPrice().compareTo(new BigDecimal("0")) == 1){
                    R r1 = couponFeignService.saveSkuReduction(skuReductionTo);
                    if(r1.getCode() != 0){
                        log.error("远程保存sku优惠信息失败");
                    }
                }

• service

@FeignClient("gulimall-coupon")
public interface CouponFeignService {

    /**
     * 1、CouponFeignService.saveSpuBounds(spuBoundTo);
     *      1）、@RequestBody将这个对象转为json。
     *      2）、找到gulimall-coupon服务，给/coupon/spubounds/save发送请求。
     *          将上一步转的json放在请求体位置，发送请求；
     *      3）、对方服务收到请求。请求体里有json数据。
     *          (@RequestBody SpuBoundsEntity spuBounds)；将请求体的json转为SpuBoundsEntity；
     * 只要json数据模型是兼容的。双方服务无需使用同一个to
     * @param spuBoundTo
     * @return
     */
    @PostMapping("/coupon/spubounds/save")
    R saveSpuBounds(@RequestBody SpuBoundTo spuBoundTo);

    @PostMapping("/coupon/skufullreduction/saveinfo")
    R saveSkuReduction(@RequestBody SkuReductionTo skuReductionTo);
}

• 修改SkuFullReductionController：添加方法实现

/**
     * 保存优惠满减等信息
     */
    @PostMapping("/saveinfo")
    public R saveInfo(@RequestBody SkuReductionTo reductionTo){

        skuFullReductionService.saveSkuReduction(reductionTo);

        return R.ok();
    }

• service

void saveSkuReduction(SkuReductionTo reductionTo);

• impl

    @Autowired
    SkuLadderService skuLadderService;

    @Autowired
    MemberPriceService memberPriceService;
	@Override
    public void saveSkuReduction(SkuReductionTo reductionTo) {

        //1、保存满减打折
        //sku的优惠、满减等信息   gulimall_sms -> sms_sku_ladder、sms_sku_full_reduction、sms_member_price


        //sms_sku_ladder
        SkuLadderEntity skuLadderEntity = new SkuLadderEntity();
        skuLadderEntity.setSkuId(reductionTo.getSkuId());
        skuLadderEntity.setFullCount(reductionTo.getFullCount());
        skuLadderEntity.setDiscount(reductionTo.getDiscount());
        skuLadderEntity.setAddOther(reductionTo.getCountStatus());
        if(reductionTo.getFullCount() > 0){
            skuLadderService.save(skuLadderEntity);
        }



        //2、sms_sku_full_reduction
        SkuFullReductionEntity reductionEntity = new SkuFullReductionEntity();
        BeanUtils.copyProperties(reductionTo,reductionEntity);
        if(reductionEntity.getFullPrice().compareTo(new BigDecimal("0"))==1){
            this.save(reductionEntity);
        }


        //3、sms_member_price
        List<MemberPrice> memberPrice = reductionTo.getMemberPrice();

        List<MemberPriceEntity> collect = memberPrice.stream().map(item -> {
            MemberPriceEntity priceEntity = new MemberPriceEntity();
            priceEntity.setSkuId(reductionTo.getSkuId());
            priceEntity.setMemberLevelId(item.getId());
            priceEntity.setMemberLevelName(item.getName());
            priceEntity.setMemberPrice(item.getPrice());
            priceEntity.setAddOther(1);
            return priceEntity;
        }).filter(item->{
            return item.getMemberPrice().compareTo(new BigDecimal("0")) == 1;
        }).collect(Collectors.toList());

        memberPriceService.saveBatch(collect);
    }

整体测试debug

目前需要启动六个服务，可以放在一起方便启动

• 如果内存不够用可是设置他们的最大内存占用：VM options:-Xms 100m
• 打上断点，product以debug启动
  
• 点击确定
  
• 进入debug模式查看

vo封装了很多信息

第一步走完，infoEntity的信息

• 前往数据库查看数据是否写入：pms_spu_info

由于这个类是加了事务注解@Transactional，数据需要提交了才能看到，所有我们需要使用：

• SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; ;

将当前这个会话的隔离等级设置成读未提交，这样当前窗口就能读到还未提交的数据

• 修改SpuInfoDescEntity

@Data
@TableName("pms_spu_info_desc")
public class SpuInfoDescEntity implements Serializable {
	private static final long serialVersionUID = 1L;

	/**
	 * 商品id
	 */
	@TableId(type = IdType.INPUT)
	private Long spuId;
	/**
	 * 商品介绍
	 */
	private String decript;

}

• 重启debug

• 过完第三部保存图片集，查看控制台
  

• 往下继续

baseattr存储了基本信息

• 给保存方法打一个断点，直接放行中间的封装数据过程
  
• 继续下一步，查看控制台
  
• 继续往下，走到远程调用的时候会需要等一会，r返回的成功
  
• 继续往下发现抛出了异常

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at com.wlq.common.utils.R.getCode(R.java:65) ~[classes/:na]

• 修改R.getCode

public Integer getCode(){
		return (Integer) this.get("code");
	}

• 重启debug启动，发送保存

打上断点，直接放行

• 继续往下，没有报错，来到了第五步保存sku信息
• 将里面每个保存方法都打上断点

r1返回成功

• 第一个商品数据插入成功，后面全部放行
• 查看数据库
  
  

优化问题

• SpuInfoServiceImpl

1、过滤空图片路径

	//5.2）、sku的图片信息         pms_sku_images
                List<SkuImagesEntity> imagesEntities = item.getImages().stream().map(img -> {
                    SkuImagesEntity skuImagesEntity = new SkuImagesEntity();
                    skuImagesEntity.setSkuId(skuId);
                    skuImagesEntity.setImgUrl(img.getImgUrl());
                    skuImagesEntity.setDefaultImg(img.getDefaultImg());

                    return skuImagesEntity;
                }).filter(entity ->{
                    //返回true就是需要，false不要
                    return !StringUtils.isEmpty(entity.getImgUrl());
                }).collect(Collectors.toList());
                //保存sku图片信息
                skuImagesService.saveBatch(imagesEntities);
                //TODO 没有图片，路径无需保存

2、打折优惠会员等信息，没有也需要过滤

	//5.4）、sku的优惠、满减等信息   gulimall_sms -> sms_sku_ladder、sms_sku_full_reduction、sms_member_price
                //需要操作远程服务，也就是跨库跨服务
                SkuReductionTo skuReductionTo = new SkuReductionTo();
                BeanUtils.copyProperties(item,skuReductionTo);
                skuReductionTo.setSkuId(skuId);
                if(skuReductionTo.getFullCount() >0 || skuReductionTo.getFullPrice().compareTo(new BigDecimal("0")) == 1){
                    R r1 = couponFeignService.saveSkuReduction(skuReductionTo);
                    if(r1.getCode() != 0){
                        log.error("远程保存sku优惠信息失败");
                    }
                }

• SkuFullReductionServiceImpl

@Override
    public void saveSkuReduction(SkuReductionTo reductionTo) {

        //1、保存满减打折
        //sku的优惠、满减等信息   gulimall_sms -> sms_sku_ladder、sms_sku_full_reduction、sms_member_price


        //sms_sku_ladder
        SkuLadderEntity skuLadderEntity = new SkuLadderEntity();
        skuLadderEntity.setSkuId(reductionTo.getSkuId());
        skuLadderEntity.setFullCount(reductionTo.getFullCount());
        skuLadderEntity.setDiscount(reductionTo.getDiscount());
        skuLadderEntity.setAddOther(reductionTo.getCountStatus());
        if(reductionTo.getFullCount() > 0){
            skuLadderService.save(skuLadderEntity);
        }



        //2、sms_sku_full_reduction
        SkuFullReductionEntity reductionEntity = new SkuFullReductionEntity();
        BeanUtils.copyProperties(reductionTo,reductionEntity);
        if(reductionEntity.getFullPrice().compareTo(new BigDecimal("0"))==1){
            this.save(reductionEntity);
        }


        //3、sms_member_price
        List<MemberPrice> memberPrice = reductionTo.getMemberPrice();

        List<MemberPriceEntity> collect = memberPrice.stream().map(item -> {
            MemberPriceEntity priceEntity = new MemberPriceEntity();
            priceEntity.setSkuId(reductionTo.getSkuId());
            priceEntity.setMemberLevelId(item.getId());
            priceEntity.setMemberLevelName(item.getName());
            priceEntity.setMemberPrice(item.getPrice());
            priceEntity.setAddOther(1);
            return priceEntity;
        }).filter(item->{
            return item.getMemberPrice().compareTo(new BigDecimal("0")) == 1;
        }).collect(Collectors.toList());

        memberPriceService.saveBatch(collect);
    }

• 重新测试发布商品

saveSpuInfo方法完成，高级部分接着完善

3、SPU管理

SPU检索

• 修改SpuInfoController ： /product/spuinfo/list

@RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params){
        PageUtils page = spuInfoService.queryPageByCondition(params);

        return R.ok().put("page", page);
    }

• service

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

• impl

@Override
    public PageUtils queryPageByCondition(Map<String, Object> params) {

        QueryWrapper<SpuInfoEntity> wrapper = new QueryWrapper<>();

        String key = (String) params.get("key");
        if(!StringUtils.isEmpty(key)){
            wrapper.and((w)->{
                w.eq("id",key).or().like("spu_name",key);
            });
        }
        // status=1 and (id=1 or spu_name like xxx)
        String status = (String) params.get("status");
        if(!StringUtils.isEmpty(status)){
            wrapper.eq("publish_status",status);
        }

        String brandId = (String) params.get("brandId");
        if(!StringUtils.isEmpty(brandId)&&!"0".equalsIgnoreCase(brandId)){
            wrapper.eq("brand_id",brandId);
        }

        String catelogId = (String) params.get("catelogId");
        if(!StringUtils.isEmpty(catelogId)&&!"0".equalsIgnoreCase(catelogId)){
            wrapper.eq("catalog_id",catelogId);
        }

        /**
         * status: 2
         * key:
         * brandId: 9
         * catelogId: 225
         */

        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	#设置时间格式
    time-zone: GMT+8

4、商品管理

SKU检索

/product/skuinfo/list

• SkuInfoController

@RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params){
        PageUtils page = skuInfoService.queryPageByCondition(params);

        return R.ok().put("page", page);
    }

• service

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

• impl

@Override
    public PageUtils queryPageByCondition(Map<String, Object> params) {
        QueryWrapper<SkuInfoEntity> queryWrapper = new QueryWrapper<>();
        /**
         * key:
         * catelogId: 0
         * brandId: 0
         * min: 0
         * max: 0
         */
        String key = (String) params.get("key");
        if(!StringUtils.isEmpty(key)){
            queryWrapper.and((wrapper)->{
                wrapper.eq("sku_id",key).or().like("sku_name",key);
            });
        }

        String catelogId = (String) params.get("catelogId");
        if(!StringUtils.isEmpty(catelogId)&&!"0".equalsIgnoreCase(catelogId)){

            queryWrapper.eq("catalog_id",catelogId);
        }

        String brandId = (String) params.get("brandId");
        if(!StringUtils.isEmpty(brandId)&&!"0".equalsIgnoreCase(catelogId)){
            queryWrapper.eq("brand_id",brandId);
        }

        String min = (String) params.get("min");
        if(!StringUtils.isEmpty(min)){
            queryWrapper.ge("price",min);
        }

        String max = (String) params.get("max");

        if(!StringUtils.isEmpty(max)  ){
            try{
                BigDecimal bigDecimal = new BigDecimal(max);

                if(bigDecimal.compareTo(new BigDecimal("0"))==1){
                    queryWrapper.le("price",max);
                }
            }catch (Exception e){

            }

        }


        IPage<SkuInfoEntity> page = this.page(
                new Query<SkuInfoEntity>().getPage(params),
                queryWrapper
        );

        return new PageUtils(page);
    }

• 测试查询