springboot使用redis對(duì)單個(gè)對(duì)象進(jìn)行自動(dòng)緩存更新刪除的實(shí)現(xiàn)

更新時(shí)間：2021年08月04日 15:43:19 作者：杉菜醬醬子~

本文主要介紹了springboot使用redis對(duì)單個(gè)對(duì)象進(jìn)行自動(dòng)緩存更新刪除的實(shí)現(xiàn)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下

Springboot的項(xiàng)目搭建在此省略，pom文件依賴什么的就不說了

創(chuàng)建一個(gè)實(shí)體類

@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@ApiModel(value="ERepository對(duì)象", description="題庫")
public class ERepository extends BasicModel<ERepository> implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty(value = "安全分類id")
    private Long safeTypeId;

    @ApiModelProperty(value = "題型")
    private Integer quesType;

    @ApiModelProperty(value = "題干")
    private String quesContent;

    @ApiModelProperty(value = "選項(xiàng)")
    private String options;

    @ApiModelProperty(value = "答案")
    private String answer;

    @ApiModelProperty(value = "是否審核(0:未審核,1:已審核)")
//    @TableField("is_check")
    private Boolean isCheck;
    @Override
    protected Serializable pkVal() {
        return this.id;
    }
}

創(chuàng)建一個(gè)控制器

@RequiredArgsConstructor
@RestController
@Slf4j
@Api(tags = "題庫模塊")
@RequestMapping("/api/eRepository")
public class ERepositoryController {
    private final IERepositoryService eRepositoryService;

    @ApiOperation("查詢所有題目")
    @GetMapping(value = "/all")
    @ResponseBody
    public Result<List<ERepository>> getRespository(ERepositoryQueryCriteria criteria){
        return Result.success(eRepositoryService.getRepositoryAll(criteria));
    }

    @ApiOperation(value = "多條件查詢題目",notes = "根據(jù)各種條件查詢，可分頁 \n author:LiFang 2021/7/25")
    @GetMapping
    @ResponseBody
    public Result<IPage<ERepositoryDTO>> getRespository(PageVO pageVO,ERepositoryQueryCriteria criteria){
        return Result.success(eRepositoryService.getRepository(pageVO.buildPage(),criteria));
    }

    @ApiOperation(value = "按安全分類id查詢")
    @GetMapping(value = "/getBySafeTypeId")
    public Result<List<ERepository>> getRespositoryBySafeTypeId(Long id){
        Long start = System.currentTimeMillis();
        List<ERepository> list = eRepositoryService.getBySafeTypeId(id);
        Long end = System.currentTimeMillis();
        System.out.println("耗時(shí)："+(end-start));
        return Result.success(list);
    }

    @ApiOperation("新增題目")
    @PostMapping
    public Result<Void> add(@RequestBody ERepository eRepository){
        eRepository.setDeleted(false);
        eRepositoryService.addRepository(eRepository);
        return Result.success();
    }

    @ApiOperation("修改題目")
    @PutMapping
    public Result<Object> update(@RequestBody ERepository eRepository){
        eRepository.setDeleted(false);
        log.info(StrUtil.format("【修改題目 /api/eRepository】操作人id：{}，被修改題目id：{}", SecurityUtils.getCurrentUserId(),
                eRepository.getId()));
        return Result.success(eRepositoryService.updateRepository(eRepository));
    }

    @ApiOperation("刪除題目")
    @DeleteMapping
    public Result<Void> delete(@RequestBody Set<Long> ids){
        eRepositoryService.deleteById(ids);
        return Result.success();
    }
}

建個(gè)service

public interface IERepositoryService extends IBasicService<ERepository> {
    List<ERepository> getRepositoryAll(ERepositoryQueryCriteria criteria);

    IPage<ERepositoryDTO> getRepository(IPage<ERepository> page,ERepositoryQueryCriteria criteria);

    List<ERepository> addRepository(ERepository eRepository);

    List<ERepository> updateRepository(ERepository eRepository);

    void deleteById(Set<Long> id);

    List<ERepository> getBySafeTypeId(Long id);
}

新建service實(shí)現(xiàn)類

