2020年某外包工作的部分内容

 简述

2020年外包到某国际知名车企，2周时间做了一个核心模块，该模块几乎涉及到了该项目的至少10张表，且含有一定算法的实现。不是简单的crud，发布这个的目的只是证明自己有较强的逻辑和快速实现的能力。以下代码实现只是2周工作的一部分。由于篇幅问题无法全部展示。

截图

代码说明

初始化权益项

controller

 /***
     * 初始化权益项
     * @return
     */
    @GetMapping("/initRightItems/{resourceId}/{type}")
    @PreAuthorize("hasRole('ROLE_USER')")
    public ResponseEntity<List<GroupCodesDTO>> initRightItems(@PathVariable Long resourceId,@PathVariable String type) {
        CodeDTO cd = new CodeDTO();
        cd.setGroupCode(type);
        Optional<Resource> res = this.resourceRepository.findById(resourceId);
        if(res.isPresent()){
            cd.setProjectId(res.get().getProject().getId()+"");
        }
        log.debug("初始化权益项，首先加载所有的系统权益项！");
        List<GroupCodesDTO> groupCodesDTOS = resourceRightService.diplayInit(cd);
        return ResponseEntity.ok().body(groupCodesDTOS);
    }

service

/**
     * 完成初始化
     * @return
     */
    public List<GroupCodesDTO> diplayInit(CodeDTO cd) {
        // 抓取所有的权益项
        List<GroupCodeMapPo> groupCodesPos = stdCodesMapper.findAllCodes(cd);
        GroupCodesDTO groupCodesDTO = null;
        List<GroupCodesDTO> groupCodesDTOS = new ArrayList<>();
        // 按照组编号进行分组
        Map<Long, List<GroupCodeMapPo>> groupById = groupCodesPos.stream().collect(Collectors.groupingBy(GroupCodeMapPo::getGroupId));


        // 通过组编号 和  分组的权益项编号 抓取 权益组对象 和 权益组下所有的权益项
        for(Map.Entry<Long,List<GroupCodeMapPo>> entry : groupById.entrySet()) {

            groupCodesDTO = new GroupCodesDTO();
            Long groupId = entry.getKey();
            List<GroupCodeMapPo> list = entry.getValue();
            // 初始化从数据库中找到组信息
            StdCodesGroup stdCodesGroup = stdCodesGroupRepository.findById(groupId).get();
            GroupDTO groupDTO = new GroupDTO();
            BeanUtils.copyProperties(stdCodesGroup, groupDTO);

            List<CodeDTO> codeDTOS = new ArrayList<>();
            CodeDTO gcd = null;
            for(GroupCodeMapPo l : list) {
                // 分组的code从库中查询得到。
                gcd = stdCodesMapper.findByCodeId(l.getId());
                if(gcd != null)
                    codeDTOS.add(gcd);
            }
            groupCodesDTO.setCodes(codeDTOS);
            groupCodesDTO.setGroup(groupDTO);

            groupCodesDTOS.add(groupCodesDTO);

        }

        return groupCodesDTOS;
    }

分页查询权益包列表

controller

@PostMapping("/queryPagePacks")
    @PreAuthorize("hasRole('ROLE_USER')")
    public ResponseEntity<List<RightPackDTO>> getPagePackList(Pageable pageable ,@RequestBody RightPackVo rightPackVo) {
        log.debug("获取权益包列表到前端展示分页！");
        Page<RightPackDTO> packs = resourceRightService.findPagePacksByCondition(pageable, rightPackVo);

        List<RightPackDTO> results = new ArrayList<>();
        List<RightPackDTO> dtos = packs.getContent();
        RightPackDTO newPack = null;
        for(RightPackDTO dto : dtos) {
            newPack = new RightPackDTO();
            BeanUtils.copyProperties(dto, newPack);

            Long projectId = dto.getProjectId();
            try {
                //project = projectRepository.getOne(projectId);
                newPack.setFinishedNum(resourceRightService.countClosedTraces(projectId));
                int total = dto.getPackNum();
                if(total == 0) {
                    newPack.setPercent("0");
                }
                // 计算已经完成跟踪包占比
                BigDecimal number = new BigDecimal(newPack.getFinishedNum()).divide(new BigDecimal(total), 2, RoundingMode.HALF_UP);
                newPack.setPercent(number.toString());
            } catch (Exception e) {
            }


            results.add(newPack);
        }

        return ResponseEntity.ok().body(results);
    }

