Redis开发规范看这篇就够用了

一、键值设计

1. 1 key名定义规则

  • 【建议】: 可读性和可管理性与不可重复性

以业务名(或数据库名或微服务名)为前缀(防止key冲突),用冒号分隔,比如业务名:表名(或子业务名称):id

order:sku:1001

举例:上面定义是定单业务下面的sku的id作为缓存key

  • 【建议】:简洁性

保证语义的前提下,控制key的长度,当key较多时,内存占用也不容忽视,例如:

user:{uid}:friends:messages:{mid}简化为u:{uid}:fr:m:{mid}
  • 【强制】:不要包含特殊字符

不要包含空格、换行、单双引号以及其他转义字符

1.2 value设计

1.2.1 【强制】:拒绝bigkey

为什么要拒绝bigkey: Redis实例集群主要思想是将redis数据的key进行散列,通过hash函数特定的key会映射到指定的redis节点上,bigkey当这个KEY流量较大的时候,流量全打到一个Redis节点上,big key既占用比较多的内存,也可能占用比较多的网卡资源,造成redis阻塞。

防止热点问题(数据倾斜),Redis big key也就意味着每次获取要产生的网络流量较大,假设一个bigkey为1MB,客户端每秒访问量为1000,那么每秒产生1000MB的流量,对于普通的千兆网卡(按照字节算是128MB/s)的服务器来说简直是灭顶之灾。

String类型控制在10KB以内,hash、list、set、zset元素个数不要超过5000。

1.2.2 bigkey举例说明

**举例1:**我们要设计一个网关过滤IP黑名单的缓存,有两种设计方法:

反例,使用LIST或SET格式来存储IP:

LPUSH lgateway:ipblack 10.25.63.123
LPUSH lgateway:ipblack 10.25.63.124
LPUSH lgateway:ipblack 10.25.63.125
LPUSH lgateway:ipblack 10.25.63.126    
...................................    

正例,使用String来存储IP:

SET gateway:ipblack:10.25.63.123 1
SET gateway:ipblack:10.25.63.124 1
SET	gateway:ipblack:10.25.63.125 1
SET	gateway:ipblack:10.25.63.126 1    

相对第二种方法,方法一随着IP数据与流量的增加,会产生热点问题,所以选择方法二

**举例2:**用户表的缓存

用户表结构如下:

CREATE TABLE `users` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) DEFAULT NULL,
  `password` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8

反例,使用map来存:

HGET 来存储 key为“userinfo”,value使用map存所有的用户信息

HGET userinfo 12321 {"name":"peter","age":22}
HGET userinfo 12322 {"name":"jake","age":23}
HGET userinfo 12323 {"name":"rose","age":24}
HGET userinfo 12324 {"name":"xiaomi","age":25}    
...................................    

正例,使用map来存储:

拆分行纪录来存储,key为 user: id, value为map

HMSET user:12321 name peter age 22
HMSET user:12322 name jake age 23
HMSET user:12323 name rose age 24
HMSET user:12324 name xiaomi age 25   
..................................

相对第二种方法,方法一随着用户数据与流量的增加,会产生热点问题,所以选择方法二。

1.2.3【推荐】:选择适合的数据类型。

例如:实体类型(要合理控制和使用数据结构,但也要注意节省内存和性能之间的平衡)

比如对用户信息的缓存,如下两例所示:

反例:

set user:1:name tom
set user:1:age 19
set user:1:favor football

正例:

hmset user:1 name tom age 19 favor football

第一种方式得查多次才能得到这条纪录的值,第二种Map结构可以很方便的一次获取所有字段的值或获取某个字段的值。

1.3【强制】:控制key的生命周期

不是需要长期保存的数据得使用expire设置过期时间,临时缓存数据不允许长期保存,成为垃圾数据。比如短信验证码,有效期是3分钟,那行设置三分钟后过期,如下所示:

SET user:sms:userid 123456
EXPIRE user:sms:userid 180

二、命令使用

2.1【推荐】 O(N)命令关注N的数量

例如hgetall、lrange、smembers、zrange、sinter等并非不能使用,但是需要明确N的值(要限制每次取的数量)。有遍历的需求可以使用hscan、sscan、zscan代替。

2.2【推荐】:禁用命令

禁止线上使用keys、flushall、flushdb等,或者使用scan的方式渐进式处理。

**警告:**KEYS命令不能用在生产的环境中,这个时候如果数量过大效率是十分低的。同时也不要用KEYS正则匹配,官方建议直接用集合类型。

FLUSHALL,FLUSHDB 命令会清空数据,而且从不失败,对于线上集群非常危险。

