液态不合群
液态不合群

商品中心—B端建品和C端缓存的技术文档（二）

11.商品B端—商品审核时的敏感字段diff计算逻辑

审核时需要把Item和SKU的敏感字段的diff值显示出来，方便审核员审核。

@Service
public class AuditServiceImpl implements AuditService {
    ...
    //查询草稿详情信息
    @Override
    public DraftDetailDTO getDraftDetail(QueryDraftRequest queryDraftRequest) {
        //草稿详情信息
        DraftDetailDTO draftDetailDTO = productAuditRepository.getDraftDetail(queryDraftRequest.getTicketId());
        //构建需要比较不同的字段数据
        buildDiffChangeField(draftDetailDTO);
        return draftDetailDTO;
    }

    //构建需要比较不同的字段的数据
    private void buildDiffChangeField(DraftDetailDTO draftDetailDTO) {
        //草稿主表信息
        DraftMainDTO draftMainDTO = draftDetailDTO.getDraftMainDTO();
        //修改后的商品数据
        FullProductData fullProductData = JSON.parseObject(draftMainDTO.getFeatures(), FullProductData.class);

        //商品新增时，item版本号是0，草稿表中的版本号是item表中的版本号加1
        //所以此时判断草稿表中的版本号是小于等于1表示新增数据
        if (draftMainDTO.getVersionId() <= 1) {
            buildAddDiff(fullProductData, draftDetailDTO);
        } else {
            buildUpdateDiff(fullProductData, draftDetailDTO);
        }
    }

    //填充新增的 商品差异变化信息
    private void buildAddDiff(FullProductData fullProductData, DraftDetailDTO draftDetailDTO) {
        //item信息
        ItemInfoDO itemInfoDO = fullProductData.getItemInfoDO();
        List itemDiffValues = DiffFieldUtil.buildDiffField(itemInfoDO, null, itemDiffFields);
        //skuList diff 存放Map集合
        Map> skuDiffFieldsMap = null;
        //sku信息
        List skuInfoDOList = fullProductData.getSkuInfoDOList();
        if (!CollectionUtils.isEmpty(skuInfoDOList)) {
            skuDiffFieldsMap = new HashMap<>(skuInfoDOList.size());
            for (SkuInfoDO skuInfoDO : skuInfoDOList) {
                List skuDiffValues = DiffFieldUtil.buildDiffField(skuInfoDO, null, skuDiffFields);
                if (!CollectionUtils.isEmpty(skuDiffValues)) {
                    skuDiffFieldsMap.put(skuInfoDO.getSkuId(), skuDiffValues);
                }
            }
        }
        //填充商品数据变更的差异信息
        buildDiffInfo(itemDiffValues, skuDiffFieldsMap, draftDetailDTO);
    }

    //填充商品数据变更的差异信息
    private void buildDiffInfo(List itemDiffValues, Map> skuDiffFieldsMap, DraftDetailDTO draftDetailDTO) {
        //item变更字段
        if (!CollectionUtils.isEmpty(itemDiffValues)) {
            draftDetailDTO.setItemDiffFields(itemDiffValues);
        }
        //sku变更字段
        if (!CollectionUtils.isEmpty(skuDiffFieldsMap)) {
            draftDetailDTO.setSkuDiffFields(skuDiffFieldsMap);
        }
    }

    //填充修改的 商品差异变化信息
    private void buildUpdateDiff(FullProductData fullProductData, DraftDetailDTO draftDetailDTO) {
        //item信息
        ItemInfoDO itemInfoDO = fullProductData.getItemInfoDO();

        //先查询修改前itemInfoDO和修改前的skuInfoDOList，再比较变更值
        ItemInfoDO oldItemInfoDO = productInfoRepository.getItemByItemId(itemInfoDO.getItemId());
        List itemDiffValues = DiffFieldUtil.buildDiffField(itemInfoDO, oldItemInfoDO, itemDiffFields);

        List oldSkuInfoDOList = productInfoRepository.listSkuByItemId(itemInfoDO.getItemId());
        List skuInfoDOList = fullProductData.getSkuInfoDOList();
        List skuDiffValues;

        //skuList diff 存放Map集合
        Map> skuDiffFieldsMap = new HashMap<>();
        //旧的商品集合转换
        Map oldMap = oldSkuInfoDOList.stream().collect(Collectors.toMap(SkuInfoDO::getSkuId, e -> e));

        for (SkuInfoDO skuInfoDO : skuInfoDOList) {
            if (oldMap.containsKey(skuInfoDO.getSkuId())) {
                SkuInfoDO oldSkuInfoDO = oldMap.get(skuInfoDO.getSkuId());
                skuDiffValues = DiffFieldUtil.buildDiffField(skuInfoDO, oldSkuInfoDO, skuDiffFields);
                if (!CollectionUtils.isEmpty(skuDiffValues)) {
                    skuDiffFieldsMap.put(skuInfoDO.getSkuId(), skuDiffValues);
                }
            }
        }
        //填充修改的商品信息
        buildDiffInfo(itemDiffValues, skuDiffFieldsMap, draftDetailDTO);
    }
    ...
}

public class DiffFieldUtil {
    public static List buildDiffField(Object newObj, Object oldObj, List diffFields) {
        //oldObj为null表示新增，如果newObj与oldObj类型不同，则不处理
        if (!Objects.isNull(oldObj) && !newObj.getClass().equals(oldObj.getClass())) {
            return null;
        }
        List diffValues = new ArrayList<>();

        Field[] newObjFields = newObj.getClass().getDeclaredFields();
        Field[] oldObjFields = null;
        if (!Objects.isNull(oldObj)) {
            oldObjFields = oldObj.getClass().getDeclaredFields();
        }

        for (int i = 0; i < newObjFields.length; i++) {
            Field newObjField = newObjFields[i];
            //需要比较当前字段
            String fieldName = newObjField.getName();
            if (diffFields.contains(fieldName)) {
                try {
                    Object newValue = newObjField.get(fieldName);
                    if (Objects.isNull(oldObjFields) || !Objects.equals(oldObjFields[i].get(fieldName), newValue)) {
                        DiffValue diffValue = new DiffValue();
                        diffValue.setField(fieldName);
                        diffValue.setOldValue(Objects.isNull(oldObjFields) ? null : oldObjFields[i].get(fieldName));
                        diffValue.setNewValue(newValue);
                        diffValues.add(diffValue);
                    }
                } catch (IllegalAccessException e) {
                    log.error("获取字段值失败", e);
                }
            }
        }
        return diffValues;
    }
}

12.商品B端—对草稿中的商品进行审核的逻辑

//审批服务
@DubboService(version = "1.0.0", interfaceClass = AuditApi.class, retries = 0)
public class AuditApiImpl implements AuditApi {
    @Autowired
    private AuditService auditService;
    ...

    @Override
    public JsonResult execAudit(AuditRequest request) {
        try {
            ExecAuditDTO execAuditDTO = auditService.execAudit(request);
            return JsonResult.buildSuccess(execAuditDTO);
        } catch (ProductBizException e) {
            log.error("biz error: request={}", JSON.toJSONString(request), e);
            return JsonResult.buildError(e.getErrorCode(), e.getErrorMsg());
        } catch (Exception e) {
            log.error("system error: request={}", JSON.toJSONString(request), e);
            return JsonResult.buildError(e.getMessage());
        }
    }
}

