乐优商城笔记三：规格与商品模块

最新推荐文章于 2020-10-24 17:28:35 发布
最新推荐文章于 2020-10-24 17:28:35 发布
阅读量399 收藏 1
点赞数
分类专栏： 乐优商城
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1031893936/article/details/91955334
版权
乐优商城规格管理和商品管理模块基本构建完成

规格模块

后端

编写实体类
package com.leyou.pojo;

import lombok.Data;

import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "tb_specification")
@Data
public class Specification {

    @Id
    private Long categoryId;
    private String specifications;
}
编写Mapper
package com.leyou.item.mapper;

import com.leyou.pojo.Specification;
import tk.mybatis.mapper.common.Mapper;

public interface SpecificationMapper extends Mapper<Specification> {
}
编写Service
package com.leyou.item.service;

import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.item.mapper.CategoryMapper;
import com.leyou.item.mapper.SpecificationMapper;
import com.leyou.pojo.Specification;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class SpecificationService {

    @Autowired
    private SpecificationMapper specificationMapper;

    @Autowired
    private CategoryMapper categoryMapper;

    /**
     * 按分类ID查询规格(此表中分类ID其实为该表的ID)
     *
     * @param categoryId 分类ID
     * @return 规格信息
     */
    public Specification queryById(Long categoryId) {
        return specificationMapper.selectByPrimaryKey(categoryId);
    }

    /**
     * 新增规格
     *
     * @param specification 规格信息
     * @return 规格信息
     */
    @Transactional
    public Specification addSpecification(Specification specification) {
        // 先查询并判断是否有该分类
        if (categoryMapper.selectByPrimaryKey(specification.getCategoryId()) == null) {
            throw new LyException(LyExceptionEnum.CATEGORY_NOT_FOUND);
        }
        // 新增
        if (specificationMapper.insert(specification) == 1)
            return specification;

        throw new LyException(LyExceptionEnum.SAVE_FAILURE);
    }

    /**
     * 编辑规格
     * @param specification 规格信息
     * @return 规格信息
     */
    public Specification saveSpecification(Specification specification) {
        // 先查询并判断是否有该分类
        if (categoryMapper.selectByPrimaryKey(specification.getCategoryId()) == null) {
            throw new LyException(LyExceptionEnum.CATEGORY_NOT_FOUND);
        }
        // 编辑
        if (specificationMapper.updateByPrimaryKey(specification) == 1)
            return specification;

        throw new LyException(LyExceptionEnum.SAVE_FAILURE);
    }
}
编写Controller
package com.leyou.item.cotroller;

import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.item.service.SpecificationService;
import com.leyou.pojo.Specification;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("spec")
public class SpecificationController {

    @Autowired
    private SpecificationService specificationService;

    @GetMapping("/{categoryId}")
    public ResponseEntity<String> querySpecificationByCategoryId(@PathVariable("categoryId") Long categoryId) {
        if (categoryId == null) {
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);
        }
        // 查询规格
        Specification specification = specificationService.queryById(categoryId);
        if (specification == null) {
            throw new LyException(LyExceptionEnum.SPU_NOT_FOUND);
        }
        // 返回存储的规格JSON字符串
        return ResponseEntity.ok(specification.getSpecifications());
    }

    @PostMapping
    public ResponseEntity<Specification> addSpecification(@RequestBody Specification specification) {
        if (specification == null || specification.getCategoryId() == null) {
            throw new LyException(LyExceptionEnum.PARAM_INVALID);
        }
        // 新增
        return ResponseEntity.status(HttpStatus.CREATED).body(specificationService.addSpecification(specification));
    }

    @PutMapping
    public ResponseEntity<Specification> saveSpecification(@RequestBody Specification specification) {
        if (specification == null || specification.getCategoryId() == null) {
            throw new LyException(LyExceptionEnum.PARAM_INVALID);
        }
        // 新增
        return ResponseEntity.ok(specificationService.saveSpecification(specification));
    }
}

