用Redis缓存对象简单高效（redis缓存一个对象）

2023-05-16 06:29:59 缓存 对象 高效

用Redis缓存对象：简单高效

随着互联网应用的不断发展，数据量越来越大，传统的关系型数据库面临着问题，使用缓存技术来提高系统响应速度和缓解数据库负载压力已成为一种非常有效的解决方案。Redis作为一种高性能的内存数据库，其具有超快的响应速度和高可靠性，极大地提高了应用性能。在这里我们将介绍如何在Java应用中使用Redis缓存对象。

一、引入依赖

我们需要添加Jedis客户端库来与Redis服务器进行通信，在pom.xml文件中添加以下配置：

“`xml

redis.clients

jedis

3.5.1


二、Redis连接池配置

由于Redis是内存数据库，为了防止缓存击穿，我们需要设置合适的过期时间，并开启Redis连接池来提高系统稳定性。下面是一个简单的Redis连接池配置示例：

```java
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtil {

    // Redis服务器IP
    private static String ADDR = "localhost";
    // Redis的端口号
    private static int PORT = 6379;
    // 访问密码，如果你没有设置redis密码可不需要
    private static String AUTH = "";
    // 可用连接实例的最大数目，默认值为8
    private static int MAX_TOTAL = 8;
    // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8
    private static int MAX_IDLE = 8;
    // 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果等待时间超过了这个值，会抛出JedisConnectionException
    private static int MAX_WT_MILLIS = 10000;
    // 在borrow一个jedis实例时，是否提前进行validate操作，如果为true，则得到的jedis实例均是可用的
    private static boolean TEST_ON_BORROW = true;
    private static JedisPool jedisPool = null;

    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_TOTAL);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWtMillis(MAX_WT_MILLIS);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT, 1000, AUTH);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取Jedis实例
     * @return Jedis实例
     */
    public synchronized static Jedis getJedis() {
        Jedis jedis = null;
        try {
            if (jedisPool != null) {
                jedis = jedisPool.getResource();
            }
            return jedis;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 释放Jedis资源
     * @param jedis Jedis实例
     */
    public static void close(final Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }
}

三、Redis缓存对象

Jedis客户端提供了一系列快捷的缓存操作方法，例如set/get/hmget等方法可以使用简单的字符串、哈希表等进行存取，更多操作详见官方文档。下面是一个Redis缓存对象的示例，我们通过Java的序列化技术将Java对象序列化成字符串存储在Redis中，并使用Redis过期时间来控制缓存对象的有效时长。

“`java

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import redis.clients.jedis.Jedis;

import redis.clients.util.SafeEncoder;

public class RedisCache {

/**

* 缓存对象

* @param key 缓存键

* @param value 缓存值

* @param expireSeconds 缓存有效时间(秒)

* @return 缓存是否成功

*/

public static boolean putObject(String key, Object value, int expireSeconds) {

Jedis jedis = RedisUtil.getJedis();

boolean result = false;

try {

ByteArrayOutputStream bos = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(bos);

oos.writeObject(value);

jedis.set(SafeEncoder.encode(key), SafeEncoder.encode(bos.toByteArray()));

jedis.expire(key, expireSeconds);

result = true;

} catch (Exception e) {

e.printStackTrace();

} finally {

RedisUtil.close(jedis);

}

return result;

}

/**

* 获取缓存对象

* @param key 缓存键

* @return 缓存对象

*/

public static Object getObject(String key) {

Jedis jedis = RedisUtil.getJedis();

Object result = null;

try {

byte[] data = jedis.get(SafeEncoder.encode(key));

if (data != null) {

ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data));

result = ois.readObject();

}

} catch (Exception e) {

e.printStackTrace();

} finally {

RedisUtil.close(jedis);

}

return result;

}

}


四、使用方法

通过以上Redis缓存对象的方法，我们可以很方便地将Java对象存储到Redis中，以提高应用响应速度，减少数据库负载。下面是一个简单的使用示例：

```java
public class UserService {
    public User findUserById(int userId) {
        User user = (User) RedisCache.getObject("user:" + userId);
        if (user == null) {
            user = userDao.findUserById(userId);
            if (user != null) {
                RedisCache.putObject("user:" + userId, user, 1800); // 有效期30分钟
            }
        }
        return user;
    }
}

五、常用操作

除了Redis缓存对象的序列化存储，在实际应用中还需要使用一些常用的Redis操作来管理缓存，例如删除多个缓存对象、批量获取缓存对象等。下面是一些常用的Redis操作示例：

“`java

import java.util.ArrayList;

import java.util.List;

import java.util.Set;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.Transaction;

import redis.clients.jedis.exceptions.JedisDataException;

import redis.clients.util.SafeEncoder;

public class RedisUtil {

// …

/**

* 删除缓存对象

* @param key 缓存键

* @return 删除是否成功

*/

public static boolean deleteObject(String key) {

Jedis jedis = RedisUtil.getJedis();

boolean result = false;

try {

jedis.del(SafeEncoder.encode(key));

result = true;

} catch (Exception e) {

e.printStackTrace();

} finally {

RedisUtil.close(jedis);

}

return result;

}

/**

* 删除多个缓存对象

* @param pattern 缓存键的通配符

* @return 删除的缓存对象数量

*/

public static int deleteObjects(String pattern) {

Jedis jedis = RedisUtil.getJedis();

int result = 0;

try {

Set keys = jedis.keys(SafeEncoder.encode(pattern));

if (keys != null && !keys.isEmpty()) {

String[] arrKeys = new String[keys.size()];

int i = 0;

for (byte[] key : keys) {

arrKeys[i++] = SafeEncoder.encode(key);

}

jedis.del(arrKeys);

result = keys.size();

}

} catch (Exception e) {

e.printStackTrace();

} finally {

RedisUtil.close(jedis);

}

return result;

}

/**

* 批量获取缓存对象

* @param keys 缓存键列表

* @return 缓存对象列表

*/

public static ListgetObjects(String[] keys) {

Jedis jedis = RedisUtil.getJedis();

Listresult = new ArrayList();

try {

for (String key : keys) {

result.add(RedisCache.getObject(key));

}

} catch (Exception e) {

e.printStackTrace();

} finally {

RedisUtil.close(jedis);

}

return result;

}

/**

* 判断缓存对象是否存在

* @param key 缓存键

* @return 缓存对象是否存在

*/

public static boolean existsObject(String key) {

相关文章