service

public Page<RightPackDTO> findPagePacksByCondition(Pageable pageable, RightPackVo rightPackVo) {

        Sort sort = pageable.getSort();
        String orderByFeild = OrderByFieldUtil.getAndFilterOrderByField(sort, rightPackOrderByFeildLists);

        rightPackVo.setOrderByField(orderByFeild);
        PageHelper.startPage(pageable.getPageNumber() + 1, pageable.getPageSize());

        List<RightPackDTO> packs = resourceRightsPackMapper.findPacksByCondition(rightPackVo);
        List<RightPackDTO> newPacks = new ArrayList<>();
        RightPackDTO newPack = null;
        for(RightPackDTO pack : packs) {
            newPack = new RightPackDTO();
            BeanUtils.copyProperties(pack, newPack);
            Long projectId = pack.getProjectId();
            Long resourceId = pack.getResourceId();
            Project project = null;
            try {
                project = projectRepository.getOne(projectId);
                pack.setFinishedNum(this.countClosedTraces(projectId));
                int total = pack.getPackNum();
                if(total == 0) {
                    pack.setPercent("0");
                }
                // 计算已经完成跟踪包占比
                BigDecimal number = new BigDecimal(pack.getFinishedNum()).divide(new BigDecimal(total), 2, RoundingMode.HALF_UP);
                pack.setPercent(number.toString());
            } catch (Exception e) {
            }

            if(project == null) continue;
            newPack.setProjectName(project.getName());
            newPack.setProjectId(project.getId());

            Resource resource = null;
            try {
                resource = resourceRepository.getOne(resourceId);
            } catch (Exception e) {
            }
            if(resource == null) continue;
            newPack.setResourceName(resource.getName());
            newPack.setResourceId(resource.getId());
            newPacks.add(newPack);

        }
        PageInfo pageInfo = new PageInfo<>(newPacks);
        Page<RightPackDTO> page = new PageImpl<>(pageInfo.getList(), pageable, pageInfo.getTotal());
        return page;
    }

根据权益包编号查询要修改的系统权益项和自定义权益项以及权益包信息

controller
    /**
     * 根据权益包编号查询要修改的系统权益项和自定义权益项以及权益包信息
     * @param id
     * @return
     */
@GetMapping("/queryRightPackAndItems/{id}")
    @PreAuthorize("hasRole('ROLE_USER')")
    public ResponseEntity<RightPackDTO> queryRightPackAndItems(@PathVariable Long id) throws Exception {
        log.debug("根据权益包编号查询要修改的权益项！");
        RightPackDTO rightPackDTO = new RightPackDTO();
        Optional<ResourceRightsPack> opt = resourceRightService.findOneRightPack(id);
        if(!opt.isPresent()) {
            throw new Exception("编号" + id + "权益包不存在！");
        }
        ResourceRightsPack rightsPack = opt.get();
        List<GroupCodesDTO> groupCodesDTOS = resourceRightService.findRightItemsByPackId(id, rightsPack.getTypeGroupCode(),rightsPack.getProject().getId());
        rightPackDTO.setGroupCodesDTOS(groupCodesDTOS);
        BeanUtils.copyProperties(rightsPack, rightPackDTO);

        return ResponseEntity.ok().body(rightPackDTO);
    }