这里规格的修改和删除为一体

商品模块

后端

实体类
  1. Spu
package com.leyou.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Table(name = "tb_spu")
@Data
public class Spu {
    @Id
    @KeySql(useGeneratedKeys = true)
    private Long id;
    private Long brandId;
    private Long cid1;// 1级类目
    private Long cid2;// 2级类目
    private Long cid3;// 3级类目
    private String title;// 标题
    private String subTitle;// 子标题
    private Boolean saleable;// 是否上架
    private Boolean valid;// 是否有效，逻辑删除用
    private Date createTime;// 创建时间
    private Date lastUpdateTime;// 最后修改时间
}

  1. SpuDetail

    package com.leyou.pojo;

import lombok.Data;

import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="tb_spu_detail")
@Data
public class SpuDetail {
    @Id
    private Long spuId;// 对应的SPU的id
    private String description;// 商品描述
    private String specTemplate;// 商品特殊规格的名称及可选值模板
    private String specifications;// 商品的全局规格属性
    private String packingList;// 包装清单
    private String afterService;// 售后服务
}
编写Mapper
package com.leyou.item.mapper;

import com.leyou.pojo.Spu;
import tk.mybatis.mapper.common.Mapper;

public interface GoodsMapper extends Mapper<Spu> {
}
编写Service
package com.leyou.item.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.leyou.BO.SpuBO;
import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.common.util.LeyouConstants;
import com.leyou.common.vo.PageResult;
import com.leyou.item.mapper.*;
import com.leyou.pojo.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class GoodsService {

    @Autowired
    private GoodsMapper goodsMapper;

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private BrandMapper brandMapper;

    @Autowired
    private SkuMapper skuMapper;

    @Autowired
    private SpuDetailMapper spuDetailMapper;

    @Autowired
    private StockMapper stockMapper;

    @Autowired
    private AmqpTemplate amqpTemplate;

    /**
     * 分页查询商品列表
     *
     * @param page     当前页
     * @param rows     每页记录数
     * @param sortBy   排序字段
     * @param desc     是否降序
     * @param key      查询关键字
     * @param saleable 是否过滤上下架
     * @return 商品列表
     */
    public PageResult<SpuBO> querySpuByPage(int page, int rows, String sortBy, Boolean desc, String key, Boolean saleable) {
        // 分页
        PageHelper.startPage(page, rows);
        // 封装查询关键字
        Example example = new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();
        if (StringUtils.isNotBlank(key)) {
            criteria.andLike("title", "%" + key + "%");
        }
        if (saleable != null) {
            criteria.andEqualTo("saleable", saleable);
        }
        // 排序
        if (StringUtils.isNotBlank(sortBy)) {
            example.setOrderByClause(sortBy + (desc ? " DESC" : " ASC"));
        }
        // 执行查询
        List<Spu> spuList = goodsMapper.selectByExample(example);
        if (spuList.size() < 1) {
            throw new LyException(LyExceptionEnum.SPU_LIST_NOT_FOUND);
        }
        PageInfo<Spu> pageInfo = new PageInfo<>(spuList);

        // 使用spu集合 构造spuBO集合
        List<SpuBO> spuBOList = pageInfo.getList().stream().map(spu -> {
            SpuBO spuBO = new SpuBO();
            BeanUtils.copyProperties(spu, spuBO);
            // 查询分类名称列表并处理成字符串
            Optional<String> categoryNameString = categoryMapper.selectByIdList(Arrays.asList(spu.getCid1(), spu.getCid2(), spu.getCid3()))
                    .stream()
                    .map(Category::getName)
                    .reduce((name1, name2) -> name1 + "/" + name2);
            // 查询品牌名称
            Brand brand = brandMapper.selectByPrimaryKey(spu.getBrandId());
            if (brand == null) {
                throw new LyException(LyExceptionEnum.BRAND_NOT_FOUND);
            }
            // 设置分类以及品牌名称
            spuBO.setBname(brand.getName());
            spuBO.setCname(categoryNameString.get());
            return spuBO;
        }).collect(Collectors.toList());

        return new PageResult<>(pageInfo.getTotal(), spuBOList);
    }

    /**
     * 新增商品
     *
     * @param goods 商品信息
     * @return SPU
     */
    @Transactional
    public Spu addGoods(SpuBO goods) {
        try {
            // 保存SPU
            goods.setSaleable(true); // 上架
            goods.setCreateTime(new Date()); // 新增时间
            goods.setLastUpdateTime(goods.getCreateTime()); // 最后更新时间
            goodsMapper.insert(goods);

            // 保存SPU描述
            SpuDetail spuDetail = goods.getSpuDetail();
            spuDetail.setSpuId(goods.getId()); // 设置ID
            spuDetailMapper.insert(spuDetail);

            // 保存SKU列表
            saveSkuList(goods);

        } catch (Exception e) {
            throw new LyException(LyExceptionEnum.SAVE_FAILURE);
        }
        return goods;
    }

    // 保存SKU列表
    private void saveSkuList(SpuBO goods) {
        goods.getSkuList().forEach(sku -> {
            if (sku.getEnable()) {
                // 保存sku信息
                sku.setCreateTime(goods.getCreateTime());
                sku.setSpuId(goods.getId());
                sku.setLastUpdateTime(goods.getCreateTime());
                skuMapper.insert(sku);
                // 保存库存信息
                Stock stock = new Stock();
                stock.setSkuId(sku.getId());
                stock.setStock(sku.getStock());
                stockMapper.insert(stock);
            }
        });
    }

    /**
     * 编辑商品
     *
     * @param goods 商品信息
     * @return SPU
     */
    @Transactional
    public Spu saveGoods(SpuBO goods) {
        try {
            // 保存SPU
            goods.setSaleable(true); // 上架
            goods.setLastUpdateTime(new Date()); // 最后更新时间
            goodsMapper.updateByPrimaryKey(goods);

            // 保存SPU描述
            spuDetailMapper.updateByPrimaryKeySelective(goods.getSpuDetail());
            // 保存SKU列表，需要先删除原先的SKU列表
            Sku sku = new Sku();
            sku.setSpuId(goods.getId());
            skuMapper.delete(sku);
            // 删除库存信息
            List<Sku> skuList = skuMapper.select(sku);
            List<Long> ids = skuList.stream().map(Sku::getId).collect(Collectors.toList());
            stockMapper.deleteByIdList(ids);
            // 保存更新后的数据
            saveSkuList(goods);

        } catch (Exception e) {
            throw new LyException(LyExceptionEnum.SAVE_FAILURE);
        }
        return goods;
    }

    /**
     * 按ID查询商品信息
     *
     * @param spuId spuid
     * @return 商品信息
     */
    public SpuBO queryGoodsById(Long spuId) {
        SpuBO spuBO = new SpuBO();
        // 查询spu基本信息
        Spu spu = goodsMapper.selectByPrimaryKey(spuId);
        if (spu == null || spu.getId() == null) {
            throw new LyException(LyExceptionEnum.GOODS_NOT_FOUND);
        }
        BeanUtils.copyProperties(spu, spuBO);
        // 查询商品描述信息
        spuBO.setSpuDetail(spuDetailMapper.selectByPrimaryKey(spuId));
        // 查询商品SKU列表
        Sku sku = new Sku();
        sku.setSpuId(spuId);
        List<Sku> skuList = skuMapper.select(sku);
        spuBO.setSkuList(skuList);

        return spuBO;
    }

    /**
     * 按spuid查询商品描述
     *
     * @param spuId id
     * @return 描述信息
     */
    public SpuDetail querySpuDetailById(Long spuId) {
        SpuDetail spuDetail = spuDetailMapper.selectByPrimaryKey(spuId);
        if (spuDetail == null) {
            throw new LyException(LyExceptionEnum.GOODS_NOT_FOUND);
        }
        return spuDetail;
    }

    /**
     * 按spuid查询sku列表
     *
     * @param spuId id
     * @return sku列表
     */
    public List<Sku> querySkuListById(Long spuId) {
        Sku sku = new Sku();
        sku.setSpuId(spuId);
        List<Sku> skuList = skuMapper.select(sku);
        if (skuList.isEmpty()) {
            throw new LyException(LyExceptionEnum.SKU_LIST_NOT_FOUND);
        }
        // 查询每个sku的库存信息
        List<Stock> stockList = stockMapper.selectByIdList(skuList.stream().map(Sku::getId).collect(Collectors.toList()));
        if (stockList.isEmpty()) {
            throw new LyException(LyExceptionEnum.GOODS_STOCK_NOT_FOUND);
        }
        // 将库存数量与skuId生成map
        Map<Long, Long> stockMap = stockList.stream().collect(Collectors.toMap(Stock::getSkuId, Stock::getStock));
        // 设置库存数量
        skuList.forEach(s -> s.setStock(stockMap.get(s.getId())));

        return skuList;
    }


    /**
     * 更新商品状态（上下架）
     *
     * @param skuId  skuId
     * @param status 商品状态
     */
    public Sku updateGoodsStatus(Long skuId, Boolean status) {
        // 查询sku
        Sku sku = skuMapper.selectByPrimaryKey(skuId);
        if (sku == null) {
            throw new LyException(LyExceptionEnum.GOODS_NOT_FOUND);
        }
        // 修改商品状态
        sku.setEnable(status);
        // 保存
        skuMapper.updateByPrimaryKey(sku);
        return sku;
    }

    /**
     * 删除商品
     *
     * @param spuId 商品ID
     * @return 被删除的商品
     */
    @Transactional
    public Spu deleteGoods(Long spuId) {
        // 查询spu
        Spu spu = goodsMapper.selectByPrimaryKey(spuId);
        if (spu == null) {
            throw new LyException(LyExceptionEnum.GOODS_NOT_FOUND);
        }
        // 删除spu和spuDetail
        goodsMapper.deleteByPrimaryKey(spuId);
        spuDetailMapper.deleteByPrimaryKey(spuId);

        // 删除sku列表
        Sku sku = new Sku();
        sku.setSpuId(spuId);
        List<Sku> skuList = skuMapper.select(sku);
        List<Long> ids = skuList.stream().map(Sku::getId).collect(Collectors.toList());
        skuMapper.deleteByIdList(ids);
        // 删除库存信息
        stockMapper.deleteByIdList(ids);

        return spu;
    }
}
编写Controller
package com.leyou.item.cotroller;