//审核请求入参
@Data
public class AuditRequest extends BaseEntity implements Serializable {
    //工单id
    private Long ticketId;
    //审核状态 1-通过 3-拒绝
    private Integer auditStatus;
    //拒绝原因
    private String rejectReason;
    //操作人
    private Integer operatorUser;
}

@Service
public class AuditServiceImpl implements AuditService {
    ...
    //执行审核
    @Transactional
    @Override
    public ExecAuditDTO execAudit(AuditRequest auditRequest) {
        //验证是否有可以审核，并填充审核信息
        AuditInfoDTO auditInfoDTO = productAuditRepository.checkAudit(auditRequest);
        //执行审核
        execGoodsAudit(auditRequest, auditInfoDTO);
        //处理审核的信息DB变更
        productAuditRepository.updateAudit(auditRequest, auditInfoDTO);
        return new ExecAuditDTO(Boolean.TRUE);
    }

    //商品审核
    private void execGoodsAudit(AuditRequest auditRequest, AuditInfoDTO auditInfoDTO) {
        DraftMainDTO draftMainDTO = auditInfoDTO.getDraftMainDTO();
        Integer ticketType = auditInfoDTO.getTicketType();
        //如果是审批通过，则需要更改正式表的数据
        if (Objects.equals(auditRequest.getAuditStatus(), AuditStatusEnum.PASS.getCode())) {
            FullProductData fullProductData = JSON.parseObject(draftMainDTO.getFeatures(), FullProductData.class);
            //建品审核
            if (Objects.equals(ticketType, AuditTypeEnum.GOODS.getCode())) {
                fullProductData.getItemInfoDO().setVersionId(draftMainDTO.getVersionId());
                //产品信息入库；版本号小于等于1，表示新增，否则表示修改
                if (fullProductData.getItemInfoDO().getVersionId() <= 1) {
                    productInfoRepository.saveItemInfo(fullProductData);
                } else {
                    productInfoRepository.updateItemInfo(fullProductData);
                }
            } else if (Objects.equals(ticketType, AuditTypeEnum.PRICE.getCode())) {
                SkuInfoDO skuInfoDO = fullProductData.getSkuInfoDOList().get(0);
                productInfoRepository.saveRecord(skuInfoDO);
            }
        }
    }
    ...
}

//商品审核 资源管理
@Repository
public class ProductAuditRepository {
    ...
    //验证是否可审核，并返回审核对象
    public AuditInfoDTO checkAudit(AuditRequest auditRequest) {
        Long ticketId = auditRequest.getTicketId();
        //查询审核工单
        AuditInfoDO auditInfoDO = auditInfoMapper.selectById(ticketId);
        if (Objects.isNull(auditInfoDO)) {
            throw new ProductBizException(AuditExceptionCode.USER_AUDIT_INFO_NULL);
        }
        AuditInfoDTO auditInfoDTO = auditConverter.convertAuditDTO(auditInfoDO);
        //获取审核工单的详情
        DraftMainDO draftMainDO = getByTicketId(ticketId);
        if (Objects.isNull(draftMainDO)) {
            throw new ProductBizException(AuditExceptionCode.USER_AUDIT_INFO_NULL.getErrorCode(), "审核工单详情信息不存在");
        }
        //验证权限是否满足
        AuditorListConfigDO auditorListConfigDO = getAuditorRuleByUserId(auditRequest.getOperatorUser());
        if (Objects.isNull(auditorListConfigDO)) {
            throw new ProductBizException(AuditExceptionCode.USER_AUDIT_RULE_NULL);
        }
        //不是超级审核权限，并且拥有的审核权限与审核类型不一致
        if (!Objects.equals(AuditorRoleEnum.ADMIN.getCode(), auditorListConfigDO.getAuditorRole())
                && !Objects.equals(draftMainDO.getTicketType(), auditorListConfigDO.getAuditorRole())) {
            throw new ProductBizException(ProductErrorCodeEnum.AUDIT_ERROR);
        }
        auditInfoDTO.setDraftMainDTO(auditConverter.convertDTO(draftMainDO));
        return auditInfoDTO;
    }

    //修改审核信息
    public void updateAudit(AuditRequest auditRequest, AuditInfoDTO auditInfoDTO) {
        DraftMainDTO draftMainDTO = auditInfoDTO.getDraftMainDTO();
        //软删除草稿表数据
        deleteDraftMain(draftMainDTO);
        //修改审核表信息
        updateAudit(auditInfoDTO, auditRequest);
        //新增审核历史记录
        saveAuditHistory(auditRequest);
    }

    //逻辑删除草稿表数据
    private void deleteDraftMain(DraftMainDTO draftMainDTO) {
        DraftMainDO draftMainDO = auditConverter.converterDO(draftMainDTO);
        draftMainDO.setDelFlag(DelFlagEnum.DISABLED.getCode());
        //草稿表数据删除
        int count = draftMainMapper.updateById(draftMainDO);
        if (count <= 0) {
            throw new ProductBizException(AuditExceptionCode.AUDIT_SQL);
        }
    }

    //修改审核表信息
    private void updateAudit(AuditInfoDTO auditInfoDTO, AuditRequest auditRequest) {
        AuditInfoDO auditInfoDO = auditConverter.convertAuditDO(auditInfoDTO);
        auditInfoDO.setTicketStatus(auditRequest.getAuditStatus());
        auditInfoDO.setUpdateUser(auditRequest.getOperatorUser());
        auditInfoDO.setUpdateTime(new Date());
        int count = this.auditInfoMapper.updateById(auditInfoDO);
        if (count <= 0) {
            throw new ProductBizException(AuditExceptionCode.AUDIT_SQL);
        }
    }

    //新增审核历史记录
    private void saveAuditHistory(AuditRequest auditRequest) {
        AuditHistoryDO auditHistoryDO = auditConverter.converterHistoryDO(auditRequest);
        auditHistoryDO.initCommon();
        int count = this.auditHistoryMapper.insert(auditHistoryDO);
        if (count <= 0) {
            throw new ProductBizException(AuditExceptionCode.AUDIT_SQL);
        }
    }
    ...
}

13.商品B端—商品属性 + 买手 + 品类的数据维护

(1)商品属性数据维护

//新增/编辑规格请求入参
@Data
public class AttributeRequest implements Serializable {
    //规格键信息
    private AttributeKeyRequest attributeKeyRequest;
    //规格值信息
    private List attributeValueRequests;
    //操作人
    @NotNull(message = "操作人[operateUser]不能为空")
    private Integer operateUser;

    @Data
    public static class AttributeKeyRequest implements Serializable {
        //属性key编码
        private String keyCode;
        //属性key名称
        private String keyName;
        //扩展字段
        private String features;
        //排序
        private Integer keySort;
        //删除标记（1-有效，0-删除）
        private Integer delFlag;
    }

    @Data
    public static class AttributeValueRequest implements Serializable {
        //属性key编码
        private String keyCode;
        //属性value名称
        private String valueName;
        //扩展字段
        private String features;
        //排序
        private Integer valueSort;
        //删除标记（1-有效，0-删除）
        private Integer delFlag;
    }
}

//规格服务
@Service
public class AttributeServiceImpl implements AttributeService {
    @Resource
    private AttributeRepository attributeRepository;

    //新增/编辑规格键值接口
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AttributeResultDTO saveAttribute(AttributeRequest attributeRequest) {
        //入参检查
        this.checkAttributeRequestParam(attributeRequest);
        //保存规格信息
        attributeRepository.saveAttribute(attributeRequest);
        //返回结果
        return new AttributeResultDTO(Boolean.TRUE);
    }