使用注解進(jìn)行自動(dòng)緩存、更新、刪除主要是在service的實(shí)現(xiàn)類里寫

@Slf4j
@Service
@EnableCaching
@RequiredArgsConstructor
@CacheConfig(cacheNames = "repository")
public class ERepositoryServiceImpl extends BasicServiceImpl<ERepositoryMapper, ERepository> implements IERepositoryService {
    private final ERepositoryMapper eRepositoryMapper;
    private final ERepositoryStruct eRepositoryStruct;
//    private final ERepositoryServiceImpl eRepositoryService;
    private final RedisUtils redisUtils;

    @Override
    public List<ERepository> getRepositoryAll(ERepositoryQueryCriteria criteria) {
        List<ERepository> eRepositories = eRepositoryMapper.selectList(buildERepositoryCriteria(criteria));
        return eRepositories;
    }

    @Override
    public IPage<ERepositoryDTO> getRepository(IPage<ERepository> page,ERepositoryQueryCriteria criteria) {
        IPage<ERepository> eRepositoryPage = eRepositoryMapper.selectPage(page,buildERepositoryCriteria(criteria));
        List<ERepositoryDTO> eRepositoryDTOList = eRepositoryStruct.toDto(eRepositoryPage.getRecords());
        return PageUtil.toMapStructPage(eRepositoryPage,eRepositoryDTOList);
    }

    @Cacheable(key = "'safeTypeId:' + #p0")
    @Override
    public List<ERepository> getBySafeTypeId(Long id) {
        List<ERepository> eRepositoryList = eRepositoryMapper.getBySafeTypeId(id);
        return eRepositoryList;
    }

    private LambdaQueryWrapper<ERepository> buildERepositoryCriteria(ERepositoryQueryCriteria criteria){
        LambdaQueryWrapper<ERepository> wrapper = new LambdaQueryWrapper<>();
//        wrapper.eq(ERepository::getDeleted,false);
        if (ObjectUtil.isNotNull(criteria.getId())) {
            wrapper.eq(ERepository::getId,criteria.getId());
        }
        if(StrUtil.isNotBlank(criteria.getQuesContent())){
            //默認(rèn)使用like匹配
            wrapper.like(ERepository::getQuesContent, criteria.getQuesContent());
        }
        if (ObjectUtil.isNotNull(criteria.getSafeTypeId())) {
            wrapper.eq(ERepository::getSafeTypeId, criteria.getSafeTypeId());
        }
        if(ObjectUtil.isNotNull(criteria.getQuesType())){
            wrapper.eq(ERepository::getQuesType,criteria.getQuesType());
        }
        if (ObjectUtil.isNotNull(criteria.getStartTime()) && ObjectUtil.isNotNull(criteria.getEndTime())) {
            wrapper.between(ERepository::getCreateTime , criteria.getStartTime(), criteria.getEndTime());
        }
        return wrapper;
    }

    @CachePut(key = "'safeTypeId:' + #p0.safeTypeId")
    @Override
    public List<ERepository> addRepository(ERepository eRepository) {
        eRepositoryMapper.insert(eRepository);
        List<ERepository> list = eRepositoryMapper.getBySafeTypeId(eRepository.getSafeTypeId());
//        list.add(eRepository);
        return list;
    }

    @CachePut(key = "'safeTypeId:' + #p0.safeTypeId")
    @Override
    public List<ERepository> updateRepository(ERepository resources) {
        ERepository eRepository = getById(resources.getId());
        if(ObjectUtil.isEmpty(eRepository)){
            log.error(StrUtil.format("【修改題目失敗】操作人id：{}，修改目標(biāo)ERepository為空，目標(biāo)id：{}", SecurityUtils.getCurrentUserId(),
                    resources.getId()));
            throw new BadRequestException("修改失敗，當(dāng)前數(shù)據(jù)id不存在");
        }
        eRepositoryMapper.updateById(resources);
        log.info(StrUtil.format("【修改題目成功】操作人id：{}，修改目標(biāo)題目：{}", SecurityUtils.getCurrentUserId(),
                resources));
        List<ERepository> list = eRepositoryMapper.getBySafeTypeId(resources.getSafeTypeId());
//        list.removeIf(item -> resources.geMId().equals(item.getId()));
//        list.add(resources);
        //清理緩存
        delCaches(resources.getId());
        return list;
    }