import com.leyou.BO.SpuBO;
import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.common.vo.PageResult;
import com.leyou.item.service.GoodsService;
import com.leyou.pojo.Sku;
import com.leyou.pojo.Spu;
import com.leyou.pojo.SpuDetail;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/goods")
public class GoodsController {

    @Autowired
    private GoodsService goodsService;

    /**
     * 分页查询商品列表
     *
     * @param page     当前页码
     * @param rows     每页记录数
     * @param sortBy   排序字段
     * @param desc     是否降序
     * @param key      查询关键字
     * @param saleable 是否上架
     * @return List<SpuBO>
     */
    @GetMapping("/spu/page")
    public ResponseEntity<PageResult<SpuBO>> querySpuByPage(@RequestParam(value = "page", defaultValue = "1") int page,
                                                            @RequestParam(value = "rows", defaultValue = "5") int rows,
                                                            @RequestParam(value = "sortBy", required = false) String sortBy,
                                                            @RequestParam(value = "desc", required = false, defaultValue = "false") Boolean desc,
                                                            @RequestParam(value = "key", required = false) String key,
                                                            @RequestParam(value = "saleable", required = false) Boolean saleable) {
        return ResponseEntity.ok(goodsService.querySpuByPage(page, rows, sortBy, desc, key, saleable));
    }

