Lettuce redisTemplate 重连 lettuce操作redis

文章目录

• 一、前言

• 1.1 搭建项目
• 1.2 选择相关依赖
• 1.3 移除lettuce
• 1.4 修改项目配置文件
• 1.5 编写Redis相关配置类

• 二、Jedis操作Redis的五种数据类型

• 2.1 初始化连接Redis
• 2.2 使用Jedis连接池操作Redis
• 2.3 操作String类型数据
• 2.4 操作Hash类型数据
• 2.5 操作List类型数据
• 2.6 操作set类型数据
• 2.7 操作sorted set类型数据
• 2.8 释放资源

Redis相关学习如下一篇文章教你Redis的入门基本操作【一】

一、前言

准备前提工作，搭建项目
新建项目New ----> Project

1.1 搭建项目

1.2 选择相关依赖

勾选这两个依赖

1.3 移除lettuce

打开pom.xml文件，移除lettuce相关依赖，因为此项目案例使用Jedis操作Redis的几种数据。（相关依赖如图）

<dependencies>
        <!--Redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <!--
                1.x 的版本默认采用的连接池技术是Jedis，
                2.0 以上版本默认连接池技术是Lettuce,
                如果采用Jedis，需要排除Lettuce的依赖
                -->
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--Jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <!--Web组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--Test组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

1.4 修改项目配置文件

将application.properties修改为application.yml，相关依赖如下：

spring:
  redis:
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器端口
    port: 6379
    # Redis服务器密码
    password:
    # 选择哪个库，默认为0
    database: 0
    # 连接超时时间
    timeout: 10000ms
    jedis:
      pool:
        # 最大连接数，默认8
        max-active: 1024
        # 最大连接阻塞等待时间，单位毫秒，默认-1ms
        max-wait: 10000ms
        # 最大空闲连接，默认8
        max-idle: 200
        # 最小空闲连接，默认0
        min-idle: 5

1.5 编写Redis相关配置类

@Configuration
public class RedisConfig {

    // 服务器地址
    @Value("${spring.redis.host}")
    private String host;
    // 服务器端口
    @Value("${spring.redis.port}")
    private int port;
    //服务器密码
    @Value("${spring.redis.password}")
    private String password;
    // 连接超时时间
    @Value("${spring.redis.timeout}")
    private String timeout;
    // 最大连接数
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxTotal;
    // 最大连接等待阻塞时间
    @Value("${spring.redis.jedis.pool.max-wait}")
    private String maxWaitMillis;
    // 最大空闲连接
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;
    // 最小空闲连接
    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;


    @Bean
    public JedisPool getJedisPool() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大连接数
        jedisPoolConfig.setMaxTotal(maxTotal);
        // 最大连接阻塞时间
        jedisPoolConfig.setMaxWaitMillis(Long.valueOf(maxWaitMillis.substring(0,maxWaitMillis.length()-2)));
        // 最大空闲连接
        jedisPoolConfig.setMaxIdle(maxIdle);
        // 最小空闲连接
        jedisPoolConfig.setMinIdle(minIdle);
        
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, Integer.valueOf(timeout.substring(0,timeout.length()-2)), null);

        return jedisPool;
    }
}

二、Jedis操作Redis的五种数据类型

在测试类中，使用Jedis进行测试

2.1 初始化连接Redis

/**
     * 连接Redis
     */
    @Test
    public void initCount() {
        // 创建Jedis对象，连接Redis服务器
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        // 设置认证密码
//        jedis.auth("root");
        // 指定数据库
        jedis.select(1);
        // 使用ping命令，测试是否连接成功
        String result = jedis.ping();
        System.out.println(result);
        // 添加一条数据
        jedis.set("name", "zhangsan");
        // 获取数据
        String name = jedis.get("name");
        System.out.println(name);
        // 释放资源
        if (jedis != null) {
            jedis.close();
        }
    }

2.2 使用Jedis连接池操作Redis

/**
     * 使用Jedis连接池操作redis
     */
    @Test
    public void initCountPool() {
        // 初始化Jedis连接池对象
        JedisPool jedisPool = new JedisPool(new JedisPoolConfig(), "127.0.0.1", 6379, 10000, null);
        // 从连接池获取Jedis对象
        Jedis jedis = jedisPool.getResource();
        // 指定数据库，默认为0
        jedis.select(2);
        // 使用ping命令，测试是否连接成功
        String result = jedis.ping();
        System.out.println(result);
        // 添加一条数据
        jedis.set("name", "zhangsan");
        // 读取一条数据
        String name = jedis.get("name");
        System.out.println(name);
        // 释放资源
        if (jedis != null) {
            jedis.close();
        }
    }