    @Override
    public void deleteById(Set<Long> ids) {
        for (Long id : ids){
            eRepositoryMapper.deleteById(id);
            //清理緩存
            delCaches(id);
        }
        log.info(StrUtil.format("【刪除題目成功】操作人id：{}，刪除目標(biāo)repositories：{}", SecurityUtils.getCurrentUserId(),
                ids.toString()));
    }

    /**
     * 清理緩存
     *
     * @param id /
     */
    private void delCaches(Long id) {
        Long safeTypeId = eRepositoryMapper.getSafeTypeIdById(id);
        //刪除屬于該安全分類的題庫緩存
        redisUtils.del(CacheKey.REPOSITORY_SAFETYPEID + safeTypeId);
    }
}

新建mapper接口

@Component
public interface ERepositoryMapper extends BasicMapper<ERepository> {
    @Select("SELECT * FROM e_repository WHERE safe_type_id = #{safeTypeId} AND is_deleted=0")
    List<ERepository> getBySafeTypeId(Long safeTypeId);

     @Select("SELECT safe_type_id FROM e_repository WHERE id= #{id} AND is_deleted=0")
     Long getSafeTypeIdById(Long id);
}

6.啟動(dòng)項(xiàng)目

使用swagger測(cè)試根據(jù)安全分類id查詢題目接口，該分類題目的查詢結(jié)果成功響應(yīng)，這時(shí)打開redis管理工具，可以看到題目按分類已經(jīng)被緩存到redis中了。

再次用swagger測(cè)試查詢?cè)摲诸恑d的所有題目，可以看到IDEA控制臺(tái)并沒有sql語句打印，仍然有查詢結(jié)果成功響應(yīng)。

@CacheConfig(cacheNames = “repository”)
放在service實(shí)現(xiàn)類上，用來配置緩存名稱。
@Cacheable(key = “‘safeTypeId:' + #p0”)
放在查詢方法上，‘safeTypeId:' + #p0作為鍵，p0是該方法的第一個(gè)參數(shù)。
作用：使用這兩個(gè)注解，會(huì)使查詢方法首先會(huì)根據(jù)key從緩存中查詢，如果緩存中沒有該鍵，則從使用sql語句到數(shù)據(jù)庫中差查詢，查詢后，響應(yīng)結(jié)果，并自動(dòng)將方法的返回結(jié)果放入redis緩存中，下一次，如果再查詢就直接從redis緩存中查詢。

好處：極大提升查詢效率，并減輕服務(wù)器壓力。

@CachePut(key = “‘safeTypeId:' + #p0.safeTypeId”)

通常加到添加和更新方法上

當(dāng)訪問新增題目接口時(shí)，數(shù)據(jù)庫新增題目成功，方法返回結(jié)果會(huì)存入redis中，這次再訪問查詢屬于該分類的題目接口，會(huì)發(fā)現(xiàn)該分類的題目已經(jīng)添加成功。
當(dāng)訪問更新題目接口時(shí)，數(shù)據(jù)庫更新題目成功，方法返回結(jié)果會(huì)根據(jù)key存入redis中，當(dāng)再根據(jù)該key查詢題目時(shí)，會(huì)發(fā)現(xiàn)控制臺(tái)并沒有打印sql語句，直接從redis中查詢出結(jié)果。

@CacheEvict(key = “#p0”)

用在刪除方法上，走該刪除方法，會(huì)刪除數(shù)據(jù)庫中的該條記錄，而且會(huì)刪除key為方法的第一個(gè)參數(shù)（通常為id）的redis記錄。再次查詢?cè)摋l記錄，發(fā)現(xiàn)查詢不到了。
注意：上面的方法不能用來存儲(chǔ)集合。

到此這篇關(guān)于springboot使用redis對(duì)單個(gè)對(duì)象進(jìn)行自動(dòng)緩存更新刪除的實(shí)現(xiàn)的文章就介紹到這了,更多相關(guān)springboot redis自動(dòng)緩存更新刪除內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: