关于Mybatis-plus整合Redis实现分页缓存解决更新，删除，添加，数据不统一的办法！！

最新推荐文章于 2024-04-15 17:18:54 发布

是阿伟咯

最新推荐文章于 2024-04-15 17:18:54 发布

阅读量1.1k

点赞数 2

CC 4.0 BY-SA版权

文章标签： mybatis 缓存 redis spring tomcat

本文链接：https://blog.csdn.net/weixin_58415189/article/details/130289598

文章描述了一个Java服务类`EventsService`，该类使用Mybatis-plus进行分页查询并结合Redis进行缓存管理。当进行添加、删除或更新操作时，会调用`clearAllCache`方法清除所有缓存以保持数据一致性。查询时，首先检查Redis中的缓存，如果不存在则从数据库查询并将结果存入缓存。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

因为我的分页查询是可带查询条件的查询方式，所以传递了个实体类
这边我设置了两个key
- key：存储Mybatis-plus中selectPage(iPage,lqw)查询出来的数据。
- countKey：分页查询到的总数据项。

数据更新，删除，添加等操作，因为业务逻辑复杂，所以普遍决定通过调用自定义方法

clearAllCache

清除所有的缓存，与数据保持统一

package com.test.Service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.test.Client.PDClient;
import com.test.Client.TagClient;
import com.test.R;
import com.test.conf.ConvertUtil;
import com.test.entity.Events;
import com.test.entity.Events;
import feign.Response;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.logging.log4j.util.Strings;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.BoundZSetOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.test.Mapper.EventsMapper;
import com.test.entity.Events;
import org.springframework.web.multipart.MultipartFile;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author LiYa
 * @create 2023-03-30 22:09
 */
@Service
public class EventsService {
    @Resource
    EventsMapper eventsMapper;

    @Resource
    RedisTemplate<String,Object> redisTemplate;

//    清除所有的缓存，与数据保持统一
    public void clearAllCache() {
        Set<String> keys = redisTemplate.keys("*");
        if (keys != null && keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    public int delevents(int id)
    {
        eventsMapper.deleteById(id);
        this.clearAllCache();
        return 1;
    }

    public int addevents(Events events)
    {
        return eventsMapper.insert(events);
    }

    public Events update(Events events)
    {
        eventsMapper.updateById(events);
        this.clearAllCache();
        return events;
    }


    public IPage<Events> getList(int pageNow, int pageSize, Events events){
//        设置key
        String key = "Events_page_" + pageNow + "_" + pageSize + "_"+
                events.getSponsorId()+"_"+events.getName()+"_"+events.getTagId();
        String countKey=key+"_totalCount";
        BoundZSetOperations<String, Object> boundZSetOps = redisTemplate.boundZSetOps(key);
        Integer totalCount = (Integer) redisTemplate.opsForValue().get(countKey);
        if (totalCount == null || totalCount == 0)
        {
            // 缓存中不存在结果，从数据库查询
//            通过LambdaQueryWrapper进行模糊查询
            LambdaQueryWrapper<Events> lqw=new LambdaQueryWrapper<Events>();
            lqw.like(Strings.isNotEmpty(events.getName()),Events::getName , events.getName());
            lqw.like(Strings.isNotEmpty(events.getSponsorId()==null?"":events.getSponsorId().toString()),Events::getSponsorId , events.getSponsorId());
            lqw.eq(Strings.isNotEmpty(events.getTagId()==null?"":events.getTagId().toString()),Events::getTagId , events.getTagId());
            IPage<Events> iPage=new Page<>(pageNow,pageSize);
            eventsMapper.selectPage(iPage,lqw);
            redisTemplate.opsForValue().set(countKey,iPage.getTotal());
            // 将结果加入缓存
            List<Events> EventsList = iPage.getRecords();
            for (int i = 0; i < EventsList.size(); i++)
            {
                boundZSetOps.add(EventsList.get(i), i);
            }
//            设置两个key的过期时间
            redisTemplate.expire(key, 5, TimeUnit.MINUTES);
            redisTemplate.expire(countKey, 5, TimeUnit.MINUTES);
            return iPage;
        }
        else
        {
            // 缓存中存在结果，直接从缓存获取
//            int start = (pageNow - 1) * pageSize;
//            int end = pageNow * pageSize - 1;
            Set<Object> eventSet = boundZSetOps.range(0, pageSize);
            List<Object> eventsList = new ArrayList<>(eventSet.size());
            for (Object event1 : eventSet)
            {
                eventsList.add((Object) event1);
            }
            return new Page(pageNow, pageSize, totalCount).setRecords(eventsList);
        }
    }


}