商品服务-平台属性

一、商品服务-API-平台属性

1、规格参数

（1）PO、DO、TO、DTO

1．PO持久对象

PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据的操作。

2、DO（Domain 0bject)领域对象

就是从现实世界中推象出来的有形或无形的业务实体。

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

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

4.DTO(Data Transfer Obiect)数据传输对象

这个概念来源于J2EE的设汁模式，原来的目的是为了EJB的分布式应用握供粗粒度的数据实体，以减少分布式调用的次数，从而握分布式调用的性能和降低网络负载，但在这里，泛指用于示层与服务层之间的数据传输对象。

5.VO(value object)值对象

通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象，可以和表对应，也可以不，这根据业务的需要。用new关韃字创建，由GC回收的

View object：视图对象

接受页面传递来的对象，封装对象

将业务处理完成的对象，封装成页面要用的数据

6.BO(business object)业务对象

从业务模型的度看．见IJML元#领嵫模型的领嵫对象。封装业务逻辑的java对象，通过用DAO方法，结合PO,VO进行业务操作。businessobject:业务对象主要作用是把业务逻辑封装为一个对苤。这个对象可以包括一个或多个其它的对彖。比如一个简历，有教育经历、工怍经历、社会关系等等。我们可以把教育经历对应一个PO工作经历

7、POJO简单无规则java对象

8、DAO

（2）新增关联关系功能完善

Request URL: http://localhost:88/api/product/attr/save，现在的情况是，它在保存的时候，只是保存了attr，并没有保存attrgroup，为了解决这个问题，我们新建了一个vo/AttrVo.java，在原Attr基础上增加了attrGroupId字段，使得保存新增数据的时候，也保存了它们之间的关系

AttrServiceImpl

  @Transactional
    @Override
    public void saveAttr(AttrVo attr) {
    
    
        AttrEntity attrEntity = new AttrEntity();
        // 重要的工具,复制属性到对象
        BeanUtils.copyProperties(attr, attrEntity);
        //1、保存基本数据
        this.save(attrEntity);

        //2、保存关联关系
        AttrAttrgroupRelationEntity relationEntity = new AttrAttrgroupRelationEntity();
        relationEntity.setAttrGroupId(attr.getAttrGroupId());
        relationEntity.setAttrId(attrEntity.getAttrId());
        relationDao.insert(relationEntity);
    }

（3）规格参数列表