    //入参检查
    private void checkAttributeRequestParam(AttributeRequest attributeRequest) {
        ParamCheckUtil.checkObjectNonNull(attributeRequest);
        //规格键信息
        AttributeRequest.AttributeKeyRequest attributeKeyRequest = attributeRequest.getAttributeKeyRequest();
        ParamCheckUtil.checkObjectNonNull(attributeKeyRequest);
        //规格值信息
        List attributeValueRequests = attributeRequest.getAttributeValueRequests();
        ParamCheckUtil.checkCollectionNonEmpty(attributeValueRequests);
    }
    ...
}

(2)买手数据维护

//新增/编辑买手请求入参
@Data
public class BuyerRequest implements Serializable {
    private Long id;
    //真实姓名
    private String realName;
    //花名
    private String roster;
    //买手图像
    private String imageUrl;
    //介绍
    private String description;
    //负责的品类ID
    private String categoryId;
    //删除标记（1-有效，0-删除）
    private Integer delFlag;
    //操作人
    @NotNull(message = "操作人[operateUser]不能为空")
    private Integer operateUser;
}

//买手服务
@Service
public class BuyerServiceImpl implements BuyerService {
    @Resource
    private BuyerRepository buyerRepository;

    @Override
    public BuyerResultDTO saveBuyer(BuyerRequest buyerRequest) {
        //保存买手信息
        buyerRepository.saveOrUpdate(buyerRequest);
        //返回结果信息
        return new BuyerResultDTO(Boolean.TRUE);
    }

    @Override
    public BuyerListDTO getBuyerInfo(QueryBuyerListRequest queryBuyerListRequest) {
        List buyerInfoDTOS = buyerRepository.listBuyerInfo(queryBuyerListRequest);
        //返回信息
        return new BuyerListDTO(buyerInfoDTOS);
    }

    @Override
    public PageResult getBuyerInfoPage(QueryBuyerPageRequest queryBuyerPageRequest) {
        return buyerRepository.pageResult(queryBuyerPageRequest);
    }
}

(3)品类数据维护

//新增/编辑品类请求入参
@Data
public class CategoryRequest implements Serializable {
    //id
    private Long id;
    //品类名称
    @NotNull(message = "品类名称[categoryName]不能为空")
    private String categoryName;
    //父ID（一级类目父ID为0）
    private Integer parentId;
    //排序（正整数，数字越小越靠前）
    @NotNull(message = "排序[categorySort]不能为空")
    private Integer categorySort;
    //图标icon
    private String icon;
    //目录是否展示（1-是，0-否）
    private Integer showMark;
    //是否是末级类目
    @NotNull(message = "末级类目[lastFlag]不能为空")
    private Integer lastFlag;
    //渠道（1-每日生鲜、2-美团、3-饿了么、4-淘鲜达、5-招商银行）
    @NotNull(message = "渠道[channel]不能为空")
    private Integer channel;
    //卖家类型（1-自营，2-POP）
    @NotNull(message = "卖家类型[sellerType]不能为空")
    private Integer sellerType;
    //扩展字段
    private String feature;
    //删除标记（1-有效，0-删除）
    private Integer delFlag;
    //操作人
    @NotNull(message = "操作人[operateUser]不能为空")
    private Integer operateUser;
}

//商品品类信息
@Service
public class CategoryInfoServiceImpl implements CategoryInfoService {
    @Resource
    private CategoryRepository categoryRepository;

    @Resource
    private CategoryInfoConverter categoryInfoConverter;

    //查询品类树
    @Override
    public List selectTree(QueryCategoryRequest categoryQueryRequest) {
        return categoryInfoConverter.converterTreeList(categoryRepository.selectTree(categoryQueryRequest));
    }

    //查询某个层级下的品类树(默认不带条件查询父类)
    @Override
    public List selectChild(QueryCategoryRequest categoryQueryRequest) {
        //查询某个层级的品类树
        List categoryInfoList = categoryRepository.listBy(categoryQueryRequest);
        //返回查询结果
        return categoryInfoConverter.converterList(categoryInfoList);
    }

    //保存/修改品类信息
    @Override
    public CategoryResultDTO saveCategory(CategoryRequest categoryRequest) {
        //保存品类树
        categoryRepository.saveOrUpdate(categoryRequest);
        //返回结果信息
        return new CategoryResultDTO(Boolean.TRUE);
    }

    //查询品类信息列表
    @Override
    public List selectListByLike(QueryCategoryListRequest categoryListRequest) {
        return categoryInfoConverter.converterList(categoryRepository.selectListByLike(categoryListRequest));
    }
}

14.商品C端—通用缓存读写组件的实现逻辑

下面以获取前台类目为例，去说明先读缓存再读DB的通用缓存读写组件的逻辑。

FrontCategoryCache继承自Redis缓存抽象类AbstractRedisStringCache，这个抽象类中会有一个模版方法listRedisStringData()，该方法可以根据关键字来批量获取数据，并且会调用通用缓存读写组件的listRedisStringDataByCache()方法。

其中，listRedisStringDataByCache()方法需要传入两个方法：一个是获取Redis的key的方法，一个是从DB查询数据的方法。

//商品前台类目服务
@DubboService(version = "1.0.0", interfaceClass = FrontCategoryApi.class, retries = 0)
public class FrontCategoryApiImpl implements FrontCategoryApi {
    @Resource
    private FrontCategoryCache frontCategoryStringSource;

    @Resource
    private FrontCategoryConverter frontCategoryConverter;

    //基于通用缓存读写组件，去获取前台类目
    @Override
    public JsonResult> getFrontCategory(FrontCategoryQuery frontCategoryQuery) {
        //入参校验
        checkParams(frontCategoryQuery);
        List frontCategoryIdList = Arrays.asList(String.valueOf(frontCategoryQuery.getFrontCategoryId()));
        //基于通用缓存读写组件，先读缓存再读DB来获取前台类目
        Optional> optional = frontCategoryStringSource.listRedisStringData(frontCategoryIdList);
        if (!optional.isPresent()) {
            JsonResult.buildSuccess();
        }
        List frontCategoryDTOList = frontCategoryConverter.converterFrontCategoryList(optional.get());
        return JsonResult.buildSuccess(frontCategoryDTOList);
    }
    ...
}

//Redis(String)缓存抽象类：是数据对象、是缓存对象
public abstract class AbstractRedisStringCache {
    @Resource
    private RedisReadWriteManager redisReadWriteManager;
    ...

    //根据关键字批量获取数据
    public Optional> listRedisStringData(List keyList) {
        if (CollectionUtils.isEmpty(keyList)) {
            return Optional.empty();
        }

        //下面会调用通用缓存读写组件RedisReadWriteManager的listRedisStringDataByCache()方法
        //getBOClass()需要子类实现
        //getPendingRedisKey()也需要子类实现
        //最后的匿名函数中，也使用了多个需要子类实现的方法：getTableFieldsMap()、getStringDatabase()、convertDO2BO()
        Optional> boListOpt = redisReadWriteManager.listRedisStringDataByCache(keyList, getBOClass(), this::getRedisKey, (key) -> {
            Map tableFieldsMap = getTableFieldsMap(key);
            Optional doOpt;
            try {
                doOpt = getStringDatabase().getTableData(tableFieldsMap, queryType());
            } catch (Exception e) {
                log.error("根据关键字批量获取数据出现异常 key={},paramMap={}", key, tableFieldsMap, e);
                return Optional.empty();
            }
            if (!doOpt.isPresent()) {
                return Optional.empty();
            }
            List boList = convertDO2BO(Arrays.asList(doOpt.get()));
            if (CollectionUtils.isEmpty(boList)) {
                return Optional.empty();
            }
            return Optional.of(boList.get(0));
        });
        return boListOpt;
    }