三、【推荐】Redisson实现分布式锁

使用Redis分布式锁开发时推荐使用Redisson客户端。

3.1 Reddsion介绍

官方推荐的Redisson实现Redis分布式锁,Redisson功能强大,几行代码就可以实现Jedis客户端中需要实现的复杂锁的功能。

**Reddisson可以防止死锁:**如果负责储存这个分布式锁的Redisson节点宕机以后,而且这个锁正好处于锁住的状态时,这个锁会出现锁死的状态。为了避免这种情况的发生,Redisson内部提供了一个监控锁的看门狗,它的作用是在Redisson实例被关闭前,不断的延长锁的有效期。默认情况下,看门狗的检查锁的超时时间是30秒钟,也可以通过修改Config.lockWatchdogTimeout来另行指定。

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

Redisson提供了很多种类型的分布式锁和分布式同步器,如下:

1. 可重入锁(Reentrant Lock) 
2. 公平锁(Fair Lock)       
3. 联锁(MultiLock)
4. 红锁(RedLock)
5. 读写锁(ReadWriteLock)
6. 信号量(Semaphore)
7. 可过期性信号量(PermitExpirableSemaphore)
8. 闭锁(CountDownLatch)

3.2 Springboot结合Redission使用

3.2.1 pom依赖
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.9.0</version>
</dependency>
3.2.2 application.yml
##端口号
server:
  port: 8080
#redis
redis:
  address:
    #单机模式 
    master: redis://127.0.0.1:6379
    #主从模式
    slave: redis://127.0.0.1:6379
    #集群模式
    cluster: redis://127.0.0.1:7001,redis://127.0.0.1:7002,redis://127.0.0.1:7003,redis://127.0.0.1:7004,redis://127.0.0.1:7005,redis://127.0.0.1:7006
  #连接模式 1 单机模式 2 主从模式 3 集群模式
  connectionMode: 1
3.2.3 Redisson配置类

支持三种配置模式:单机模式、主从模式、集群模式

@Configuration
public class RedissionConfig {
    private static final Logger logger = LoggerFactory.getLogger(RedissionConfig.class);

    @Autowired
    private Environment env;
    private Config config;

    private static final String REDISSION_ClIENT_NAME = "SHIT_IS_PERFECT";

    private static final Integer POOL_SIZE = 200;

    private static final Integer IDLE_SIZE = 15;

    private static final Integer TIME_OUT = 10000;

    @Value("${redis.address.master}")
    private String master;
    @Value("${redis.address.slave}")
    private String slave;
    @Value("${redis.connectionMode}")
    private Integer connectionMode;
    @Value("${redis.address.cluster}")
    private String cluster;

    @Bean
    public RedissonClient redissionClient(){
        config = new Config();
        switch (connectionMode){
            //standalone 单机模式
            case 1:
                config.useSingleServer().setAddress(master)
                        .setConnectionPoolSize(POOL_SIZE)
                        .setClientName(REDISSION_ClIENT_NAME)
                        .setConnectionMinimumIdleSize(IDLE_SIZE)
                        .setConnectTimeout(TIME_OUT)
                        .setPingTimeout(30000);
                break;
             //master_slave 主从模式
            case 2:
                config.useMasterSlaveServers().setClientName(REDISSION_ClIENT_NAME)
                        .setConnectTimeout(TIME_OUT)
                        .setMasterAddress(master)
                        .addSlaveAddress(slave)
                        .setMasterConnectionMinimumIdleSize(IDLE_SIZE)
                        .setMasterConnectionPoolSize(POOL_SIZE)
                        .setSlaveConnectionMinimumIdleSize(IDLE_SIZE)
                        .setSlaveConnectionPoolSize(POOL_SIZE);
                break;
             //cluster 集群模式
            case 3:
                config.useClusterServers()
                        .addNodeAddress(cluster.split(","))//这是用的集群server
                        .setScanInterval(2000) //设置集群状态扫描时间
                        .setMasterConnectionPoolSize(10000) //设置连接数
                        .setSlaveConnectionPoolSize(10000);
                break;
        }
        return Redisson.create(config);
    }
}
3.2.4 RedissonLocker的具体实现类
@Service("redissonLocker")
public class RedissonLockerImpl implements DistributedLocker {

    @Autowired
    private RedissonClient redissonClient;

