Redis的见解

什么算Redis

Redis 概述

在我们日常的Java Web开发中，无不都是使用数据库来进行数据的存储，由于一般的系统任务中通常不会存在高并发的情况，所以这样看起来并没有什么问题，可是一旦涉及大数据量的需求，比如一些商品抢购的情景，或者是主页访问量瞬间较大的时候，单一使用数据库来保存数据的系统会因为面向磁盘，磁盘读/写速度比较慢的问题而存在严重的性能弊端，一瞬间成千上万的请求到来，需要系统在极短的时间内完成成千上万次的读/写操作，这个时候往往不是数据库能够承受的，极其容易造成数据库系统瘫痪，最终导致服务宕机的严重生产问题。

1. 当第一次读取数据的时候，读取 Redis 的数据就会失败，此时就会触发程序读取数据库，把数据读取出来，并且写入 Redis 中；
2. 当第二次以及以后需要读取数据时，就会直接读取 Redis，读到数据后就结束了流程，这样速度就大大提高了。

高速读/写的场合

在如今的互联网中，越来越多的存在高并发的情况，比如天猫双11、抢红包、抢演唱会门票等，这些场合都是在某一个瞬间或者是某一个短暂的时刻有成千上万的请求到达服务器，如果单纯的使用数据库来进行处理，就算不崩，也会很慢的，轻则造成用户体验极差用户量流失，重则数据库瘫痪，服务宕机，而这样的场合都是不允许的！

所以我们需要使用 Redis 来应对这样的高并发需求的场合，我们先来看看一次请求操作的流程图：

我们来进一步阐述这个过程：

1. 当一个请求到达服务器时，只是把业务数据在 Redis 上进行读写，而没有对数据库进行任何的操作，这样就能大大提高读写的速度，从而满足高速响应的需求；
2. 但是这些缓存的数据仍然需要持久化，也就是存入数据库之中，所以在一个请求操作完 Redis 的读/写之后，会去判断该高速读/写的业务是否结束，这个判断通常会在秒杀商品为0，红包金额为0时成立，如果不成立，则不会操作数据库；如果成立，则触发事件将 Redis 的缓存的数据以批量的形式一次性写入数据库，从而完成持久化的工作。

Redis 的安装

访问地址：https://github.com/ServiceStack

把 Redis 下载下来后找到一个合适的地方解压，就能得到如下图所示的目录

 为了方便启动，我们在该目录下新建一个 startup.cmd 的文件，然后将以下内容写入文件：

redis-server redis.windows.conf

这个命令其实就是在调用 redis-server.exe 命令来读取 redis.window.conf 的内容，我们双击刚才创建好的 startup.cmd 文件，就能成功的看到 Redis 启动：

或者在文件路径直接输入cmd

 就直接打开黑色命令窗口，然后输入

redis-server redis.windows.conf

我们可以打开同一个文件夹下的 redis-cli.exe 文件，这是 Redis 自带的一个客户端工具，它可以用来连接到我们当前的 Redis 服务器，我们做以下测试：

在 Java 中使用 Redis

第一步：添加 Jedis 依赖

想要在 Java 中使用 Redis 缓存，需要添加相关的Jar包依赖，打开Maven仓库的网站：https://mvnrepository.com/ ，搜索Jedis：

把它导入工程中去就可以啦

Jedis的基本使用

Redis操作指令大全带衍生：(63条消息) RedisTemplate使用最详解（二）--- opsForList()_学习中啊哈哈的博客-优快云博客

1. 创建Jedis对象

Jedis jedis = new Jedis() 无参构造默认为localhost，6379。

Jedis jedis = new Jedis(url,port) redis端口一般为6379，