    /**
     * 新增商品
     *
     * @param goods 商品
     * @return Spu
     */
    @PostMapping
    public ResponseEntity<Spu> addGoods(@RequestBody SpuBO goods) {
        if (goods == null)
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);

        // 保存
        return ResponseEntity.status(HttpStatus.CREATED).body(goodsService.addGoods(goods));
    }

    /**
     * 编辑商品
     *
     * @param goods 商品
     * @return Spu
     */
    @PutMapping
    public ResponseEntity<Spu> saveGoods(@RequestBody SpuBO goods) {
        if (goods == null)
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);

        // 保存
        return ResponseEntity.ok(goodsService.saveGoods(goods));
    }

    /**
     * 按商品ID查询商品描述
     *
     * @param spuId 商品ID
     * @return SpuDetail
     */
    @GetMapping("/spu/detail/{spuId}")
    public ResponseEntity<SpuDetail> querySpuDetailById(@PathVariable("spuId") Long spuId) {
        if (spuId == null) {
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);
        }
        return ResponseEntity.ok(goodsService.querySpuDetailById(spuId));
    }

    /**
     * 按商品ID查询该商品所有规格的商品列表
     *
     * @param spuId 商品ID
     * @return List<Sku>
     */
    @GetMapping("/sku/list/{spuId}")
    public ResponseEntity<List<Sku>> querySkuListById(@PathVariable("spuId") Long spuId) {
        if (spuId == null) {
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);
        }
        return ResponseEntity.ok(goodsService.querySkuListById(spuId));
    }

    /**
     * 上架下架
     *
     * @param skuId  skuID
     * @param status 修改后的商品状态
     * @return Sku
     */
    @GetMapping("/sku/status/{skuId}")
    public ResponseEntity<Sku> updateSkuStatus(@PathVariable("skuId") Long skuId,
                                               @RequestParam("status") Boolean status) {
        return ResponseEntity.ok(goodsService.updateGoodsStatus(skuId, status));
    }

    /**
     * 删除指定spuId的商品
     *
     * @param spuId 商品ID
     * @return Spu 被删除的spu
     */
    @DeleteMapping("/{spuId}")
    public ResponseEntity<Spu> deleteGoods(@PathVariable("spuId") Long spuId) {
        return ResponseEntity.ok(goodsService.deleteGoods(spuId));
    }

    /**
     * 查询spu信息
     *
     * @param spuId 商品ID
     * @return Spu
     */
    @GetMapping("/{spuId}")
    public ResponseEntity<SpuBO> queryGoodsById(@PathVariable("spuId") Long spuId) {
        return ResponseEntity.ok(goodsService.queryGoodsById(spuId));
    }
}