service

    /**
     * 根据权益包编号查找所有的权益项
     * @param id
     * @return
     */
    public List<GroupCodesDTO> findRightItemsByPackId(Long id, String type,Long projectId) {
        // 所有的系统权益项列表
        CodeDTO cd = new CodeDTO();
        cd.setGroupCode(type);
        cd.setProjectId(projectId+"");
        List<CodeDTO> codeDTOS = stdCodesMapper.findAllActiveCodes(cd);

        // 所有持久化存库的权益项（含自定义和部分持久化的系统权益项）
        List<ResourceRightItem> rightItems = resourceRightsPackMapper.queryRightItemsByPackId(id);
        // 找出该权益包下所有自定义的持久化权益项
        List<ResourceRightItem> customItems = rightItems.stream().filter(o -> o.getCustom() == 1).collect(Collectors.toList());
        // 已经赋值的持久化系统权益项
        List<ResourceRightItem> markedRightItems =rightItems.stream().filter(o -> o.getCustom() == 0).collect(Collectors.toList());
        // 标记权益包编号已经持久化的权益项包装
        List<CodeDTO> markedCodes = new ArrayList<>();
        CodeDTO markedCode = null;
        for(ResourceRightItem markedRightItem : markedRightItems) {
            markedCode = new CodeDTO();
            BeanUtils.copyProperties(markedRightItem, markedCode);
            markedCode.setRightItemId(markedRightItem.getId()); //权益项编号 必须带上
            // note: 已经定义好了
            markedCode.setExternalCode(markedRightItem.getStdCodeName());

            // 标记为已经持久化
            long codeId = stdCodesMapper.findCodeIdByGroupAndInternalCode(markedRightItem.getGroupCode(), markedRightItem.getInternalCode());
            markedCode.setId(codeId);
            markedCodes.add(markedCode);
        }

        // 还未设置的系统权益项
        List<CodeDTO> unsetCodes = new ArrayList<>();
        for(CodeDTO codeDTO : codeDTOS) {
            boolean found = false;
            for(CodeDTO mark : markedCodes) {
                if(codeDTO.getGroupCode().equals(mark.getGroupCode())
                    && codeDTO.getInternalCode().equals(mark.getInternalCode())) {
                    found = true;
                    break;
                }
            }
            if(!found)
                unsetCodes.add(codeDTO);
        }
        // 自定义权益项
        List<CodeDTO> custumCodes = new ArrayList<>();
        CodeDTO customCode = null;
        for(ResourceRightItem item: customItems) {
            customCode = new CodeDTO();
            BeanUtils.copyProperties(item, customCode);
            // 自定义标记位 设置STD_CODE 的编号 为 -1
            customCode.setId(-1l);
            // BUG 这个是持久化到数据库的自定义权益项的 主键  必须有
            customCode.setRightItemId(item.getId());

            customCode.setExternalCode(item.getStdCodeName());

            custumCodes.add(customCode);
        }

        codeDTOS.clear();

        codeDTOS.addAll(unsetCodes);
        codeDTOS.addAll(markedCodes);
        List<GroupCodeMapPo> groupCodesPos = stdCodesMapper.findAllCodes(cd);
        GroupCodesDTO groupCodesDTO = null;
        List<GroupCodesDTO> groupCodesDTOS = new ArrayList<>();
        // 按照组编号进行分组
        Map<Long, List<GroupCodeMapPo>> groupById = groupCodesPos.stream().collect(Collectors.groupingBy(GroupCodeMapPo::getGroupId));

        for(Map.Entry<Long,List<GroupCodeMapPo>> entry : groupById.entrySet()) {

            groupCodesDTO = new GroupCodesDTO();
            Long groupId = entry.getKey();
            List<GroupCodeMapPo> list = entry.getValue();
            // 初始化从数据库中找到组信息
            StdCodesGroup stdCodesGroup = stdCodesGroupRepository.findById(groupId).get();
            GroupDTO groupDTO = new GroupDTO();
            BeanUtils.copyProperties(stdCodesGroup, groupDTO);

            List<CodeDTO> subCodeDTOS = new ArrayList<>();
            CodeDTO gcd = null;
            for(GroupCodeMapPo l : list) {
                // 不是初始化，分组的code从缓存中查询得到。
                gcd = null;
                try {
                    gcd = codeDTOS.stream().filter(o->o.getId() == l.getId()).findFirst().get();
                } catch (Exception e) {
                    gcd = null;
                }

                if(gcd != null)
                    subCodeDTOS.add(gcd);
            }
            groupCodesDTO.setCodes(subCodeDTOS);
            groupCodesDTO.setGroup(groupDTO);

            groupCodesDTOS.add(groupCodesDTO);

        }
        // 将自定义的分组加到 展示组中
        GroupDTO customGroupDTO = new GroupDTO();
        customGroupDTO.setId(-1l);
        customGroupDTO.setGroupCode(type+"_EXT");
        customGroupDTO.setGroupDesc("拓展权益");
        groupCodesDTO = new GroupCodesDTO();
        groupCodesDTO.setGroup(customGroupDTO);
        groupCodesDTO.setCodes(custumCodes);

        groupCodesDTOS.add(groupCodesDTO);

        return groupCodesDTOS;
    }