使用jedis存储数据，jedis读取数据的操作命令和redis读取数据的操作命令基本相同。
字符串类型：
1. 存储数据：jedis.set(String key,String value);
2. 读取数据：String value = jedis.gett(String key);
3. 存储数据并在指定时间后删除：jedis.setex(String key，int seconds，String value);
4. 删除数据：jedis.dle(String key);
hash类型：map
1. 存储数据：jedis.hset(String key,String field,String value);
2. 读取某个数据：String value = jedis.hget(String key,String field);
3. 读取所有数据：Map<String,String> map = jedis.hgetall(String key);
4. 删除数据：jedis.hdel(String key,String field);
list类型，可以重复：
1. 向列表最左边添加数据：jedis.lpush(String key,String...strings);可以存储多个数据，逗号隔开。
2. 向列表最右边添加数据：jedis.rpush(String key,String...strings);
3. 按照范围查询数据：jedis.lrange(String key,long start,long end);
4. 删除列表最左边的数据：jedis.lpop(String key);
5. 删除列表最右边的数据：jedis.rpop(String key);
set类型,不可重复:
1. 存储数据：jedis.sadd(String key,String...strings);可以存储多个数据，逗号隔开。
2. 获取数据：jedis.smembers(String key);
3. 删除数据：jedis.srem(String key,String strings);可以删除多个数据，逗号隔开。
sorted类型，不可重复，有序：
1. 存储数据：jedis.zadd(String key,double score,String value)；
2. 获取数据：jedis.zrange(String key,long start,long end);
3. 删除数据：jedis.zrem(String key,String value);

public class RedisTest {

    @Test
    public void test1(){
        Jedis jedis = new Jedis("localhost",6379);

        jedis.set("username","lxyk");
        System.out.println(jedis.get("username"));
        jedis.close();
    }

    //String
    @Test
    public void test2(){
        Jedis jedis = new Jedis("localhost",6379);

        //存储
        jedis.set("username1","lxyk");
        //获取
        System.out.println(jedis.get("username1"));

        //  这个 key和value  存进去  20秒之后会自动删除
        jedis.setex("code",20,"haohaohao");

        jedis.close();
    }

    //hash
    @Test
    public void test3(){
        Jedis jedis = new Jedis();//如果使用空参构造，默认值急速  localhost 6379
        //存储
        jedis.hset("aaaa","naem","fbb");
        jedis.hset("aaaa","age","23");
        jedis.hset("aaaa","gender","male");

        //获取hash
        String s = jedis.hget("aaaa", "naem");
        System.out.println(s);

        Map<String, String> map = jedis.hgetAll("aaaa");
        for (String key : map.keySet()) {
            String value = map.get(key);
            System.out.println(key + ":"+value);
        }

        jedis.close();

    }


    //list
    @Test
    public void test4(){
        Jedis jedis = new Jedis();

        //存储
        jedis.lpush("myList","a","b","c");  //左边存
        jedis.rpush("myList","a","b","c");  //右边存

        //获取
        List<String> myList = jedis.lrange("myList", 0, -1);
        System.out.println("myList = " + myList);

        //list弹出
        System.out.println(jedis.lpop("myList"));   //左弹出
        System.out.println(jedis.rpop("myList"));   //右弹出


        //获取
        List<String> myList2 = jedis.lrange("myList", 0, -1);
        System.out.println("myList2 = " + myList2);

        jedis.close();

    }

    //set
    @Test
    public void test5(){
        Jedis jedis = new Jedis();

        //set存储
        jedis.sadd("myset","java","php","C++","Go");

        //set获取
        Set<String> myset = jedis.smembers("myset");
        System.out.println("myset = " + myset);

        jedis.close();
    }

    // sortdset
    @Test
    public void test6(){
        Jedis jedis = new Jedis();
        // 存储
        jedis.zadd("mysortdset",3,"李白");
        jedis.zadd("mysortdset",29,"妲己");
        jedis.zadd("mysortdset",26,"韩信");

        //获取
        Set<String> mysortdset = jedis.zrange("mysortdset", 0, -1);
        System.out.println("mysortdset = " + mysortdset);

        jedis.close();

    }

 

}

Jedis连接池的基本配置和使用

#最大活动对象数     
redis.pool.maxTotal=1000    
#最大能够保持idel状态的对象数      
redis.pool.maxIdle=100  
#最小能够保持idel状态的对象数   
redis.pool.minIdle=50    
#当池内没有返回对象时，最大等待时间    
redis.pool.maxWaitMillis=10000    
#当调用borrow Object方法时，是否进行有效性检查    
redis.pool.testOnBorrow=true    
#当调用return Object方法时，是否进行有效性检查    
redis.pool.testOnReturn=true  
#“空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1.  
redis.pool.timeBetweenEvictionRunsMillis=30000  
#向调用者输出“链接”对象时，是否检测它的空闲超时；  
redis.pool.testWhileIdle=true  
# 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3.  
redis.pool.numTestsPerEvictionRun=50  
#redis服务器的IP    
redis.ip=xxxxxx  
#redis服务器的Port    
redis1.port=6379 