    //获取Redis key
    protected String getRedisKey(String key) {
        return String.format(getPendingRedisKey(), key);
    }

    //获取BO对象的Class
    protected abstract Class getBOClass();
    //获取待处理的Redis Key
    protected abstract String getPendingRedisKey();
    //关联表字段值
    protected abstract Map getTableFieldsMap(String key);
    //获取DB读取对象
    protected abstract RedisStringDatabase getStringDatabase();
    //DO转BO
    protected abstract List convertDO2BO(Collection doList);
    ...
}

@Service("frontCategoryStringSource")
public class FrontCategoryCache extends AbstractRedisStringCache {
    @Resource
    private FrontCategoryStringDatabase frontCategoryStringDatabase;
    ...

    //获取BO对象的Class
    @Override
    protected Class getBOClass() {
        return FrontCategoryBO.class;
    }

    //获取待处理的Redis Key
    @Override
    protected String getPendingRedisKey() {
        return AbstractRedisKeyConstants.FRONT_CATEGORY_STRING;
    }

    @Override
    protected RedisStringDatabase getStringDatabase() {
        return frontCategoryStringDatabase;
    }

    //DO转BO
    @Override
    protected List convertDO2BO(Collection frontCategoryDOList) {
        if (CollectionUtils.isEmpty(frontCategoryDOList)) {
            return null;
        }
        List result = Lists.newArrayList();
        for (FrontCategoryDO frontCategoryDO : frontCategoryDOList) {
            FrontCategoryBO frontCategoryBO = new FrontCategoryBO();
            BeanUtils.copyProperties(frontCategoryDO, frontCategoryBO);
            result.add(frontCategoryBO);
        }
        return result;
    }
    ...
}

@Service("frontCategoryStringDatabase")
public class FrontCategoryStringDatabase extends AbstractRedisStringDatabase {
    ...
    //获取表数据
    @Override
    public Optional getTableData(Map tableFieldsMap, String queryType) {
        if (tableFieldsMap.containsKey(ID)) {
            QueryWrapper queryWrapper = new QueryWrapper<>();
            queryWrapper.in("ID", Sets.newHashSet(Integer.valueOf(tableFieldsMap.get(ID).toString())));
            List frontCategoryDOList = frontCategoryMapper.selectList(queryWrapper);

            if (!CollectionUtils.isEmpty(frontCategoryDOList)) {
                FrontCategoryDO doBase = frontCategoryDOList.get(0);
                if (Objects.equals(DelFlagEnum.EFFECTIVE.getCode(), doBase.getDelFlag())) {
                    return Optional.of(doBase);
                }
            }
            return Optional.empty();
        }
        throw new UnsupportedOperationException();
    }
    ...
}

//通用缓存读写组件
@Service
public class RedisReadWriteManager {
    @Resource
    private RedisCache redisCache;

    @Resource
    private RedisLock redisLock;
    ...

    //批量获取缓存数据
    //@param keyList             关键字列表
    //@param clazz               需要将缓存JSON转换的对象
    //@param getRedisKeyFunction 获取Redis key的方法
    //@param getDbFuction        获取数据源对象的方法
    //@return java.util.Optional>
    public  Optional> listRedisStringDataByCache(List keyList, Class clazz, 
            Function getRedisKeyFunction, Function> getDbFuction) {
        try {
            List list = Lists.newArrayList();
            List pendingKeyList = keyList.stream().distinct().collect(toList());
            List redisKeyList = pendingKeyList.stream().map(getRedisKeyFunction).distinct().collect(toList());
            List cacheList = redisCache.mget(redisKeyList);
            for (int i = 0; i < cacheList.size(); i++) {
                String cache = cacheList.get(i);
                //过滤无效缓存
                if (EMPTY_OBJECT_STRING.equals(cache)) {
                    continue;
                }
                if (StringUtils.isNotBlank(cache)) {
                    T t = JSON.parseObject(cache, clazz);
                    list.add(t);
                    continue;
                }
                //缓存没有则读库
                Optional optional = getRedisStringDataByDb(pendingKeyList.get(i), getRedisKeyFunction, getDbFuction);
                if (optional.isPresent()) {
                    list.add(optional.get());
                }
            }
            return CollectionUtils.isEmpty(list) ? Optional.empty() : Optional.of(list);
        } catch (Exception e) {
            log.error("批量获取缓存数据异常 keyList={},clazz={}", keyList, clazz, e);
            throw e;
        }
    }

    //查询数据库表的数据并赋值到Redis
    public  Optional getRedisStringDataByDb(String key, Function getRedisKeyFunction, Function> getDbFuction) {
        if (StringUtils.isEmpty(key) || Objects.isNull(getDbFuction)) {
            return Optional.empty();
        }
        try {
            //使用分布式锁
            if (!redisLock.lock(key)) {
                return Optional.empty();
            }
            String redisKey = getRedisKeyFunction.apply(key);
            Optional optional = getDbFuction.apply(key);
            if (!optional.isPresent()) {
                //把空对象暂存到Redis
                redisCache.setex(redisKey, EMPTY_OBJECT_STRING, RedisKeyUtils.redisKeyRandomTime(INT_EXPIRED_ONE_DAY, TimeUnit.HOURS, NUMBER_24));
                log.warn("发生缓存穿透 redisKey={}", redisKey);
                return optional;
            }
            //把表数据对象存到Redis
            redisCache.setex(redisKey, JSON.toJSONString(optional.get()), RedisKeyUtils.redisKeyRandomTime(INT_EXPIRED_SEVEN_DAYS));
            log.info("表数据对象存到redis redisKey={}, data={}", redisKey, optional.get());
            return optional;
        } finally {
            redisLock.unlock(key);
        }
    }
    ...
}

15.商品C端—接口代码实现逻辑

(1)获取前台类目下的商品列表

FrontCategoryRelationCache和SkuCollectCache这两个缓存类，都继承自抽象类AbstractRedisStringCache，并使用了通用缓存读写组件RedisReadWriteManager。

//商品前台类目服务
@DubboService(version = "1.0.0", interfaceClass = FrontCategoryApi.class, retries = 0)
public class FrontCategoryApiImpl implements FrontCategoryApi {
    @Resource
    private FrontCategoryRelationCache frontCategoryRelationCache;

    @Resource
    private SkuCollectCache skuCollectCache;

    @Resource
    private FrontCategoryConverter frontCategoryConverter;
    ...

    //获取前台类目下的商品列表
    @Override
    public JsonResult getFrontCategorySkuList(FrontCategoryQuery frontCategoryQuery) {
        //入参校验
        checkParams(frontCategoryQuery);
        List frontCategoryIdList = Arrays.asList(String.valueOf(frontCategoryQuery.getFrontCategoryId()));

        //查询前端类目下关联的商品sku信息
        Optional> optiona = frontCategoryRelationCache.listRedisStringData(frontCategoryIdList);
        if (!optiona.isPresent()) {
            JsonResult.buildSuccess();
        }
        //填充商品的sku信息
        List frontCategoryRelationBOS = optiona.get();
        List skuIdList = frontCategoryRelationBOS.stream().map(FrontCategoryRelationBO::getParticipateId).collect(Collectors.toList());

        Optional> optional = skuCollectCache.listRedisStringData(skuIdList);
        if (!optional.isPresent()) {
            JsonResult.buildSuccess();
        }
        List skuList = frontCategoryConverter.converterObjectList(optional.get());
        return JsonResult.buildSuccess(new FrontCategorySkuRelationDTO(skuList));
    }
    ...
}