其他后端改动

分类Mapper新增继承
package com.leyou.item.mapper;

import com.leyou.pojo.Category;
import tk.mybatis.mapper.additional.idlist.SelectByIdListMapper;
import tk.mybatis.mapper.common.Mapper;

public interface CategoryMapper extends Mapper<Category>, SelectByIdListMapper<Category, Long> {
}

继承SelectByIdListMapper<T, PK>，泛型第一参数为实体类，第二个参数为ID类型

品牌新增接口

  1. BrandController

        @GetMapping("/cid/{categoryId}")
    public ResponseEntity<List<Brand>> queryBrandByCategoryId(@PathVariable("categoryId") Long categoryId) {
        if (categoryId == null) {
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);
        }
        // 查询
        return ResponseEntity.ok(brandService.queryBrandByCategoryId(categoryId));
    }

  2. BrandService

        /**
     * 按分类ID查询品牌列表
     *
     * @param categoryId 分类ID
     * @return 品牌列表
     */
    public List<Brand> queryBrandByCategoryId(Long categoryId) {
        List<Brand> brands = brandMapper.queryBrandByCategoryId(categoryId);
        if (brands.isEmpty()) {
            throw new LyException(LyExceptionEnum.BRAND_LIST_NOT_FOUND);
        }
        return brands;
    }

  3. BrandMapper

        @Select("SELECT b.* FROM tb_category_brand cb, tb_brand b WHERE cb.category_id = #{categoryId} AND cb.brand_id = b.id")
    List<Brand> queryBrandByCategoryId(Long categoryId);
