Redis基本使用

2023-03-23

一、事务

事务的四个特性(ACID)：

原子性（Atomicity）： 指事务是一个不可分割的最小工作单位，事务中的操作只有都发生和都不发生两种情况（要么同时成功，要么同时失败）
一致性（Consistency）： 事务必须使数据库从一个一致状态变换到另外一个一致状态
隔离性（Isolation）： 一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰
持久性（Durability）： 一个事务一旦提交成功，它对数据库中数据的改变将是永久性的，接下来的其他操作或故障不应对其有任何影响

Redis事务本质是一组命令的集合，顺序执行

一次性、顺序性、排他性，执行一系列的命令

Redis单条命令是保证原子性，但是其事务不保证原子性，没有隔离级别的概念

redis的事务：

开启事务（multi）
命令入队（……）
执行事务（exec）
放弃事务（discard）

事务异常

编译型异常（代码有误）：队列中的命令全部不执行
运行时异常（1/0）：其余命令正常执行，异常的命令抛出

监控 watch

乐观锁
- 不上锁，只对写上锁，更新时判断是否被修改
- 获取version
- 更新的时候比较version
悲观锁
- 无论做什么都加锁
- 影响性能

watch 使用watch等效于redis的乐观锁操作
unwatch 取消监控，解锁

二、Jedis

Jedis是java链接开发工具，使用java操作redis

导入对应的依赖

<dependencies>  
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->  
    <dependency>  
        <groupId>redis.clients</groupId>  
        <artifactId>jedis</artifactId>  
        <version>3.2.0</version>  
    </dependency>    
    <dependency>        
    <groupId>com.alibaba</groupId>  
        <artifactId>fastjson</artifactId>  
        <version>2.0.25</version>  
    </dependency>  
</dependencies>

测试链接

public class Ping {  
    public static void main(String[] args) {  
        Jedis jedis = new Jedis("127.0.0.1",6379);    
        //查看服务是否运行  
        System.out.println(jedis.ping());  
    }  
}

事务测试

public class TestMulti {  
    public static void main(String[] args) {  
        //创建客户端连接服务端，redis服务端需要被开启  
        Jedis jedis = new Jedis("127.0.0.1", 6379);  
        jedis.flushDB();  
  
        JSONObject jsonObject = new JSONObject();  
        jsonObject.put("hello", "world");  
        jsonObject.put("name", "java");  
        //开启事务  
        Transaction multi = jedis.multi();  
        String result = jsonObject.toJSONString();  
        try{  
            //向redis存入一条数据  
            multi.set("json", result);  
            //再存入一条数据  
            multi.set("json2", result);  
            //这里引发了异常，用0作为被除数  
            int i = 100/0;  
            //如果没有引发异常，执行进入队列的命令  
            multi.exec();  
        }catch(Exception e){  
            e.printStackTrace();  
            //如果出现异常，回滚  
            multi.discard();  
        }finally{  
            System.out.println(jedis.get("json"));  
            System.out.println(jedis.get("json2"));  
            //最终关闭客户端  
            jedis.close();  
        }  
    }  
}

整合SpringBoot

jedis： 直连，多线程下不安全，则需要使用jedis pool连接池，类似于BIO模式

lettuce： 采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，减少了线程数据，类似于NIO模式

引入

<dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-data-redis</artifactId>  
</dependency>

链接配置

spring:  
    redis:  
      host: 127.0.0.1  
      port: 6379

测试

class SpringbootRedisApplicationTests {  
  
    @Autowired  
    private RedisTemplate<String,String> redisTemplate;  
  
    @Test  
    void contextLoads() {  
        RedisConnection connection = Objects.requireNonNull(redisTemplate.getConnectionFactory()).getConnection();  
        connection.flushAll();  
        redisTemplate.opsForValue().set("myKey","myValue");  
        System.out.println(redisTemplate.opsForValue().get("myKey"));  
    }  
  
}

自定义RedisTemplate

@Configuration  
public class RedisConfig {  
  
  @Bean  
  @SuppressWarnings("all")  
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {  
      // 为了开发方便一般直接使用<String, Object>
      RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();  
      template.setConnectionFactory(factory); 
      // json序列化
      Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);  
      ObjectMapper om = new ObjectMapper();  
      om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
      om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);  
      jackson2JsonRedisSerializer.setObjectMapper(om);  
      // string的序列化
      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
  
      // key采用String的序列化方式  
      template.setKeySerializer(stringRedisSerializer);  
      // hash的key也采用String的序列化方式  
      template.setHashKeySerializer(stringRedisSerializer);  
      // value序列化方式采用jackson  
      template.setValueSerializer(jackson2JsonRedisSerializer);  
      // hash的value序列化方式采用jackson  
      template.setHashValueSerializer(jackson2JsonRedisSerializer);  
      template.afterPropertiesSet();  
  
      return template;  
  }  
  
  
}