• 先用mp的正常分页查出来数据，得到Page对象
• 然后用PageUtils把分页信息得到，但里面的数据需要替换一下
• 替换数据是为了解决“不使用联表查询”

 @Override
    public PageUtils queryBaseAttrPage(Map<String, Object> params, Long catelogId) {
    
    

        QueryWrapper<AttrEntity> queryWrapper = new QueryWrapper<>();

        if (catelogId != 0) {
    
    
            queryWrapper.eq("catelog_id", catelogId);
        }

        // 获取key
        String key = (String) params.get("key");
        if (!StringUtils.isEmpty(key)) {
    
    
            queryWrapper.and((wrapper) -> {
    
    
                wrapper.eq("attr_id", key).or().like("attr_name", key);
            });
        }

        // 分页
        IPage<AttrEntity> page = this.page(
                new Query<AttrEntity>().getPage(params),
                queryWrapper

        );

        // 封装pageUtils
        PageUtils pageUtils = new PageUtils(page);
        // 1. 获取记录
        List<AttrEntity> records = page.getRecords();
        // 2. 重新处理，映射元素
        List<AttrResVo> resVoList = records.stream().map((attrEntity) -> {
    
    
            AttrResVo attrResVo = new AttrResVo();
            // 2.1 拷贝基本属性
            BeanUtils.copyProperties(attrEntity, attrResVo);
            // 2.2 设置分类和分组的名字

            // 关联表中根据属性id 查到 分组id
            AttrAttrgroupRelationEntity attrId = relationDao.selectOne(new QueryWrapper<AttrAttrgroupRelationEntity>().eq("attr_id", attrEntity.getAttrId()));
            // 根据 attrId 得到分组信息
            if (attrId != null) {
    
    
                AttrGroupEntity attrGroupEntity = attrGroupDao.selectById(attrId);
                // 设置分组名
                attrResVo.setGroupName(attrGroupEntity.getAttrGroupName());
            }
            // 设置分类名
            CategoryEntity categoryEntity = categoryDao.selectById(attrEntity.getCatelogId());
            if (categoryEntity != null) {
    
    
                attrResVo.setCatelogName(categoryEntity.getName());
            }

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

        pageUtils.setList(resVoList);
        return pageUtils;
    }

（4）规格参数修改

AttrServiceImpl

 // 信息回显
    @Override
    public AttrResVo getAttrInfo(Long attrId) {
    
    
        AttrResVo resVo = new AttrResVo();
        // 获取当前attr
        AttrEntity attrEntity = this.getById(attrId);
        // 基本属性拷贝到reVo
        BeanUtils.copyProperties(attrEntity, resVo);

        // 1.分组信息设置
        // 1.1 在关联表中查询 attr_id 对应的 分组信息
        AttrAttrgroupRelationEntity attrgroupRelation = relationDao.selectOne(new QueryWrapper<AttrAttrgroupRelationEntity>().eq("attr_id", attrId));
        if (attrgroupRelation != null) {
    
    
            // 1.2 根据分组关联信息得到分组id
            resVo.setAttrGroupId(attrgroupRelation.getAttrGroupId());
            // 1.3 设置分组名字
            AttrGroupEntity attrGroupEntity = attrGroupDao.selectById(attrgroupRelation.getAttrGroupId());
            if (attrGroupEntity != null) {
    
    
                resVo.setGroupName(attrGroupEntity.getAttrGroupName());
            }
        }

        // 2.设置分类信息
        // 2.1 设置分类id
        Long catelogId = attrEntity.getCatelogId();
        // 2.2 获取完整路径
        Long[] cateLogPath = categoryService.findCateLogPath(catelogId);
        resVo.setCatelogPath(cateLogPath);
        CategoryEntity categoryEntity = categoryDao.selectById(catelogId);
        if (categoryEntity != null) {
    
    
            resVo.setCatelogName(categoryEntity.getName());
        }
        return resVo;
    }

    // 修改数据
    @Override
    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(attr.getAttrId());
        // 条件
        QueryWrapper<AttrAttrgroupRelationEntity> wrapper = new QueryWrapper<AttrAttrgroupRelationEntity>().eq("attr_id", attr.getAttrId());

        Integer count = relationDao.selectCount(wrapper);
        if (count > 0) {
    
    
            // 更新
            relationDao.update(relationEntity, wrapper);
        } else {
    
    
            // 新增
            relationDao.insert(relationEntity);
        }

    }

2、销售属性

（1） 获取分类销售属性：

/product/attr/sale/list/{catelogId}

• 直接修改queryBaseAttrPage,增加参数type用于判断类型是base 还是 sale

 public PageUtils queryBaseAttrPage(Map<String, Object> params, Long catelogId, String type) {
    
    

        QueryWrapper<AttrEntity> queryWrapper = new QueryWrapper<AttrEntity>();
        // 判断type类型，是base 还是 sale
        queryWrapper.eq("attr_type", "base".equalsIgnoreCase(type) ? 1 : 0);

（2）优化

• 基本属性才需要进行分组信息设置
• common 中增加ProductConstant常量

public class ProductConstant {
    
    

    public enum AttrEnum{
    
    
        ATTR_TYPE_BASE(1,"基本属性"),ATTR_TYPE_SALE(0,"销售属性");
        private int code;
        private String msg;

        AttrEnum(int code, String msg) {
    
    
            this.code = code;
            this.msg = msg;
        }

if (attrEntity.getAttrType() == ProductConstant.AttrEnum.ATTR_TYPE_BASE.getCode()) {
    
    
            // 1.分组信息设置if (attrEntity.getAttrType() == ProductConstant.AttrEnum.ATTR_TYPE_BASE.getCode()) {
    
    
            // 1.分组信息设置

3、分组关联

（1）获取分组关联属性

AttrServiceImpl

/**
     * 根据分组id 查找所有关联属性
     *
     * @param attrgroupId
     * @return
     */
    @Override
    public List<AttrEntity> getRelationAttr(Long attrgroupId) {
    
    
        // 1. 查询关联表
        List<AttrAttrgroupRelationEntity> entities = relationDao.selectList(new QueryWrapper<AttrAttrgroupRelationEntity>().eq("attr_group_id", attrgroupId));

        // 2. 收集属性id attr_id
        List<Long> attrIds = entities.stream().map((attr) -> {
    
    
            return attr.getAttrId();
        }).collect(Collectors.toList());

		if (attrIds == null || attrIds.size() == 0) {
    
    
            return null;
        }

        // 3. 根据属性id集合查询所有信息
        List<AttrEntity> attrEntities = this.listByIds(attrIds);

        return attrEntities;
    }

（2）删除关联

AttrServiceImpl

   /**
     * 批量删除
     *
     * @param vos
     */
    @Override
    public void deleteRelations(AttrGroupRelationVo[] vos) {
    
    
        List<AttrAttrgroupRelationEntity> entities = Arrays.asList(vos).stream().map((item) -> {
    
    
            AttrAttrgroupRelationEntity relationEntity = new AttrAttrgroupRelationEntity();
            BeanUtils.copyProperties(item, relationEntity);
            return relationEntity;
        }).collect(Collectors.toList());

        relationDao.deleteBatchRelation(entities);
    }

AttrAttrgroupRelationDao.xml

   <delete id="deleteBatchRelation">
        delete from pms_attr_attrgroup_relation where
        <foreach collection="entities" item="item" separator=" OR ">
            (attr_id=#{
    
    item.attrId} AND attr_group_id=#{
    
    item.attrGroupId})
        </foreach>

    </delete>

（3）查询分组未关联属性

AttrServiceImpl

/**
     * 获取当前分组未关联的属性
     *
     * @param params
     * @param attrgroupId
     * @return
     */
    @Override
    public PageUtils getNoRelationAttr(Map<String, Object> params, Long attrgroupId) {
    
    
        // 1. 当前分组只能关联自己所属分类里面的所有属性
        //  1.1 获取当前分组信息
        AttrGroupEntity attrGroupEntity = attrGroupDao.selectById(attrgroupId);
        //  1.2 根据当前分组信息获取分类id
        Long catelogId = attrGroupEntity.getCatelogId();

        // 2. 当前分组只能关联别的分组没有引用的属性
        //  2.1 当前分类下的其他分组
        List<AttrGroupEntity> group = attrGroupDao.selectList(new QueryWrapper<AttrGroupEntity>()
                .eq("catelog_id", catelogId));

        List<Object> collect = group.stream().map((item) -> {
    
    
            return item.getAttrGroupId();
        }).collect(Collectors.toList());

        //  2.2 这些分组关联的属性
        List<AttrAttrgroupRelationEntity> groupId = relationDao.selectList(new QueryWrapper<AttrAttrgroupRelationEntity>()
                .in("attr_group_id", collect));

        List<Long> attrIds = groupId.stream().map((item) -> {
    
    
            return item.getAttrId();
        }).collect(Collectors.toList());

        //  2.3 从当前分类的所有属性中移除这些属性
        QueryWrapper<AttrEntity> wrapper = new QueryWrapper<AttrEntity>()
                .eq("catelog_id", catelogId)
                .eq("attr_type", ProductConstant.AttrEnum.ATTR_TYPE_BASE.getCode());
        if (attrIds != null && attrIds.size() > 0) {
    
    
            wrapper.notIn("attr_id", attrIds);

        }

        String key = (String) params.get("key");
        if (!StringUtils.isEmpty(key)) {
    
    
            wrapper.and((w) -> {
    
    
                w.eq("attr_id", key).or().like("attr_name", key);
            });
        }

        IPage<AttrEntity> page = this.page(new Query<AttrEntity>().getPage(params), wrapper);
        PageUtils pageUtils = new PageUtils(page);

        return pageUtils;
    }

（4）新增 分组与属性 关联