代码：

  //jedis连接池
    @Test
    public void test7(){
        //创建一个配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(50);
        config.setMaxIdle(10);

        //创建连接池对象
        JedisPool jedisPool = new JedisPool(config,"localhost",6379);

        //得到Jedis获取连接
        Jedis resource = jedisPool.getResource();
        //设置数据
        resource.set("hehe","fbbb");
        //获取
        System.out.println(resource.get("hehe"));

        //关闭连接
        resource.close();

    }

通过工具类连接

配置文件：

host=127.0.0.1
port=6379
maxTotal=50
maxIdle=10

工具类

//工具类
public class JedisPoolUtils {
    private static JedisPool jedisPool;

    static {
        //读取配置文件
        InputStream is =
                JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedsi.properties");

        //创建
        Properties pro = new Properties();

        try {
            pro.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //获取数据，设置到JedisPoolConfig中
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(Integer.parseInt(pro.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(pro.getProperty("maxIdle")));

        jedisPool =
                new JedisPool(config,pro.getProperty("host"),Integer.parseInt(pro.getProperty("port")));

    }

    //获取连接的方法
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }



}

代码

//工具类操作
    @Test
    public void test8(){
        //通过工具类连接
        Jedis jedis = JedisPoolUtils.getJedis();

        jedis.set("hello","world");

        jedis.close();
    }

StringBoot操作Redis

（1）在SpringBoot中添加Redis依赖：

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

（2）添加配置文件：

spring:
  # 环境 dev|test|prod
  profiles:
    active: dev
  servlet:
    multipart:
      max-file-size: 100MB
      max-request-size: 100MB
      enabled: true
  redis:
    database: 0           # Redis服务器数据库
    host: 127.0.0.1    # Redis服务器地址
    port: 6379            # Redis服务器连接端口
    timeout: 6000ms       # 连接超时时间（毫秒）
    jedis:
      pool:
        max-active: 200   # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1      # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 10      # 连接池中的最大空闲连接
        min-idle: 0     # 连接池中的最小空闲连接

  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis?serverTimzone=UTC
    hikari: # springboot 2.0 整合了hikari ,据说这是目前性能最好的java数据库连接池
      username: root
      password: root

redis 通用配置类

作用 处理Springboot使用 RedisTemplate过程中的编码问题

现象如下，看数据的时候不方便

@Configuration    //Redis配置类
public class RedisConfig {
    //固定模板
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String,Object>redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        //json序列化配置
        Jackson2JsonRedisSerializer jsonRedisSerializer =
                new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jsonRedisSerializer.setObjectMapper(mapper);
        //String序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //  value序列化采用  Jackson
        template.setValueSerializer(jsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

redis工具类

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    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 键(不能为 Null)
     * @return true 存在 false 不存在
     */
    public boolean hashKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete((Collection<String>) 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)
     * @return
     */
    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)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().decrement(key, delta);
    }

    // ===============================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;
        }

    }

    // ============================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;
        }
    }

    // ================================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);
    }

    // ===============================HyperLogLog=================================

    public long pfadd(String key, String value) {
        return redisTemplate.opsForHyperLogLog().add(key, value);
    }

    public long pfcount(String key) {
        return redisTemplate.opsForHyperLogLog().size(key);
    }

    public void pfremove(String key) {
        redisTemplate.opsForHyperLogLog().delete(key);
    }

    public void pfmerge(String key1, String key2) {
        redisTemplate.opsForHyperLogLog().union(key1, key2);
    }
}

实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component       //注入到容器中
public class User implements Serializable{   //实现序列化
    private int id;
    private String name;
}

测试