新增商品BO
package com.leyou.BO;

import com.leyou.pojo.Sku;
import com.leyou.pojo.Spu;
import com.leyou.pojo.SpuDetail;
import lombok.Data;

import javax.persistence.Transient;
import java.util.List;

@Data
public class SpuBO extends Spu {
    // 分类名称
    @Transient
    private String cname;

    // 品牌名称
    @Transient
    private String bname;

    // 商品描述
    @Transient
    private SpuDetail spuDetail;

    // 商品列表
    @Transient
    private List<Sku> skuList;
}
新增异常枚举
    SPU_LIST_NOT_FOUND(404, "未查询到商品列表"),
    SPU_NOT_FOUND(404, "未查询到商品列表"),

前端

Goods.vue
getDataFromApi() {
        this.loading = true;
        this.$http.get("/item/goods/spu/page", {
          params: {
            page: this.pagination.page, // 当前页
            rows: this.pagination.rowsPerPage, // 每页条数
            sortBy: this.pagination.sortBy, // 排序字段
            desc: this.pagination.descending, // 是否降序
            key: this.search.key, // 查询字段
            saleable: this.search.saleable // 过滤上下架
          }
        }).then(response => { // 获取响应结果对象
          this.totalItems = response.data.total; // 总条数
          this.items = response.data.items; // 品牌数据
          this.loading = false; // 加载完成
        }).catch(response => {
          // http返回的error结构很复杂，并不是直接返回你定义好的对象格式。
          // 如果你也想使用 response.data.message 获取到错误消息
          // 需要在http.js中自定义个一个响应拦截器
          // 或者你也可以使用 response.response.data.message 直接获取到错误消息
          this.$message.error(response.data.message);
        });
      }

goods.vue 其他地方均无太大改动。如有报错，注意查看浏览器中提示的错误信息。

http.js新增响应拦截器
axios.interceptors.response.use(
	response => {
		const res = response.status
		if (res !== 200) {
			return Promise.reject('error')
		} else {
			return response
		}
	},
	error => {
		console.log('err' + error.response) // for debug
		console.log('err' + error.message)
		return Promise.reject(error.response)
	}
)

由于我的那部分乐优资料中的SQL语句和视频中不一致，这一块有很多的实现都和视频中的不同，我写这一块的时候也有许多的BUG，但是并不要紧，这不是关键流程，写不写得出来问题都不大。