    /**************************可重入锁**************************/
    /**
     * 拿不到lock就不罢休,不然线程就一直block(阻塞)
     * 没有超时时间,默认30s
     *
     * @param lockKey
     * @return
     */
    @Override
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    /**
     * 自己设置超时时间
     *
     * @param lockKey 锁的key
     * @param timeout 秒 如果是-1,直到自己解锁,否则不会自动解锁
     * @return
     */
    @Override
    public RLock lock(String lockKey, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, TimeUnit.SECONDS);
        return lock;
    }

    /**
     * 自己设置超时时间
     *
     * @param lockKey 锁的key
     * @param unit 锁时间单位
     * @param timeout 超时时间
     *
     */
    @Override
    public RLock lock(String lockKey, TimeUnit unit, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }

    /**
     *  尝试加锁,最多等待waitTime,上锁以后leaseTime自动解锁
     * @param lockKey   锁key
     * @param unit      锁时间单位
     * @param waitTime  等到最大时间
     * @param leaseTime 锁失效时间
     * @return 如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false
     */
    @Override
    public boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }



    /**************************公平锁**************************/
    /**
     *   尝试加锁,最多等待waitTime,上锁以后leaseTime自动解锁
     * @param lockKey   锁key
     * @param unit      锁时间单位
     * @param waitTime  等到最大时间
     * @param leaseTime 锁失效时间
     * @return 如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false
     */
    public boolean fairLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
        RLock fairLock = redissonClient.getFairLock(lockKey);
        try {
            return fairLock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 释放锁
     * @param lockKey 锁key
     */
    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    /**
     * 释放锁
     */
    @Override
    public void unlock(RLock lock) {
        lock.unlock();
    }
}

四、附录:删除bigkey

4.1 Hash删除: hscan + hdel

public void delBigHash(String host, int port, String password, String bigHashKey) {
    Jedis jedis = new Jedis(host, port);
    if (password != null && !"".equals(password)) {
        jedis.auth(password);
    }
    ScanParams scanParams = new ScanParams().count(100);
    String cursor = "0";
    do {
        ScanResult<Entry<String, String>> scanResult = jedis.hscan(bigHashKey, cursor, scanParams);
        List<Entry<String, String>> entryList = scanResult.getResult();
        if (entryList != null && !entryList.isEmpty()) {
            for (Entry<String, String> entry : entryList) {
                jedis.hdel(bigHashKey, entry.getKey());
            }
        }
        cursor = scanResult.getStringCursor();
    } while (!"0".equals(cursor));
    
    //删除bigkey
    jedis.del(bigHashKey);
}

4.2 List删除: ltrim

public void delBigList(String host, int port, String password, String bigListKey) {
    Jedis jedis = new Jedis(host, port);
    if (password != null && !"".equals(password)) {
        jedis.auth(password);
    }
    long llen = jedis.llen(bigListKey);
    int counter = 0;
    int left = 100;
    while (counter < llen) {
        //每次从左侧截掉100个
        jedis.ltrim(bigListKey, left, llen);
        counter += left;
    }
    //最终删除key
    jedis.del(bigListKey);
}

4.3 Set删除: sscan + srem

public void delBigSet(String host, int port, String password, String bigSetKey) {
    Jedis jedis = new Jedis(host, port);
    if (password != null && !"".equals(password)) {
        jedis.auth(password);
    }
    ScanParams scanParams = new ScanParams().count(100);
    String cursor = "0";
    do {
        ScanResult<String> scanResult = jedis.sscan(bigSetKey, cursor, scanParams);
        List<String> memberList = scanResult.getResult();
        if (memberList != null && !memberList.isEmpty()) {
            for (String member : memberList) {
                jedis.srem(bigSetKey, member);
            }
        }
        cursor = scanResult.getStringCursor();
    } while (!"0".equals(cursor));
    
    //删除bigkey
    jedis.del(bigSetKey);
}

4.4 SortedSet删除: zscan + zrem

public void delBigZset(String host, int port, String password, String bigZsetKey) {
    Jedis jedis = new Jedis(host, port);
    if (password != null && !"".equals(password)) {
        jedis.auth(password);
    }
    ScanParams scanParams = new ScanParams().count(100);
    String cursor = "0";
    do {
        ScanResult<Tuple> scanResult = jedis.zscan(bigZsetKey, cursor, scanParams);
        List<Tuple> tupleList = scanResult.getResult();
        if (tupleList != null && !tupleList.isEmpty()) {
            for (Tuple tuple : tupleList) {
                jedis.zrem(bigZsetKey, tuple.getElement());
            }
        }
        cursor = scanResult.getStringCursor();
    } while (!"0".equals(cursor));
    
    //删除bigkey
    jedis.del(bigZsetKey);
}
  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值