封装方法

RedisUtil

@Component  
public final class RedisUtil {  
  
    @Autowired  
    private RedisTemplate<String, Object> redisTemplate;  
  
    // =============================common============================  
    /**  
     * 指定缓存失效时间  
     * @param key  键  
     * @param time 时间(秒)  
     */    public boolean expire(String key, long time) {  
        try {  
            if (time > 0) {  
                redisTemplate.expire(key, time, TimeUnit.SECONDS);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
    /**  
     * 根据key 获取过期时间  
     * @param key 键 不能为null  
     * @return 时间(秒) 返回0代表为永久有效  
     */  
    public long getExpire(String key) {  
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);  
    }  
  
  
    /**  
     * 判断key是否存在  
     * @param key 键  
     * @return true 存在 false不存在  
     */  
    public boolean hasKey(String key) {  
        try {  
            return redisTemplate.hasKey(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 删除缓存  
     * @param key 可以传一个值 或多个  
     */  
    @SuppressWarnings("unchecked")  
    public void del(String... key) {  
        if (key != null && key.length > 0) {  
            if (key.length == 1) {  
                redisTemplate.delete(key[0]);  
            } else {  
                redisTemplate.delete(CollectionUtils.arrayToList(key));  
            }  
        }  
    }  
  
  
    // ============================String=============================  
  
    /**  
     * 普通缓存获取  
     * @param key 键  
     * @return 值  
     */  
    public Object get(String key) {  
        return key == null ? null : redisTemplate.opsForValue().get(key);  
    }  
  
    /**  
     * 普通缓存放入  
     * @param key   键  
     * @param value 值  
     * @return true成功 false失败  
     */  
  
    public boolean set(String key, Object value) {  
        try {  
            redisTemplate.opsForValue().set(key, value);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 普通缓存放入并设置时间  
     * @param key   键  
     * @param value 值  
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期  
     * @return true成功 false 失败  
     */  
  
    public boolean set(String key, Object value, long time) {  
        try {  
            if (time > 0) {  
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);  
            } else {  
                set(key, value);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 递增  
     * @param key   键  
     * @param delta 要增加几(大于0)  
     */    public long incr(String key, long delta) {  
        if (delta < 0) {  
            throw new RuntimeException("递增因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, delta);  
    }  
  
  
    /**  
     * 递减  
     * @param key   键  
     * @param delta 要减少几(小于0)  
     */    public long decr(String key, long delta) {  
        if (delta < 0) {  
            throw new RuntimeException("递减因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, -delta);  
    }  
  
  
    // ================================Map=================================  
  
    /**  
     * HashGet     * @param key  键 不能为null  
     * @param item 项 不能为null  
     */    public Object hget(String key, String item) {  
        return redisTemplate.opsForHash().get(key, item);  
    }  
  
    /**  
     * 获取hashKey对应的所有键值  
     * @param key 键  
     * @return 对应的多个键值  
     */  
    public Map<Object, Object> hmget(String key) {  
        return redisTemplate.opsForHash().entries(key);  
    }  
  
    /**  
     * HashSet     * @param key 键  
     * @param map 对应多个键值  
     */  
    public boolean hmset(String key, Map<String, Object> map) {  
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * HashSet 并设置时间  
     * @param key  键  
     * @param map  对应多个键值  
     * @param time 时间(秒)  
     * @return true成功 false失败  
     */  
    public boolean hmset(String key, Map<String, Object> map, long time) {  
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            if (time > 0) {  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 向一张hash表中放入数据,如果不存在将创建  
     *  
     * @param key   键  
     * @param item  项  
     * @param value 值  
     * @return true 成功 false失败  
     */  
    public boolean hset(String key, String item, Object value) {  
        try {  
            redisTemplate.opsForHash().put(key, item, value);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
    /**  
     * 向一张hash表中放入数据,如果不存在将创建  
     *  
     * @param key   键  
     * @param item  项  
     * @param value 值  
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间  
     * @return true 成功 false失败  
     */  
    public boolean hset(String key, String item, Object value, long time) {  
        try {  
            redisTemplate.opsForHash().put(key, item, value);  
            if (time > 0) {  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 删除hash表中的值  
     *  
     * @param key  键 不能为null  
     * @param item 项 可以使多个 不能为null  
     */    public void hdel(String key, Object... item) {  
        redisTemplate.opsForHash().delete(key, item);  
    }  
  
  
    /**  
     * 判断hash表中是否有该项的值  
     *  
     * @param key  键 不能为null  
     * @param item 项 不能为null  
     * @return true 存在 false不存在  
     */  
    public boolean hHasKey(String key, String item) {  
        return redisTemplate.opsForHash().hasKey(key, item);  
    }  
  
  
    /**  
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回  
     *  
     * @param key  键  
     * @param item 项  
     * @param by   要增加几(大于0)  
     */    public double hincr(String key, String item, double by) {  
        return redisTemplate.opsForHash().increment(key, item, by);  
    }  
  
  
    /**  
     * hash递减  
     *  
     * @param key  键  
     * @param item 项  
     * @param by   要减少记(小于0)  
     */    public double hdecr(String key, String item, double by) {  
        return redisTemplate.opsForHash().increment(key, item, -by);  
    }  
  
  
    // ============================set=============================  
  
    /**  
     * 根据key获取Set中的所有值  
     * @param key 键  
     */  
    public Set<Object> sGet(String key) {  
        try {  
            return redisTemplate.opsForSet().members(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;        }  
    }  
  
  
    /**  
     * 根据value从一个set中查询,是否存在  
     *  
     * @param key   键  
     * @param value 值  
     * @return true 存在 false不存在  
     */  
    public boolean sHasKey(String key, Object value) {  
        try {  
            return redisTemplate.opsForSet().isMember(key, value);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 将数据放入set缓存  
     *  
     * @param key    键  
     * @param values 值 可以是多个  
     * @return 成功个数  
     */  
    public long sSet(String key, Object... values) {  
        try {  
            return redisTemplate.opsForSet().add(key, values);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
  
    /**  
     * 将set数据放入缓存  
     *  
     * @param key    键  
     * @param time   时间(秒)  
     * @param values 值 可以是多个  
     * @return 成功个数  
     */  
    public long sSetAndTime(String key, long time, Object... values) {  
        try {  
            Long count = redisTemplate.opsForSet().add(key, values);  
            if (time > 0)  
                expire(key, time);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
  
    /**  
     * 获取set缓存的长度  
     *  
     * @param key 键  
     */  
    public long sGetSetSize(String key) {  
        try {  
            return redisTemplate.opsForSet().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
  
    /**  
     * 移除值为value的  
     *  
     * @param key    键  
     * @param values 值 可以是多个  
     * @return 移除的个数  
     */  
  
    public long setRemove(String key, Object... values) {  
        try {  
            Long count = redisTemplate.opsForSet().remove(key, values);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
    // ===============================list=================================  
  
    /**  
     * 获取list缓存的内容  
     *  
     * @param key   键  
     * @param start 开始  
     * @param end   结束 0 到 -1代表所有值  
     */  
    public List<Object> lGet(String key, long start, long end) {  
        try {  
            return redisTemplate.opsForList().range(key, start, end);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;        }  
    }  
  
  
    /**  
     * 获取list缓存的长度  
     *  
     * @param key 键  
     */  
    public long lGetListSize(String key) {  
        try {  
            return redisTemplate.opsForList().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
  
    /**  
     * 通过索引 获取list中的值  
     *  
     * @param key   键  
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推  
     */  
    public Object lGetIndex(String key, long index) {  
        try {  
            return redisTemplate.opsForList().index(key, index);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;        }  
    }  
  
  
    /**  
     * 将list放入缓存  
     *  
     * @param key   键  
     * @param value 值  
     */  
    public boolean lSet(String key, Object value) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 将list放入缓存  
     * @param key   键  
     * @param value 值  
     * @param time  时间(秒)  
     */    public boolean lSet(String key, Object value, long time) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            if (time > 0)  
                expire(key, time);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
  
    }  
  
  
    /**  
     * 将list放入缓存  
     *  
     * @param key   键  
     * @param value 值  
     * @return  
     */  
    public boolean lSet(String key, List<Object> value) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
  
    }  
  
  
    /**  
     * 将list放入缓存  
     *  
     * @param key   键  
     * @param value 值  
     * @param time  时间(秒)  
     * @return  
     */  
    public boolean lSet(String key, List<Object> value, long time) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            if (time > 0)  
                expire(key, time);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 根据索引修改list中的某条数据  
     *  
     * @param key   键  
     * @param index 索引  
     * @param value 值  
     * @return  
     */  
  
    public boolean lUpdateIndex(String key, long index, Object value) {  
        try {  
            redisTemplate.opsForList().set(key, index, value);  
            return true;        } catch (Exception e) {  
            e.printStackTrace();  
            return false;        }  
    }  
  
  
    /**  
     * 移除N个值为value  
     *     * @param key   键  
     * @param count 移除多少个  
     * @param value 值  
     * @return 移除的个数  
     */  
  
    public long lRemove(String key, long count, Object value) {  
        try {  
            Long remove = redisTemplate.opsForList().remove(key, count, value);  
            return remove;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
  
    }  
  
}