imxushuai
关注
专栏目录
乐优商城第九天，第十天，（商品规格参数模版的新增，商品的新增）
CR2018博客
06-03 2519
乐优商城第9,10两天，商品的新增，是整个后台系统最难的地方，尤其是前端页面，这里把中心放在后端代码和业务逻辑上spu是一种商品的总称，比如小米8sku是细分领域，比如xiaomi8 星空黑64G商品的新增涉及4张表，spu，spudetail，sku，store其实就是两张表spu和sku，但是spudetail数据量太为庞大，而且不常用，我们采取了垂直拆分的方式，而sku的库存，因为要经常读写...
乐优商城项目总结——07商品规格管理（spu，sku）
胡辣汤麻辣烫的博客
08-01 2090
商品管理 商品的管理不能像以前写的小demo一样，一个表解决所有的问题。 全品类的商品种类很多，商品的属性也不一样，存到一起商品又多又难管理。所以抽出来两个概念：spu和sku。 商品管理的难点就在于搞清楚商品spu和sku，搞清楚以后业务逻辑很容易实现。 SPU和SKU SPU：Standard Product Unit （标准产品单位） ，一组具有共同属性的商品集 SKU：Stock Keep...
lyshop学习笔记七-商品管理（添加商品）
小武的Blog
04-17 2286
title: 乐优商城学习笔记七-商品管理（添加商品） date: 2019-04-17 16:18:10 tags: - 乐优商城 - java - springboot categories: - 乐优商城 0.学习目标 独立实现商品新增后台 独立实现商品编辑后台 独立搭建前台系统页面 1.商品新增 1.1.页面预览 当我们点击新增商品按钮： ...
乐优商城笔记二：分类与品牌模块
Bbb的博客
06-14 975
分类模块与品牌模块实现 准备工作 使用nginx，通过域名访问本地项目 下载nginx压缩包（我这里直接下载的windows包，解压后编写配置文件，即可使用） nginx.conf ... # 配置两个server节点即可 server { listen 80; server_name manage.leyou.com; ...
乐优商城学习笔记十八-商品详情
小武的Blog
04-21 1682
0.学习目标 了解Thymeleaf的基本使用 实现商品详情页的渲染 知道页面静态化的作用 实现页面静态化功能 1.商品详情 当用户搜索到商品，肯定会点击查看，就会进入商品详情页，接下来我们完成商品详情页的展示， 1.2.商品详情页服务 商品详情浏览量比较大，并发高，我们会独立开启一个微服务，用来展示商品详情。 1.2.1.创建module 商品的详情页服务，命名为：ly-goods-page...
乐优商城笔记.zip
09-16
10. **微服务架构**：如果乐优商城采用微服务架构，那么笔记中可能讨论了服务拆分、服务注册与发现、服务间通信（如Dubbo或gRPC）等方面的知识。 11. **持续集成/持续部署(CI/CD)**：Jenkins或GitLab CI/CD可能被...
乐优商城官方笔记（全）
05-21
乐优商城官方笔记是针对一个电子商务平台的详细技术文档，旨在帮助开发者、运营人员以及对电商系统感兴趣的读者深入了解和掌握该平台的运作机制与核心技术。笔记涵盖了从平台架构设计、数据库模型、前端开发、后端...
黑马乐优商城19天全套视频加配套笔记
11-08
【标题】"黑马乐优商城19天全套视频加配套笔记"揭示了这是一套针对乐优商城项目的全面教学资源，由知名IT教育机构黑马程序员提供，并且是2018年的最新版本。课程可能涵盖了从项目启动到完成的全过程，总计19天的学习...
乐优商城19天(全)项目笔记
03-02
乐优商城19天(全)项目笔记是一个全面记录了基于SpringCloud微服务架构的电商平台开发过程的学习资源。这份笔记涵盖了从项目初始化到系统完善的所有关键环节，旨在帮助开发者深入理解SpringBoot、SpringCloud和Vue.js...
基于微服务的乐优商城《项目笔记》.rar
06-26
- 商品规格参数管理 - 商品管理 - 库存管理 我们先完成项目的搭建： ### 3.7.1.微服务的结构 因为与商品的品类相关，我们的工程命名为`ly-item`. 需要注意的是，我们的ly-item是一个微服务，那么将来肯定会有...
传智黑马乐优商城sql，表tb_spec_param，tb_spec_group和tb_spu_detail，和对应实体类
lyd的博客
07-02 2574
乐优商城sql，表tb_spec_param，tb_spec_group和tb_spu_detail，和对应实体类视频缺失的表对tb_spec_group和tb_spec_param转化过程最后 视频缺失的表 表的结构和实体类是暂停视频，跟着敲出来的，数据则是我根据表tb_specification的specifications，创建一个对应实体类，然后用java代码生成的，除了tb_spec_g...
乐优商城各个模块话术
技术高手
05-09 3674
我主要负责的是后台管理模块中商品的操作，我们后台管理系统是采用Vue+webpack+vue-cli+vue-route+Vuetify所构建的单页应用，所谓单页应用，就是我们一整个项目只有一个html页面，通过VueRoute根据路由规则来切换展示的页面，达到动态切换的效果，采用nginx反向代理，与前台项目共享一个微服务集群，使用axios来发起异步的ajax请求，达到前后端分离的结果，因为我们后台域名与后端域名不同，ajax请求默认不允许跨域，我们通过Cors来解决跨域问题，在商品的图片存储上，我们使
乐优商城（填坑）——秒杀商品添加
lyj2018gyq的博客
01-01 3478
一、需求 后台商品管理中，将商品添加到可秒杀商品列表 选中商品将其设置为可秒杀。 选择具体的参与秒杀的商品规格，然后设置相关参数，点击保存即可。 二、后端接口修改 原来的添加秒杀商品接口在leyou-secskill微服务中，现在将其移动到leyou-item中，代码如下： 2.1 Controller /** * 添加秒杀商品 * @param sec...
乐优商城介绍
lcczzu的专栏
09-08 8273
1.乐优商城介绍 1.1.项目介绍 乐优商城是一个全品类的电商购物网站（B2C）。 用户可以在线购买商品、加入购物车、下单、秒杀商品 可以品论已购买商品 管理员可以在后台管理商品的上下架、促销活动 管理员可以监控商品销售状况 客服可以在后台处理退款操作 希望未来3到5年可以支持千万用户的使用 1.2.系统架构 1.2.1.架构图 乐优商城架构缩略图，大图请参考课前资料： DevOps ngi...
乐优商城（十）商品管理
lyj2018gyq的博客
09-08 2561
目录 3.4 商品描述信息 3.4.1 富文本编辑器 3.4.2 Vue-Quill-Editor 3.4.3 使用方法 3.4.4 自定义富文本编辑器 3.4.5 效果 3.5 规格参数 3.5.1 查询商品规格 3.5.2 页面展示规格属性 3.6 SKU特有属性 3.6.1 筛选特有属性 3.6.2 页面渲染特有属性 3.6.3 自由添加和删除文本框 3.7 展示...
商品规格sku算法应用
by_ron的专栏
08-17 1万+
商品规格
乐优商城（十二）商品管理
lyj2018gyq的博客
09-10 4207
目录 四、商品修改 4.1 点击编辑出现弹窗 4.2 回显数据 4.2.1 存在的问题 4.2.2 解决方案 4.2.3 前端执行逻辑 4.3 效果 4.4 修改商品信息的后台接口 4.4.1 Controller 4.4.2 Mapper 4.4.3 Service 4.5 测试  五、商品删除 5.1 点击删除商品 5.2 后台接口 5.2.1 Controll...
乐优商城（一）项目介绍
热门推荐
lyj2018gyq的博客
08-23 5万+
GitHub：https://github.com/lyj8330328 目录 一，项目介绍 二，系统架构 2.1架构图 2.2架构图介绍 三，项目搭建 3.1技术选型 3.2域名 3.3后台管理系统搭建 3.3.1代码 3.3.2安装依赖 3.3.3运行测试 3.3.4项目结构 3.4前台门户搭建（暂略） 3.5服务搭建 ...
乐优商城 leyou-gateway 模块详解
weixin_46046477的博客
10-24 344
该模块是zuul网关，原本只需要配置一些路由即可。但是有一些东西要在这里进行统一配置（跨域、登录拦截）。 登录拦截部分： zuul网关提供的过滤方法： 过滤中的shouldFilter方法解释： 过滤方法中的run方法解释： yml文件： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值