Redis实战：Redis在Java中的基本使用

约定不等于承诺〃 2023-10-14 22:56 56阅读 0赞

> 本片将介绍 Redis 在 Java 中的基本使用

--------------------

### 文章目录 ###

*   *   *   *  1、使用jedis操作redis
             *   *  1.1、Jedis简介
                 *  1.2、引入jedis的Maven依赖
                 *  1.2、获取连接
                 *  1.3、使用实例
             *  2、对于JedisPooled的使用
             *   *  2.1、使用JedisPooled
                 *  2.2、关于连接池
             *  3、SpringBoot下使用Redis
             *   *  3.1、引入Maven依赖
                 *  3.2、配置Redis连接
                 *  3.3、创建RedisTemplate
             *  3.4、使用RedisTemplate

--------------------

#### 1、使用jedis操作redis ####

##### 1.1、Jedis简介 #####

Jedis 是 Java 语言开发的 Redis 客户端工具包，用于 Java 语言与 Redis 数据进行交互。

Jedis 在 github 官网地址：[https://github.com/redis/jedis\#readme][https_github.com_redis_jedis_readme]

Jedis 只是对 Redis 命令的封装，掌握 Redis 命令便可轻易上手 Jedis。

Jedis 遵循 RESP 协议规范开发，具有良好的通用性与可读性。

##### 1.2、引入jedis的Maven依赖 #####

<dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>4.4.3</version>
            </dependency>

##### 1.2、获取连接 #####

对于许多应用程序，需要连接到 Redis 时。最好使用连接池。可以像这样实例化一个 Jedis 连接池:

JedisPool pool = new JedisPool("localhost", 6379);

对于 JedisPool 实例，可以使用 try-With-resources 块获得连接并运行 Redis 命令（这种方式无须自己手动 close）。

try (Jedis jedis = pool.getResource()) {
        
    	// 运行单个 SET 命令
      jedis.set("clientName", "Jedis");
    }

##### 1.3、使用实例 #####

编写以下代码：

public static void main(String[] args) {
        
            // Redis服务端IP和端口号
            JedisPool pool = new JedisPool("127.0.0.1", 6379);
            try (Jedis jedis = pool.getResource()) {
        
                // 使用相关Redis的命令
                // 选择第0个数据库进行操作
                jedis.select(0);
                // 向0号数据库写入,字符串数据
                jedis.set("Java", "best");
                jedis.set("PHP", "good");
                // 查询是否写入
                System.out.println(jedis.get("Java"));
                System.out.println(jedis.get("PHP"));
            }
        }

运行测试用例:

![image-20230812233428661][]

Jedis 实例实现了大多数 Redis 命令，这些命令可以在 [https://www.javadoc.io/doc/redis.clients/jedis/latest/redis/clients/jedis/Jedis.htmlApI][https_www.javadoc.io_doc_redis.clients_jedis_latest_redis_clients_jedis_Jedis.htmlApI] 中查询命令对应的方法。

![image-20230812233859534][]

--------------------

#### 2、对于JedisPooled的使用 ####

##### 2.1、使用JedisPooled #####

对每个命令使用 try-with-resources 块可能比较麻烦，因此我们可以考虑使用 JedisPooled。

JedisPooled jedis = new JedisPooled("localhost", 6379);

详细代码:

public static void main(String[] args) {
        
            JedisPooled pool = new JedisPooled("127.0.0.1", 6379, null, null);
            pool.set("Java", "best");
            pool.set("PHP", "good");
            System.out.println(pool.get("Java"));
            System.out.println(pool.get("PHP"));
        }

运行效果:

![image-20230812233428661][]

##### 2.2、关于连接池 #####

使用链接池是官方推荐的使用方式，通过连接池可以更好的使用 Jedis 的，我们可以通过 GenericObjectPoolConfig 对连接池进行相关配置，GenericObjectPoolConfig API 文档：[https://commons.apache.org/proper/commons-pool/apidocs/org/apache/commons/pool2/impl/GenericObjectPoolConfig.html][https_commons.apache.org_proper_commons-pool_apidocs_org_apache_commons_pool2_impl_GenericObjectPoolConfig.html]

通过 GenericObjectPoolConfig 对象对连接池进行配置，具体代码如下:

public static void main(String[] args) {
        
            GenericObjectPoolConfig config = new JedisPoolConfig();
            // 设置连接池中最多允许放100个Jedis对象
            config.setMaxTotal(100);
            // 设置连接池中最大允许空闲连接
            config.setMaxIdle(100);
            // 设置连接池中最小允许的连接数
            config.setMinIdle(10);
            // 借出连接的时候是否测试有效性,推荐false
            config.setTestOnBorrow(false);
            // 归还时是否测试,推荐false
            config.setTestOnReturn(false);
            // 创建时是否测试有效  开发的时候设置为false,实践运行的时候设置为true
            config.setTestOnCreate(false);
            // 当连接池内jedis无可用资源时,是否等待资源,true
            config.setBlockWhenExhausted(true);
            // 没有获取资源时最长等待1秒,1秒后没有还没有的话就报错
            config.setMaxWaitMillis(1000);
    
            JedisPool pool = new JedisPool(config, "127.0.0.1", 6379);
    
            try (Jedis jedis = pool.getResource()) {
        
                // 使用相关Redis的命令
                // 选择第0个数据库进行操作
                jedis.select(0);
                // 向0号数据库写入,字符串数据
                jedis.set("Java", "best");
                jedis.set("PHP", "good");
    
                // 查询是否写入
                System.out.println(jedis.get("Java"));
                System.out.println(jedis.get("PHP"));
            }
        }

运行效果:

![image-20230812233428661][]

--------------------

#### 3、SpringBoot下使用Redis ####

##### 3.1、引入Maven依赖 #####

首先，需要在 pom.xml 文件中添加 Redis 依赖：

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

这个依赖包含了 Spring Data Redis，以及 Jedis 和 Lettuce 这两种 Redis 客户端的实现。

##### 3.2、配置Redis连接 #####

在 SpringBoot 项目中，可以通过在 application.properties 或 application.yml 文件中配置 Redis 连接信息。以下是一个示例：

spring:
      data:
        redis:
          timeout: 3000
          database: 0
          password: password
          port: 6379
          host: localhost

其中，host 和 port 分别是 Redis 服务器的地址和端口号，password 是 Redis的密码（如果没有密码，可以不填），timeout 是 Redis 连接超时时间，jedis.pool 是连接池的相关设置。

##### 3.3、创建RedisTemplate #####

使用 Spring Data Redis 操作 Redis，通常会使用 RedisTemplate 类。为了方便起见，我们可以创建一个工具类来管理 RedisTemplate 的创建和使用。以下是一个示例：

import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    @Component
    public class RedisUtils {
        
    
        /**
         * 如果使用 @Autowired 注解完成自动装配 那么
         * RedisTemplate要么不指定泛型,要么泛型 为<Stirng,String> 或者<Object,Object>
         * 如果你使用其他类型的 比如RedisTemplate<String,Object>
         * 那么请使用 @Resource 注解
         * */
        @Resource
        private RedisTemplate<String,Object> redisTemplate;
    
        private Logger logger = LoggerFactory.getLogger(this.getClass());
    
        /**
         * 缓存value
         *
         * @param key -
         * @param value -
         * @param time -
         * @return -
         */
        public boolean cacheValue(String key, Object value, long time) {
        
            try {
        
                ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
                valueOperations.set(key, value);
                if (time > 0) {
        
                    // 如果有设置超时时间的话
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Throwable e) {
        
                logger.error("缓存[" + key + "]失败, value[" + value + "] " + e.getMessage());
            }
            return false;
        }
    
        /**
         * 缓存value，没有设置超时时间
         *
         * @param key -
         * @param value -
         * @return -
         */
        public boolean cacheValue(String key, Object value) {
        
            return cacheValue(key, value, -1);
        }
    
        /**
         * 判断缓存是否存在
         *
         * @param key
         * @return
         */
        public boolean containsKey(String key) {
        
            try {
        
                return redisTemplate.hasKey(key);
            } catch (Throwable e) {
        
                logger.error("判断缓存是否存在时失败key[" + key + "]", "err[" + e.getMessage() + "]");
            }
            return false;
        }
    
        /**
         * 根据key，获取缓存
         *
         * @param key -
         * @return -
         */
        public Object getValue(String key) {
        
            try {
        
                ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
                return valueOperations.get(key);
            } catch (Throwable e) {
        
                logger.error("获取缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
            }
            return null;
        }
    
        /**
         * 移除缓存
         *
         * @param key -
         * @return -
         */
        public boolean removeValue(String key) {
        
            try {
        
                redisTemplate.delete(key);
                return true;
            } catch (Throwable e) {
        
                logger.error("移除缓存时失败key[" + key + "]", "err[" + e.getMessage() + "]");
            }
            return false;
        }
    
        /**
         * 根据前缀移除所有以传入前缀开头的key-value
         *
         * @param pattern -
         * @return -
         */
        public boolean removeKeys(String pattern) {
        
            try {
        
                Set<String> keySet = redisTemplate.keys(pattern + "*");
                redisTemplate.delete(keySet);
                return true;
            } catch (Throwable e) {
        
                logger.error("移除key[" + pattern + "]前缀的缓存时失败", "err[" + e.getMessage() + "]");
            }
            return false;
        }
    
    }

在这个示例中，我们使用 `@Resource` 注解自动注入了一个 `RedisTemplate<String, Object>` 对象。然后，我们提供了三个方法来对 Redis 进行操作：cacheValue 方法用于缓存数据，getValue 方法用于获取缓存数据，removeValue 方法用于删除缓存数据。这些方法都是通过 redisTemplate 对象来实现的。

需要注意的是，在使用 RedisTemplate 时，需要指定键值对的类型。在这个示例中，我们指定了键的类型为 String，值的类型为 Object。

#### 3.4、使用RedisTemplate ####

在上面的示例中，我们已经创建了一个 RedisTemplate 对象，并提供了一些方法来对 Redis 进行操作。现在，我们可以在 SpringBoot 项目中的任何地方使用这个工具类来进行缓存操作。以下是一个示例：

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class UserController {
        
    
        @Autowired
        private RedisUtils redisUtils;
    
        @Autowired
        private UserService userService;
    
        @GetMapping("/users/{id}")
        public User getUserById(@PathVariable Long id) {
        
    
            String key = "user_" + id;
            User user = (User) redisUtils.getValue(key);
            if (user == null) {
        
                user = userService.getUserById(id);
                redisUtils.cacheValue(key, user);
            }
            return user;
        }
    }

在这个示例中，我们创建了一个 UserController 类，用于处理 HTTP 请求。在 getUserById 方法中，我们首先构造了一个缓存的 key，然后使用 `redisUtils.getValue`方法从 Redis 中获取缓存数据。如果缓存中没有数据，我们调用 `userService.getUserById` 方法从数据库中获取数据，并使用 `redisUtils.cacheValue` 方法将数据存入Redis缓存中。最后，返回获取到的数据。

通过这个示例，我们可以看到，在S pringBoot 项目中使用 Redis 作为缓存的流程。我们首先需要添加 Redis 依赖，然后在配置文件中配置 Redis 连接信息。接着，我们创建了一个 RedisUtil s工具类来管理 RedisTemplate 的创建和使用。最后，我们在控制器中使用 RedisUtils 来对 Redis 进行缓存操作。

[https_github.com_redis_jedis_readme]: https://github.com/redis/jedis#readme
[image-20230812233428661]: https://img-blog.csdnimg.cn/img_convert/ac4dcac5bf967f6648a7f767773c8000.png
[https_www.javadoc.io_doc_redis.clients_jedis_latest_redis_clients_jedis_Jedis.htmlApI]: https://www.javadoc.io/doc/redis.clients/jedis/latest/redis/clients/jedis/Jedis.htmlApI
[image-20230812233859534]: https://img-blog.csdnimg.cn/img_convert/70f82a39b2bb5f364d9e1c7887551ba9.png
[https_commons.apache.org_proper_commons-pool_apidocs_org_apache_commons_pool2_impl_GenericObjectPoolConfig.html]: https://commons.apache.org/proper/commons-pool/apidocs/org/apache/commons/pool2/impl/GenericObjectPoolConfig.html