2.3 操作String类型数据

为了避免每次在Redis中存取数据，都必须要通过Jedis的进行连接，则可以通过注解注入到Spring的容器中进行管理。

@Autowired
    private JedisPool jedisPool;

    private Jedis jedis = null;

    // 初始化Jedis实例对象
    @BeforeEach
    public void initRedisCount() {
        jedis = jedisPool.getResource();
    }


    /**
     * Jedis操作String类型数据
     */
    @Test
    public void testString() {
    	jedis.select(1);
        // 添加一条数据
        jedis.set("name", "zs");
        // 获取一条数据
        String name = jedis.get("name");
        System.out.println(name);
        // 添加多条数据，参数的奇数位是key，偶数位为value
        jedis.mset("address", "shanghai", "sex", "0");
        // 获取多条数据
        List<String> list = jedis.mget("name", "address", "sex");
        list.forEach(System.out::println);
        // 删除数据
        jedis.del("name");
    }

2.4 操作Hash类型数据

/**
     * 操作Hash类型数据
     */
    @Test
    public void testHash() {
        /**
         * 添加一条数据
         *      第一个参数：redis的key
         *      第二个参数：hash的key
         *      第三个参数：hash的value
         */
        jedis.hset("user", "name", "zhangsan");
        /**
         * 获取一条数据
         *      第一个参数：redis的key
         *      第二个参数：hash的key
         */
        String name = jedis.hget("user", "name");
        System.out.println(name);

        // 添加多条数据
        Map<String, String> map = new HashMap<>();
        map.put("age", "18");
        map.put("sex", "0");
        jedis.hmset("user", map);

        // 获取多条数据
        List<String> list = jedis.hmget("user", "name", "age", "sex");
        System.out.println(list);

        // 获取hash类型的所有数据
        Map<String, String> user = jedis.hgetAll("user");
        user.entrySet().forEach(e -> {
            System.out.println(e.getKey() + "------->" + e.getValue());
        });

        /**
         * 删除
         *      第一个参数：redis的key
         *      第二个参数：hash的key
         *      第三个参数：hash的value
         */
        jedis.hdel("user", "name", "age");
    }

2.5 操作List类型数据

/**
     * 操作List类型数据
     */
    @Test
    public void testList() {
        // 左添加
        jedis.lpush("students", "aaa", "bbb", "ccc");
        // 右添加
        jedis.rpush("students", "ee", "ff");
        /**
         * 获取数据
         *      第一个参数：redis的key
         *      第二个参数：起始下标
         *      第三个参数：结束下标
         */
        List<String> list = jedis.lrange("students", 0, 4);
        list.forEach(System.out::println);
        //获取list长度
        Long total = jedis.llen("students");
        System.out.println("list集合长度：" + total);
        /**
         * 删除数据
         *      第一个参数：redis的key
         *      第二个参数：参数值的个数
         *      第三个参数：需要删除的值
         */
        jedis.lrem("students", 1, "ee");

        // 左弹出
//        String left = jedis.lpop("students");
//        System.out.println("左边弹出的数据：" + left);
        //右弹出
//        String right = jedis.lpop("students");
//        System.out.println("右边弹出的数据：" + right);
    }

2.6 操作set类型数据

/**
     * 操作set类型数据
     */
    @Test
    public void testSet() {
        // 添加数据
        jedis.sadd("letters","aa","bb","cc","dd");
        // 获取数据
        Set<String> set = jedis.smembers("letters");
        set.forEach(System.out::println);
        // 获取set集合长度
        Long total = jedis.scard("letters");
        System.out.println("set集合的长度：" + total);
        // 删除数据
        jedis.srem("letters","aa","dd");
    }

2.7 操作sorted set类型数据

/**
     * 操作sorted set类型数据
     */
    @Test
    public void testSortedSet() {
        Map<String,Double> map = new HashMap<>();
        map.put("zhangsan",6D);
        map.put("lisi",2D);
        map.put("wangwu",7D);
        map.put("zhaoliu",9D);
        map.put("tianqi",5D);
        // 添加数据
        jedis.zadd("score",map);
        /**
         * 获取数据
         *      第一个参数：redis的key
         *      第二个参数：起始下标
         *      第三个参数：结束下标
         */
        Set<String> set = jedis.zrange("score", 0, 4);
        set.forEach(System.out::println);
        // 获取sorted set集合长度
        Long total = jedis.zcard("score");
        System.out.println("sorted set集合的长度：" + total);
        // 删除数据
        jedis.zrem("score","lisi","zhaoliu");

    }

2.8 释放资源

// 释放资源
    @AfterEach
    public void closeRedisCount() {
        if (jedis != null) {
            jedis.close();
        }
    }