@SpringBootTest
class SpringbootRedisApplicationTests {
    @Autowired
    ObjectMapper objectMapper;


    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.boundValueOps("xxxxx").set("fbb");
    }

    @Test
    public void test(){
        Object name = redisTemplate.boundValueOps("xxxxx").get();
        System.out.println(name);
    }

    @Test
    public void test2(){
        //  实际开发都是JSON传递对象
        User user = new User(001,"冯宝宝");
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

    /*
    * 操作字符串：opsForValue()
    * 操作list：opsForList()
    * 操作set：opsForSet()
    * 操作hash：opsForHash()
    * opsForZSet()
    * */

    /**
     * 操作字符串：opsForValue()
     */
    @Test
    public void test4(){
        redisTemplate.opsForValue().set("password","www.baidu.com");
        System.out.println(redisTemplate.opsForValue().get("password"));
    }


    /**
     * 操作list：opsForList()
     */
    @Test
    public void test5(){
        ListOperations<Object, User> listOps = (ListOperations<Object, User>) redisTemplate.opsForList();
        User user = new User(18, "18");
        User user1 = new User(19, "18");
        ArrayList<User> userList = new ArrayList<>();
        userList.add(user);
        userList.add(user1);
        listOps.leftPushAll("users", userList);
        //此时拿到的是jackson序列化后的json字符串
        List<User> lists = listOps.range("users", 0,1);
        System.out.println("lists = " + lists);
        //jackson解析出具体的bean
        List<User> users = objectMapper.convertValue(lists, new TypeReference<List<User>>() {
        });
        System.out.println(users);
    }

    /**
     *操作set：opsForSet()
     */
    @Test
    public void test6(){
        // add(K key, V... values)存入，members(K key)取值
        redisTemplate.opsForSet().add("setValue","A","B","C","B","D","E","F");
        Set set = redisTemplate.opsForSet().members("setValue");
        System.out.println("通过members(K key)方法获取变量中的元素值:" + set);

        //size(K key)获取长度
        long setLength = redisTemplate.opsForSet().size("setValue");
        System.out.println("通过size(K key)方法获取变量中元素值的长度:" + setLength);

       //randomMember(K key)获取变量中元素
        Object randomMember = redisTemplate.opsForSet().randomMember("setValue");
        System.out.println("通过randomMember(K key)方法随机获取变量中的元素:" + randomMember);

        //randomMembers(K key, long count)获取变量中指定个数的元素
        List randomMembers = redisTemplate.opsForSet().randomMembers("setValue",2);
        System.out.println("通过randomMembers(K key, long count)方法随机获取变量中指定个数的元素:" + randomMembers);

        //isMember(K key, Object o)检查给定的元素是否在变量中。
        boolean isMember = redisTemplate.opsForSet().isMember("setValue","A");
        System.out.println("通过isMember(K key, Object o)方法检查给定的元素是否在变量中:" + isMember);

        //move(K key, V value, K destKey)   转移变量的元素值到目的变量。
        boolean isMove = redisTemplate.opsForSet().move("setValue","A","destSetValue");
        if(isMove){
            set = redisTemplate.opsForSet().members("setValue");
            System.out.print("通过move(K key, V value, K destKey)方法转移变量的元素值到目的变量后的剩余元素:" + set);
            set = redisTemplate.opsForSet().members("destSetValue");
            System.out.println(",目的变量中的元素值:" + set);
        }

        //pop(K key) 弹出变量中的元素。
        Object popValue = redisTemplate.opsForSet().pop("setValue");
        System.out.print("通过pop(K key)方法弹出变量中的元素:" + popValue);
        set = redisTemplate.opsForSet().members("setValue");
        System.out.println(",剩余元素:" + set);

        //、remove(K key, Object... values)批量移除变量中的元素。
        long removeCount = redisTemplate.opsForSet().remove("setValue","E","F","G");
        System.out.print("通过remove(K key, Object... values)方法移除变量中的元素个数:" + removeCount);
        set = redisTemplate.opsForSet().members("setValue");
        System.out.println(",剩余元素:" + set);

    }

    @Autowired
    private RedisUtil redisUtil;

    @Test
    public void test3(){
        redisUtil.set("names","fbb'");
        System.out.println(redisUtil.get("names"));
    }


}

详情操作：

操作字符串：opsForValue：(63条消息) RedisTemplate之opsForValue使用说明_太阳晒屁股了的博客-优快云博客_redistemplate.opsforvalue.set

操作List：opsForList：(63条消息) RedisTemplate集合使用说明-opsForList(二）_椰汁菠萝的博客-优快云博客_redis rightpop

操作hash：opsForHash()：(63条消息) RedisTemplate使用最详解（三）--- opsForHash()_学习中啊哈哈的博客-优快云博客_opsforhash

操作opsForZSet()：(63条消息) RedisTemplate常用集合使用说明-opsForZSet(六)_凌辰1228的博客-优快云博客_opsforzset

操作Set：opsForSet：(63条消息) RedisTemplate set集合使用说明-opsForSet(四)_椰汁菠萝的博客-优快云博客_redistemplate.opsforset