redis 模糊删除key

我们遇到 也没有正面解决，通过python 做任务 删除

修改key的前缀就可以了，每次清理缓存后自动变更一次前缀，比如清理前key是a_id_xx，修改后再查询就变成b_id_xx。当然特别提醒设置好redis的内存限制，所有的key都设置过期时间，redis会自行慢慢清理。

再一种，在redis建立单独的库进行缓存，需要删除的时候，直接用 FLUSHDB 命令达到全部清空的目的

角色关联的菜单有人修改了，为什么要一下子删除：删除所有缓存？ 

如果是我的话，我认为谁登陆，这个人相关数据在删，或者重新配置，而不是删除所有人

很简单，自己扩展一个类就行

package uml.tech.bigdata.sdkredis.ext;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 继承自StringRedisTemplate，用于重写某些不支持集群的方法
 *
 * @author SunYu
 */
@Component
public class StringRedisTemplateExt extends StringRedisTemplate {
    public static final int FETCH_BATCH = 500;//批量抓取多少条

    public StringRedisTemplateExt(RedisConnectionFactory connectionFactory) {
        super(connectionFactory);
    }

    /**
     * 重写keys方法，使用scan方式，避免redis实例卡死
     *
     * @param pattern *正则
     * @return
     */
    @Override
    public Set<String> keys(String pattern) {
        return new HashSet<>(keysByPattern(pattern));
    }

    /**
     * 批量删除key，使用scan方式，避免redis实例卡死
     *
     * @param pattern *正则
     * @return
     */
    public Long delByPattern(String pattern) {
        return delete(keysByPattern(pattern));
    }

    /**
     * 使用scan方式，查找keys
     *
     * @param pattern *正则
     * @return
     */
    public List<String> keysByPattern(String pattern) {
        List<String> list = new ArrayList<>();
        RedisConnectionFactory connectionFactory = getConnectionFactory();
        RedisConnection connection = connectionFactory.getConnection();
        Cursor<byte[]> scan = connection.scan(ScanOptions.scanOptions().count(FETCH_BATCH).match(pattern).build());
        scan.forEachRemaining(bytes -> list.add(StrUtil.utf8Str(bytes)));
        return list;
    }

    /**
     * 查找keys
     *
     * @param pattern
     * @param cursorCallback
     */
    public void keysByPattern(String pattern, CursorCallback cursorCallback) {
        RedisConnectionFactory connectionFactory = getConnectionFactory();
        RedisConnection connection = connectionFactory.getConnection();
        Cursor<byte[]> scan = connection.scan(ScanOptions.scanOptions().count(FETCH_BATCH).match(pattern).build());
        scan.forEachRemaining(bytes -> {
            String key = StrUtil.utf8Str(bytes);
            cursorCallback.execute(key);
        });
    }

    /**
     * 返回匹配的key数量
     *
     * @param pattern *正则
     * @return
     */
    public Long size(String pattern) {
        AtomicLong al = new AtomicLong(0);
        RedisConnectionFactory connectionFactory = getConnectionFactory();
        RedisConnection connection = connectionFactory.getConnection();
        Cursor<byte[]> scan = connection.scan(ScanOptions.scanOptions().count(FETCH_BATCH).match(pattern).build());
        scan.forEachRemaining(bytes -> al.incrementAndGet());
        return al.get();
    }

    /**
     * 获得多个key信息，返回key，value
     *
     * @param pattern *key正则
     * @return
     */
    public Map<String, String> mgetByPattern(String pattern) {
        Map<String, String> m = new HashMap<>();
        RedisConnectionFactory connectionFactory = getConnectionFactory();
        RedisConnection connection = connectionFactory.getConnection();
        Cursor<byte[]> scan = connection.scan(ScanOptions.scanOptions().count(FETCH_BATCH).match(pattern).build());
        List<String> keys = new ArrayList<>();
        scan.forEachRemaining(bytes -> {
            keys.add(StrUtil.utf8Str(bytes));
            if (keys.size() == FETCH_BATCH) {
                List<String> values = opsForValue().multiGet(keys);
                for (int i = 0; i < keys.size(); i++) {
                    m.put(keys.get(i), values.get(i));
                }
                keys.clear();
            }
        });
        List<String> values = opsForValue().multiGet(keys);
        for (int i = 0; i < keys.size(); i++) {
            m.put(keys.get(i), values.get(i));
        }
        return m;
    }

    /**
     * 获得多个key信息，返回key，value
     *
     * @param keys *key集合
     * @return
     */
    public Map<String, String> mgetByKeys(Collection<String> keys) {
        Map<String, String> m = new HashMap<>();
        CollUtil
                .split(keys, FETCH_BATCH)
                .forEach(keyList -> {
                    List<String> values = opsForValue().multiGet(keyList);
                    for (int i = 0; i < keyList.size(); i++) {
                        m.put(keyList.get(i), values.get(i));
                    }
                });
        return m;
    }

    /**
     * 获取hash类型的field与value
     *
     * @param key    *hash key
     * @param fields *多个field
     * @return map field, value
     */
    public Map<String, String> hmget(String key, Collection<String> fields) {
        Map<String, String> m = new HashMap<>();
        HashOperations<String, String, String> hash = opsForHash();
        CollUtil
                .split(fields, FETCH_BATCH)
                .forEach(fieldList -> {
                    List<String> values = hash.multiGet(key, fieldList);
                    for (int i = 0; i < fieldList.size(); i++) {
                        m.put(fieldList.get(i), values.get(i));
                    }
                });
        return m;
    }

}

里面用到了工具类

<dependency>
  <groupId>cn.hutool</groupId>
  <artifactId>hutool-all</artifactId>
  <version>5.3.10</version>
</dependency>

或者你直接这样写也行

String pattern="key*";
int FETCH_BATCH = 500;//批量抓取多少条
redisTemplate.execute((RedisCallback<Object>) connection -> {
    Cursor<byte[]> scan = connection.scan(ScanOptions.scanOptions().count(FETCH_BATCH).match(pattern).build());
    scan.forEachRemaining(bytes -> connection.del(bytes));
    return null;
});