保存权益包和该权益包下所有权益项

controller

/***
     * 保存权益包和该权益包下所有权益项
     * @param rightPackPo
     * @return
     */
    @PostMapping("/saveOrUpdateRightItemsAndPack")
    @PreAuthorize("hasRole('ROLE_USER')")
    public ResponseEntity<Map<String,Object>> saveOrUpdateRightItemsAndPack(@RequestBody RightPackPo rightPackPo) {
        log.debug("获取权益包列表到前端展示分页！");
        Map<String,Object> result = new HashMap<>();

        result.put("success",true);
        try {
            resourceRightService.saveRightItemsAndPack(rightPackPo);
        } catch (Exception e) {
            result.put("success",false);
            result.put("error", e.getMessage());
        }

        return ResponseEntity.ok().body(result);
    }

service

/**
     * 保存权益包及该包下的所有的权益项
     * @param rightPackPo
     */
    public void saveRightItemsAndPack(RightPackPo rightPackPo) throws Exception {

        log.info("输入权益包对象={}", JSON.toJSONString(rightPackPo));

        // 初始化创建权益包对象
        ResourceRightsPack newRightsPack = new ResourceRightsPack();
        BeanUtils.copyProperties(rightPackPo, newRightsPack);

        // 设置资源对象
        Long resourceId = rightPackPo.getResourceId();
        boolean exist = resourceRepository.existsById(resourceId);
        if(!exist)
            throw new Exception("编号" + resourceId + "资源不存在！");
        log.info("权益包名称{}设置资源编号{}", rightPackPo.getPackName(), resourceId);
        Optional<Resource> resOption = resourceRepository.findById(resourceId);
        Resource resource = resOption.get();
        newRightsPack.setResource(resource);

        // 设置项目对象
        Long projectId = rightPackPo.getProjectId();
        exist = projectRepository.existsById(projectId);
        if(!exist)
            throw new Exception("编号" + projectId + "项目不存在！");
        log.info("权益包名称{}设置项目编号{}", rightPackPo.getPackName(), projectId);
        Optional<Project> projOption =  projectRepository.findById(projectId);
        Project project =  projOption.get();
        newRightsPack.setProject(project);

        newRightsPack = packRepository.save(newRightsPack);

        // 批量处理权益项并持久化
        List<RightItemPo> itemPos = rightPackPo.getItems();

        List<ResourceRightItem> newRightItems = new ArrayList<>();
        ResourceRightItem newRightItem = null;
        for(RightItemPo itemPo : itemPos) {
            newRightItem = new ResourceRightItem();
            BeanUtils.copyProperties(itemPo, newRightItem);
            // 设置资源对象
            newRightItem.setResource(resource);
            // 设置权益包对象
            newRightItem.setResourceRightsPack(newRightsPack);

            newRightItems.add(newRightItem);
        }
        resourceRightItemRepository.saveAll(newRightItems);

    }