springboot使用redis对单个对象进行自动缓存更新删除的实现

springboot的项目搭建在此省略，pom文件依赖什么的就不说了

创建一个实体类

@data
@equalsandhashcode(callsuper = true)
@accessors(chain = true)
@apimodel(value="erepository对象", 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 = "选项")
    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;
    }
}

创建一个控制器

@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 = "根据各种条件查询，可分页 \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("耗时："+(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();
    }
}

建个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实现类

使用注解进行自动缓存、更新、删除主要是在service的实现类里写

@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())){
            //默认使用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：{}，修改目标erepository为空，目标id：{}", securityutils.getcurrentuserid(),
                    resources.getid()));
            throw new badrequestexception("修改失败，当前数据id不存在");
        }
        erepositorymapper.updatebyid(resources);
        log.info(strutil.format("【修改题目成功】操作人id：{}，修改目标题目：{}", 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：{}，删除目标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.启动项目

使用swagger测试根据安全分类id查询题目接口，该分类题目的查询结果成功响应，这时打开redis管理工具，可以看到题目按分类已经被缓存到redis中了。

再次用swagger测试查询该分类id的所有题目，可以看到idea控制台并没有sql语句打印，仍然有查询结果成功响应。

@cacheconfig(cachenames = “repository”)
放在service实现类上，用来配置缓存名称。
@cacheable(key = “‘safetypeid:' + #p0”)
放在查询方法上，‘safetypeid:' + #p0作为键，p0是该方法的第一个参数。
作用：使用这两个注解，会使查询方法首先会根据key从缓存中查询，如果缓存中没有该键，则从使用sql语句到数据库中差查询，查询后，响应结果，并自动将方法的返回结果放入redis缓存中，下一次，如果再查询就直接从redis缓存中查询。

好处：极大提升查询效率，并减轻服务器压力。

@cacheput(key = “‘safetypeid:' + #p0.safetypeid”)

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

• 当访问新增题目接口时，数据库新增题目成功，方法返回结果会存入redis中，这次再访问查询属于该分类的题目接口，会发现该分类的题目已经添加成功。
• 当访问更新题目接口时，数据库更新题目成功，方法返回结果会根据key存入redis中，当再根据该key查询题目时，会发现控制台并没有打印sql语句，直接从redis中查询出结果。

@cacheevict(key = “#p0”)

用在删除方法上，走该删除方法，会删除数据库中的该条记录，而且会删除key为方法的第一个参数（通常为id）的redis记录。再次查询该条记录，发现查询不到了。
注意：上面的方法不能用来存储集合。

到此这篇关于springboot使用redis对单个对象进行自动缓存更新删除的实现的文章就介绍到这了,更多相关springboot redis自动缓存更新删除内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！