@Service("frontCategoryRelationCache")
public class FrontCategoryRelationCache extends AbstractRedisStringCache {
    @Resource
    private FrontCategoryRelationStringDatabase frontCategoryRelationStringDatabase;

    @Override
    protected Class getBOClass() {
        return FrontCategoryRelationBO.class;
    }

    @Override
    protected String getPendingRedisKey() {
        return AbstractRedisKeyConstants.FRONT_CATEGORY_ITEM_RELATION_SET;
    }

    @Override
    protected RedisStringDatabase getStringDatabase() {
        return frontCategoryRelationStringDatabase;
    }
    ...
}

@Service("frontCategoryRelationStringDatabase")
public class FrontCategoryRelationStringDatabase extends AbstractRedisStringDatabase {
    ...
    @Override
    public Optional getTableData(Map tableFieldsMap, String queryType) {
        if (tableFieldsMap.containsKey(FRONT_CATEGORY_ID)) {
            List frontCategoryDOList = frontCategoryMapper.queryFrontCategoryList(Arrays.asList(Long.valueOf(tableFieldsMap.get(FRONT_CATEGORY_ID).toString())));

            if (!CollectionUtils.isEmpty(frontCategoryDOList)) {
                FrontCategoryRelationDO doBase = frontCategoryDOList.get(0);
                if (Objects.equals(DelFlagEnum.EFFECTIVE.getCode(), doBase.getDelFlag())) {
                    return Optional.of(doBase);
                }
            }
            return Optional.empty();
        }
        throw new UnsupportedOperationException();
    }
    ...
}

//Redis(string)缓存抽象类：数据对象、缓存对象
public abstract class AbstractRedisStringCache {
    @Resource
    private RedisReadWriteManager redisReadWriteManager;
    ...

    //根据关键字批量获取数据
    public Optional> listRedisStringData(List keyList) {
        if (CollectionUtils.isEmpty(keyList)) {
            return Optional.empty();
        }
        //下面会调用通用缓存读写组件RedisReadWriteManager的listRedisStringDataByCache()方法
        //getBOClass()需要子类实现
        //getPendingRedisKey()也需要子类实现
        //最后的匿名函数中，也使用了多个需要子类实现的方法：getTableFieldsMap()、getStringDatabase()、convertDO2BO()
        Optional> boListOpt = redisReadWriteManager.listRedisStringDataByCache(keyList, getBOClass(), this::getRedisKey, (key) -> {
            Map tableFieldsMap = getTableFieldsMap(key);
            Optional doOpt;
            try {
                doOpt = getStringDatabase().getTableData(tableFieldsMap, queryType());
            } catch (Exception e) {
                log.error("根据关键字批量获取数据出现异常 key={},paramMap={}", key, tableFieldsMap, e);
                return Optional.empty();
            }
            if (!doOpt.isPresent()) {
                return Optional.empty();
            }
            List boList = convertDO2BO(Arrays.asList(doOpt.get()));
            if (CollectionUtils.isEmpty(boList)) {
                return Optional.empty();
            }
            return Optional.of(boList.get(0));
        });
        return boListOpt;
    }

    //获取Redis key
    protected String getRedisKey(String key) {
        return String.format(getPendingRedisKey(), key);
    }
    ...
} 
  
 
  
(2)获取商品信息和详情接口
 
  
 
  
ItemCollectCache和ProductDetailCache这两个缓存类，都继承自抽象类AbstractRedisStringCache，并使用了通用缓存读写组件RedisReadWriteManager。
 
  
 
  
@DubboService(version = "1.0.0", interfaceClass = ProductCollectApi.class, retries = 0)
public class ProductCollectApiImpl implements ProductCollectApi {
    @Resource
    private ItemCollectCache itemCollectCache;

    @Resource
    private ProductDetailCache productDetailCache;
    ...

    //根据itemId或skuId获取商品信息
    @Override
    public JsonResult> getProductCollect(ProductCollectQuery productCollectQuery) {
        if (Objects.isNull(productCollectQuery) || CollectionUtils.isEmpty(productCollectQuery.getProductIdList())) {
            return JsonResult.buildError(ProductErrorCodeEnum.PARAM_ERROR.getErrorCode(), ProductErrorCodeEnum.PARAM_ERROR.getErrorMsg());
        }
        if (productCollectQuery.getProductIdList().size() > BaseConstants.LIMIT_100) {
            return JsonResult.buildError(ProductErrorCodeEnum.PRODUCT_LIMIT_ERROR.getErrorCode(), ProductErrorCodeEnum.PRODUCT_LIMIT_ERROR.getErrorMsg());
        }

        Set productIdSet = Sets.newHashSet(productCollectQuery.getProductIdList());
        Set itemIdSet = productIdSet.stream().filter(NumberUtils::isItem).collect(Collectors.toSet());

        List itemInfoBOList = Lists.newArrayList();
        if (!CollectionUtils.isEmpty(itemIdSet)) {
            Optional> itemOptional = itemCollectCache.listRedisStringData(Lists.newArrayList(itemIdSet));
            if (itemOptional.isPresent()) {
                itemInfoBOList = itemOptional.get();
            }
        }
        //获取sku相关信息
        ProductBO productBO = buildSkuInfoList(productCollectQuery, itemInfoBOList);
        return JsonResult.buildSuccess(buildProductCollect(productBO.getItemInfoBOList(), productBO.getSkuInfoBOList(), productBO.getPriceBOList()));
    }

    //根据skuId获取商品详情
    @Override
    public JsonResult getProductDetail(ProductDetailQuery productDetailQuery) {
        if (Objects.isNull(productDetailQuery) || Objects.isNull(productDetailQuery.getSkuId())) {
            return JsonResult.buildError(ProductErrorCodeEnum.PARAM_ERROR.getErrorCode(), ProductErrorCodeEnum.PARAM_ERROR.getErrorMsg());
        }

        List productIdList = Arrays.asList(productDetailQuery.getSkuId());
        Optional> optional = productDetailCache.listRedisStringData(productIdList);
        if (optional.isPresent()) {
            List productDetailBOS = optional.get();
            ProductDetailDTO productDetailDTO = productDetailConverter.converterDetail(productDetailBOS.get(0));
            return JsonResult.buildSuccess(productDetailDTO);
        }
        return JsonResult.buildSuccess();
    }
    ...
}
 
  
 
  
 
   
文章转载自：东阳马生架构
 
   
原文链接：商品中心—1.B端建品和C端缓存的技术文档 - 东阳马生架构 - 博客园
 
   
体验地址：JNPF快速开发平台
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(windows)

        

            

                
    
                    
  • 15个小技巧，让我的Windows电脑更好用了！
                        曹元_

                        
    01.桌面及文档处理第一部分的技巧，主要是围绕桌面的一些基本操作，包括主题设置、常用文档文件快捷打开的多种方式等等。主题换色默认情况下，我们的Win界面可能就是白色的文档界面，天蓝色的图表背景，说不出哪里不好看，但是就是觉得不够高级。imageimage说到高级感，本能第一反应就会和暗色模式联想起来，如果我们将整个界面换成黑夜模式的话，它会是这样的。imageimage更改主题颜色及暗色模式，我们
    
                    
    • 
                    
  • 9、汇编语言编程入门：从环境搭建到简单程序实现
                        神经网络酱
汇编语言MEPISGNU工具链
                        
    汇编语言编程入门：从环境搭建到简单程序实现1.数据存储介质问题解决在处理数据存储时，若要使用MEPIS系统，需确保有其可访问的存储介质。目前，MEPIS无法向采用NTFS格式（常用于Windows2000和XP工作站）的硬盘写入数据。不过，若硬盘采用FAT32格式，MEPIS就能进行写入操作。此外，MEPIS还能将文件写入软盘和大多数USB闪存驱动器。若工作站连接到局域网，还可通过FTP协议或挂载
    
                    
    • 
                    
  • MotionLCM 部署优化 踩坑解决bug
                        AI算法网奇
aigc与数字人深度学习宝典文生motion
                        
    目录依赖项windowstorchok：渲染黑白图问题解决：humanml3d：sentence-t5-large下载数据：报错：Nomodulenamed'sentence_transformers'继续报错：fromtransformers.integrationsimportCodeCarbonCallback解决方法：推理相关转mesh：module‘matplotlib.cm‘hasno
    
                    
    • 
                    
  • EasyPlayer播放器系列开发计划2025
                        xiejiashu
EasyPlayerEasyPlayerEasyPlayer播放器RTSP播放器js播放器Web播放器
                        
    EasyPlayer系列产品发展至今，已经超过10年，从最早的EasyPlayerRTSP播放器，到如今维护的3条线：EasyPlayer-RTSP播放器：Windows、Android、iOS；EasyPlayerPro播放器：Windows、Android、iOS；EasyPlayer.js播放器：H5；这3个播放器各有各的应用场景，用户量也是巨大，像RTSP版本的播放器，到今天依然还有很多低
    
                    
    • 
                    
  • 包含日志获取webshell
                        陈望_ning

                        
    日志文件关闭：Apache目录下的httpd.conf文件#ErrorLog"logs/error.log"#CustomLog"logs/access.log"common加#号为注释不产生日志文件如果去掉#将会在Apache/logs/目录下产生日志文件linux:access_logerror_logwindows:access.logerror.logaccess_log每一行记录了一次网
    
                    
    • 
                    
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    
                    
    • 
                    
  • selenium 特殊场景处理
                        

                        
    文章目录前言一、windows的弹窗二、内嵌网页frame三、页签切换四、截图五、弹窗六、JS执行总结前言selenium处理web操作师，有很多特殊的情况需要处理，例如弹窗、内嵌网页，页签切换，js执行等，下面介绍一些可能会遇到的特殊场景一、windows的弹窗importwin32com.client'''创建了一个WScript.ShellCOM(ComponentObjectModel)对
    
                    
    • 
                    
  • PDF转Markdown - Python 实现方案与代码
                        Eiceblue
PythonPythonPDFpdfpython开发语言vscode
                        
    PDF作为广泛使用的文档格式，转换为轻量级标记语言Markdown后，可无缝集成到技术文档、博客平台和版本控制系统中，提高内容的可编辑性和可访问性。本文将详细介绍如何使用国产Spire.PDFforPython库将PDF文档转换为Markdown格式。技术优势：精准保留原始文档结构（段落/列表/表格）完整提取文本和图像内容无需Adobe依赖的纯Python实现支持Linux/Windows/mac
    
                    
    • 
                    
  • .net平台的跨平台桌面应用开发的技术方案总结对比
                        yuanpan
.net
                        
    目前，.NET平台提供了多种跨平台桌面应用开发的技术方案，主要包括.NETMAUI、AvaloniaUI、UnoPlatform、Eto.Forms等。以下是它们的核心特点及优缺点对比：1..NETMAUI（.NETMulti-platformAppUI）支持平台：Windows、macOS、iOS、Android核心特点：微软官方维护，继承自Xamarin.Forms，支持XAML和C#开发。提
    
                    
    • 
                    
  • 在Windows11上安装Linux操作系统的几种技术方案
                        yuanpan
linux运维服务器
                        
    在Windows11上安装Linux主要有以下几种技术方案，每种方案适用于不同的需求场景：1.WindowsSubsystemforLinux(WSL)适用场景：开发、命令行工具、轻量级Linux环境支持发行版：Ubuntu、Debian、KaliLinux、Fedora等优点：轻量级：无需虚拟机，直接在Windows上运行Linux命令行环境。无缝集成：可访问Windows文件系统，支持VSCo
    
                    
    • 
                    
  • Claude Code 超详细完整指南（2025最新版）
                        笙囧同学
python
                        
    终端AI编程助手|高频使用点+生态工具+完整命令参考+最新MCP配置目录快速开始（5分钟上手）详细安装指南系统要求Windows安装（WSL方案）macOS安装Linux安装安装验证配置与认证首次认证环境变量配置代理配置⚡基础命令详解启动命令会话管理文件操作Think模式完全指南MCP服务器配置详解MCP基础概念添加MCP服务器10个必备MCP服务器MCP故障排除记忆系统详解高级使用技巧成本控制策
    
                    
    • 
                    
  • Linux中Samba服务器安装与配置文件
                        長樂.-
linux运维服务器
                        
    Samba简述27zkqsamba是一个基于TCP/IP协议的开源软件套件，可以在Linux、Windows、macOS等操作系统上运行。它允许不同操作系统的计算机之间实现文件和打印机共享。samba提供了一个服务，使得Windows操作系统可以像访问本地文件一样访问Linux、Mac等操作系统上的共享文件。实现跨平台的文件共享，提高办公环境的效率和便利性。samba也支持Windows网络邻居协
    
                    
    • 
                    
  • ubuntu qt环境下出现No suitable kits found解决方案
                        

                        
    1.清理QtCreator缓存QtCreator会缓存项目配置、索引等数据，可能导致某些异常。清理方法：(1)删除QtCreator配置目录bashrm-rf~/.config/QtProject/（Ubuntu/Linux）或Windows：cmdrmdir/s/q"%APPDATA%\QtProject"(2)清除QtCreator的编译缓存bashrm-rf~/.cache/QtProjec
    
                    
    • 
                    
  • window显示驱动开发—Direct3D 11 视频设备驱动程序接口 (DDI)
                        程序员王马
windows图形显示驱动开发音视频
                        
    这些设备驱动程序接口(DDI)是新的或针对Windows8更新的：CalcPrivateCryptoSessionSizeCalcPrivateAuthenticatedChannelSizeCalcPrivateVideoDecoderOutputViewSizeCalcPrivateVideoDecoderSizeCalcPrivateVideoProcessorEnumSizeCalcPri
    
                    
    • 
                    
  • 群晖 File Station：集中浏览与管理 NAS 文件的工具
                        Trihawk宇麦科技
群晖NAS
                        
    FileStation是SynologyDSM（DiskStationManager）操作系统中的核心内建应用，以网页形式提供友好的图形界面，供用户在浏览器中管理NAS上的文件和共享资料核心功能特色1.文件浏览与管理Navigate文件夹、执行拖放上传、剪贴、重命名、移动、删除等常用操作，类似WindowsExplorer或macOSFinder的使用体验，直观且便捷支持批量操作、压缩与解压、多文
    
                    
    • 
                    
  • Windows系统第一次运行C语言程序，环境配置，软件安装等遇到的坑及解决方法
                        灬爱码士灬
windowsc语言开发语言
                        
    明确需要编辑器和编译器，并选择自己要用什么（我选的编辑器是VSCode：VisualStudioCode；编译器是gcc）下载VSCode并配置环境变量（这里没啥问题），安装C/C++的拓展安装Cygwin，用来在Windows操作系统上模拟Unix/Linux环境（Cygwin官网：https://www.cygwin.com/。）安装过程中镜像可以选择https://mirrors.aliyu
    
                    
    • 
                    
  • Windows下Oracle安装图解
                        叫我老村长

                        
    Windows下Oracle安装图解----oracle-win-64-11g详细安装步骤一、Oracle下载官方下地址http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.htmlwin32位操作系统下载地址：http://download.oracle.com/otn/nt/oracle11g
    
                    
    • 
                    
  • 从0到1学PHP（一）：PHP 基础入门：开启后端开发之旅
                        

                        
    目录一、PHP简介与发展历程1.1PHP定义与特点1.2在后端开发中的地位1.3发展阶段及重要版本更新二、PHP开发环境搭建2.1Windows系统下搭建步骤2.2Mac系统下搭建方法及常用工具2.3适合初学者的集成开发环境三、第一个PHP程序3.1编写"HelloWorld"程序3.2程序基本结构和执行过程3.3PHP代码的嵌入方式（在HTML中）一、PHP简介与发展历程1.1PHP定义与特点P
    
                    
    • 
                    
  • LLaMA-Factory微调教程1：LLaMA-Factory安装及使用
                        Cachel wood
LLM和AIGCllamapython开发语言react.jsjavascript前端microsoft
                        
    文章目录环境搭建LLaMA-Factory安装教程模型大小选择环境搭建Windows系统RTX4060Ti（16G显存）python3.10cuda=12.6cudnntorch==2.7.1+cu126torchvision==0.22.1+cu126torchaudio==2.7.1+cu126PSC:\Users\18098>nvidia-smiTueJul2201:52:192025+<
    
                    
    • 
                    
  • openssl-1.1.1w-win64
                        创想未来CTF
QtC++https
                        
    下载地址：ICSDownload-Overbyte解压后添加环境变量或放在目录“C:\Windows\System32”下其他版本下载GitGodeOpenSSL1.1.1g安装包
    
                    
    • 
                    
  • LEADTOOLS 将一维和条形码读取图像 - Windows C DLL
                        sdk大全
LEADTOOLS23windowsc语言开发语言
                        
    将一维和条形码读取图像-WindowsCDLL本教程介绍如何使用WindowsCDLL应用程序中的LEADTOOLSSDK在加载的图像上写入一维和二维条形码信息。概述概括本教程介绍如何L_BarCodeWrite在WindowsCDLL应用程序中使用该函数。完成时间30分钟VisualStudio项目下载教程项目(19KB)平台WindowsCDLL应用程序集成开发环境VisualStudio20
    
                    
    • 
                    
  • 如何在Windows环境下编译QT-5.15.17版本
                        

                        
    最近在开发一款客户端软件，基于QT实现跨平台。网上能下载的安装版本只有比较老的V5.15.2版本，就想着自己去编译一个最新的QT版本。目前线上能下载的Qt5的最新版本是V5.15.17。原本以为应该比较简单，哪知道花了2天的时间才真正编译成功，经历了几次编译半天最后失败的无奈。我的笔记本配置不高，每次编译基本上要6小时以上。最坑的是编译了好几个小时，快最后了，突然报错了。现在把我编译的过程分享出来
    
                    
    • 
                    
  • os系统服务器防火墙怎么关闭,mac防火墙如何关闭
                        

                        
    用久了mac防火墙，有点烦它了，想要关闭该怎么办呢?下面由小编给你做出详细的mac防火墙关闭方法介绍!希望对你有帮助!mac防火墙关闭方法一：1.在开始界面下点击【桌面】或【Win+D】快捷键或单独按【Win】显示桌面。2.在开始的位置的地方点击鼠标右键。选择【控制面板】3.进入控制面板后点击【用户帐户和家庭安全】4.在用户帐户和家庭安全界面中依次点击【系统和安全】----【Windows防火墙】
    
                    
    • 
                    
  • 远程服务器windows对外开放端口,Windows Server 2008 R2开启新端口远程桌面
                        

                        
    【要求】1、修改默认端口。2、不用关闭防火墙。【步骤】1、用PowerShell查看：(Get-ItemProperty-Path"hklm:SYSTEM\CurrentControlSet\Control\TerminalServer\Wds\rdpwd\Tds\tcp").PortNumber(Get-ItemProperty-Path"hklm:SYSTEM\CurrentControlSe
    
                    
    • 
                    
  • 如何查看 Windows 电脑的处理器类型（x64 或 ARM64）
                        枫萏
Other经验分享笔记
                        
    方法1：通过「设置」查看按Win+I打开「设置」进入系统→关于在设备规格部分，查看系统类型：①如果显示64位操作系统，基于x64的处理器→选择GitforWindows/x64Portable②如果显示64位操作系统，基于ARM的处理器→选择GitforWindows/ARM64Portable方法2：通过「任务管理器」查看按Ctrl+Shift+Esc打开「任务管理器」切换到性能选项卡查看CPU
    
                    
    • 
                    
  • 配置环境变量（以 JDK 1.8为例）macOS Mojave
                        夜色曾沁凉
编程语言&程序设计macOS编程语言&amp;amp;程序设计
                        
    什么是环境变量环境变量（environmentvariables）一般是指在操作系统中用来指定操作系统运行环境的一些参数，如：临时文件夹位置和系统文件夹位置等。环境变量是在操作系统中一个具有特定名字的对象，它包含了一个或者多个应用程序所将使用到的信息。例如Windows和DOS操作系统中的path环境变量，当要求系统运行一个程序而没有告诉它程序所在的完整路径时，系统除了在当前目录下面寻找此程序外，
    
                    
    • 
                    
  • linux shell从入门到精通（一）——为什么要学习Linux Shell
                        

                        
    1.编译型语言和解释型语言  计算机不能直接理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言编写的程序。  翻译的方式有两种，一种是编译（compile），另一种是解释（interpret）。两种方式只是翻译的时间不同。编译型语言写在程序执行之前，需要一个专门的编译过程，把程序编译成为机器语言的文件，例如：Windows系统中的EXE文件，编译好后运行
    
                    
    • 
                    
  • 在 Windows 系统 下直接使用了 Linux/macOS 的环境变量设置语法 PLATFORM=android
                        

                        
    一、报错原因由于开发这个项目的同事，使用电脑的操作系统是macOS。所以才会出现这个错误，因为我是在Windows系统下直接使用了Linux/macOS的环境变量设置语法PLATFORM=android（项目根目录下的package.json文件，找到scripts部分，检查test:android的定义），而Windows不支持这种语法。二、解决方案cross-env是一个解决跨平台环境变量设置
    
                    
    • 
                    
  • 查看自己电脑安装了wsl
                        Jiang_Immortals
各平台开源项目python
                        
    要查看自己的电脑是否安装了WSL（WindowsSubsystemforLinux），可以按照以下步骤进行：打开WindowsPowerShell或命令提示符（CommandPrompt）。输入以下命令并按回车键执行：wsl--list--verbose等待一段时间，系统会列出已安装的WSL发行版。如果没有任何输出或返回错误消息，则表示未安装WSL。如果您已经安装了WSL，输出将包含已安装的发行版
    
                    
    • 
                    
  • zabbix-agent静默安装
                        小周学学学
zabbix
                        
    msiexec/izabbix-msi安装包/qnSERVER=zabbix服务器IP例如版本为zabbix_agent-7.0.7-windows-amd64-openssl.msi，服务器为192.168.1.100msiexec/izabbix_agent-7.0.7-windows-amd64-openssl.msi/qnSERVER=192.168.1.100官方文档地址：4从MSI安装
    
                    
    • 
                                
  • mysql主从数据同步
                                    林鹤霄
mysql主从数据同步
                                    
    配置mysql5.5主从服务器(转)   
教程开始：一、安装MySQL 
说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22 
 二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
    
                                
    • 
                                
  • oracle学习笔记
                                    caoyong
oracle
                                    
    1、ORACLE的安装 
   a>、ORACLE的版本 
   8i,9i :   i是internet 
   10g,11g : grid (网格) 
   12c : cloud (云计算) 
   
   b>、10g不支持win7 
&
    
                                
    • 
                                
  • 数据库，SQL零基础入门
                                    天子之骄
sql数据库入门基本术语
                                    
    数据库，SQL零基础入门 
       做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。 
  
       数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
    
                                
    • 
                                
  • pom.xml
                                    一炮送你回车库
pom.xml
                                    
    1、一级元素dependencies是可以被子项目继承的 
2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 
3、父项目里的一级元素<modules> 
<module>lcas-admin-war</module> 
<
    
                                
    • 
                                
  • sql查地区省市县
                                    3213213333332132
sqlmysql
                                    
    
-- db_yhm_city   
SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35   
  
SELECT * FROM db_yhm_city WHERE class_parent_id =169   
  
SELECT d1.cla
    
                                
    • 
                                
  • 关于监听器那些让人头疼的事
                                    宝剑锋梅花香
画图板监听器鼠标监听器
                                    
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。 
      
    
                                
    • 
                                
  • JAVA的遍历MAP
                                    darkranger
map
                                    
    Java Map遍历方式的选择 
1. 阐述 
　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 
　　为了解遍历性能的真实差距，包括在遍历ke
    
                                
    • 
                                
  • POJ 2312 Battle City 优先多列+bfs
                                    aijuans
搜索
                                    
    来源：http://poj.org/problem?id=2312 
题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 
思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
    
                                
    • 
                                
  • Hibernate与Jpa的关系，终于弄懂
                                    avords
javaHibernate数据库jpa
                                    
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 
在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
    
                                
    • 
                                
  • 酸爽的console.log
                                    bee1314
console
                                    
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 
/**
 * log.js hufeng
 * The safe wrapper for `console.xxx` functions
 *  
    
                                
    • 
                                
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质
                                    bijian1013
时间管理励志人生穷人过于忙碌
                                    
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 
　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
    
                                
    • 
                                
  • other operate
                                    征客丶
OSosx
                                    
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 
二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一
    
                                
    • 
                                
  • 【Scala五】分析Spark源代码总结的Scala语法三
                                    bit1129
scala
                                    
    1. If语句作为表达式 
    val properties = if (jobIdToActiveJob.contains(jobId)) {
      jobIdToActiveJob(stage.jobId).properties
    } else {
      // this stage will be assigned to "default" po
    
                                
    • 
                                
  • ZooKeeper 入门
                                    BlueSkator
中间件zk
                                    
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 
值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
    
                                
    • 
                                
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么
                                    BreakingBad
mysqlDate
                                    
    取得当前时间用 now() 就行。
在数据库中格式化时间 用DATE_FORMA T(date, format) .
根据格式串format 格式化日期或日期和时间值date，返回结果串。

  可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值:

  %S, %s 两位数字形式的秒（ 00,01,
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-组合模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.util.ArrayList;
import java.util.List;

abstract class Component {
	
	public abstract void printStruct(Str
    
                                
    • 
                                
  • 4_JAVA+Oracle面试题(有答案)
                                    chenke
oracle
                                    
    基础测试题 
 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 
选择题 
1、 What will happen when you attempt to compile and run the following code? （3） 
public class Static { 
 static { 
 int x = 5; // 在static内有效 
 } 
 st
    
                                
    • 
                                
  • 新一代工作流系统设计目标
                                    comsci
工作算法脚本
                                    
     
  用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 
 
 在这个设计中，最难的地方是系统根据什么来生成流
    
                                
    • 
                                
  • oracle 行链接与行迁移
                                    daizj
oracle行迁移
                                    
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 
 
第一种情况: 
INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
    
                                
    • 
                                
  • [JShop]开源电子商务系统jshop的系统缓存实现
                                    dinguangx
jshop电子商务
                                    
    前言 
jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
    
                                
    • 
                                
  • 初三全学年难记忆单词
                                    dcj3sjt126com
englishword
                                    
    several 儿子；若干 
shelf 架子 
knowledge 知识；学问 
librarian 图书管理员 
abroad 到国外，在国外 
surf 冲浪 
wave 浪；波浪 
twice 两次；两倍 
describe 描写；叙述 
especially 特别；尤其 
attract 吸引 
prize 奖品；奖赏 
competition 比赛；竞争 
event 大事；事件 
O
    
                                
    • 
                                
  • sphinx实践
                                    dcj3sjt126com
sphinx
                                    
      
安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server 
  
yum install sphinx 
如果失败的话使用下面的方式安装 
wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm 
yum loca
    
                                
    • 
                                
  • JPA之JPQL（三）
                                    frank1234
ormjpaJPQL
                                    
    1 什么是JPQL 
JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 
 
2 检索单个对象 
@Test 
public  void querySingleObject1() { 
    Query query = em.createQuery("sele
    
                                
    • 
                                
  • Remove Duplicates from Sorted Array II
                                    hcx2013
remove
                                    
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? 
For example,Given sorted array nums = [1,1,1,2,2,3], 
Your function should return length 
    
                                
    • 
                                
  • Spring4新特性——Groovy Bean定义DSL
                                    jinnianshilongnian
spring 4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • CentOS安装Mysql5.5
                                    liuxingguome
centos
                                    
    CentOS下以RPM方式安装MySQL5.5 
 
首先卸载系统自带Mysql： 
yum remove mysql mysql-server mysql-libs compat-mysql51 
rm -rf /var/lib/mysql 
rm /etc/my.cnf 
查看是否还有mysql软件： 
rpm -qa|grep mysql 
 
 
 
去http://dev.mysql.c
    
                                
    • 
                                
  • 第14章 工具函数（下）
                                    onestopweb
函数
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • POJ 1050
                                    SaraWon
二维数组子矩阵最大和
                                    
    POJ ACM第1050题的详细描述，请参照 
http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 
 
题目意思： 
给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 
如二维数组 
0 -2 -7 0 
9 2 -6 2 
-4 1 -4 1 
-1 8 0 -2 
中和最大的子矩阵是 
9 2 
-4 1 
-1 8 
且最大和是15
    
                                
    • 
                                
  • [5]设计模式——单例模式
                                    tsface
java单例设计模式虚拟机
                                    
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点 
  
安全的单例模式： 
  
  
/*
 * @(#)Singleton.java  2014-8-1
 *
 * Copyright 2014 XXXX, Inc. All rights reserved.
 */
package com.fiberhome.singleton;


    
                                
    • 
                                
  • Java8全新打造，英语学习supertool
                                    yangshangchuan
javasuperword闭包java8函数式编程
                                    
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。 
  
升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
    
                                
    •