文章目录

  • Java 整合 Redis
  • 一、Jedis
  • 二、Spring-Data-Redis


Java 整合 Redis

Redis 在项目中我们主要用来做缓存，就像我们用 MySQL 做持久层数据一样。Redis 的客户端有两种实现方式：

一是直接调用 Jedis 来实现，类似于 Java 使用 JDBC 操作数据库一样。

二是使用 Spring-Data-Redis，通过 Spring 的封装来调用。

一、Jedis

Jedis 是 Redis 官方推荐的 Java 连接开发工具，Jedis 是 Redis 的 Java 版本的客户端实现。

Java 通过 Jedis 来操作 Redis 服务，类似于 Java 通过 JDBC 技术来操作 MySQL 数据库。

通过前面 Redis 的常见数据类型的命令操作，可以很容易地使用 Jedis，因为大多数方法名与对应的命令基本一致。Redis 的常见数据类型的命令可以参考上一篇文章 Redis常见的数据类型命令

Jedis 的简单使用如下：

首先引入 Jedis 的 maven 依赖：

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

下面是测试代码：

public class JedisTest {

    Jedis jedis;

    /**
     * 初始化Jedis实例
     */
    @Before
    public void init() {
        //指定Redis服务器的IP地址和端口号
        jedis = new Jedis("192.168.43.100", 6379);
    }

    @Test
    public void redisJedisTest() {
        //操作字符串
        //方法名与操作原生redis的命令一致
        jedis.set("dec", "hello");
        String dec = jedis.get("dec");
        System.out.println(dec);

        //操作list
        jedis.lpush("data", "v1", "v2", "v3");
        jedis.rpush("data", "v4", "v5", "v6");
        List<String> data = jedis.lrange("data", 0, -1);
        for (String s : data) {
            System.out.print(s + " ");
        }
        System.out.println();

        //操作hash
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("id", "1");
        hashMap.put("name", "huhai");
        hashMap.put("age", "24");
        jedis.hset("object", hashMap);
        Map<String, String> object = jedis.hgetAll("object");
        object.forEach((key, value) -> System.out.print(key + "=" + value + " "));
    }

    /**
     * 关闭Jedis连接
     */
    @After
    public void close() {
        jedis.close();
    }
}

终端输出如下：

hello
v3 v2 v1 v4 v5 v6 
name=huhai age=24 id=1

也可以使用 JedisPool 来进行操作：

//声明Linux服务器IP地址
String host = "192.168.43.100";
//声明Redis端口号
int port = Protocol.DEFAULT_PORT;
//创建连接池对象
JedisPool jedisPool = new JedisPool(host, port);
//获取Jedis对象连接Redis
Jedis jedis = jedisPool.getResource();
//执行具体操作
String ping = jedis.ping();
System.out.println(ping);//pong
//关闭连接
jedisPool.close();

二、Spring-Data-Redis

Spring-Data-Redis 是 Spring 大家族的一部分，通过简单的配置访问 Redis 服务，对 Redis 底层开发包（Jedis，JRedis，RJC）进行了高度封装，RedisTemplate提供了 Redis 的各种操作、异常处理以及序列化，支持发布订阅。

RedisTemplate

Spring 封装了 RedisTemplate 对象来进行对 Redis 的各种操作，它支持所有的 Redis 原生的 API。

org.springframework.data.redis.core.RedisTemplate<K, V>

RedisTemplate 中定义了对 5 种基本数据结构的操作

redisTemplate.opsForValue();//操作String字符串
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForZSet();//操作有序set

StringRedisTemplate 和 RedisTemplate

  • 两者的关系是 StringRedisTemplate 继承 RedisTemplate。
  • 两者的数据是不共通的；也就是说 StringRedisTemplate 只能管理 StringRedisTemplate 里面的数据，RedisTemplate 只能管理 RedisTemplate 中的数据。
  • SDR 默认采用的序列化策略有两种，一种是 String 的序列化策略，一种是 JDK 的序列化策略。
  • StringRedisTemplate 默认采用的是 String 的序列化策略，保存的 key 和 value 都是采用此策略序列化保存的。
  • RedisTemplate 默认采用的是 JDK 的序列化策略，保存的 key 和 value 都是采用此策略序列化保存的。

使用 Spring-Data-Redis 的 demo 如下：

1、首先引入依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <exclusions>
            <exclusion>
                <groupId>io.lettuce</groupId>
                <artifactId>lettuce-core</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
    <!-- lombok依赖 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

2、添加配置文件，进行 Redis 的一些配置

spring:
  redis:
    #redis服务器连接地址
    host: 192.168.43.100
    #端口号
    port: 6379
    #连接超时时间（毫秒）
    timeout: 10000
    #使用的redis库
    database: 0
    jedis:
      pool:
        #连接池最大连接数
        max-active: 10
        #连接池中的最大空闲连接
        max-idle: 10
        #连接池中的最小空闲连接
        min-idle: 2
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 10000

3、添加 Redis 配置类，定义序列化机制

/**
 * Description: Redis 基础配置类
 */
public class BaseRedisConfig {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory, RedisSerializer<Object> redisSerializer) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(redisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public RedisSerializer<Object> redisSerializer() {
        //创建JSON序列化器
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //必须设置，否则无法将JSON转化为对象，会转化成Map类型
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);
        return serializer;
    }

    @Bean
    public IRedisService redisService(RedisTemplate<String, Object> redisTemplate) {
        return new RedisServiceImpl(redisTemplate);
    }
}
/**
 * Description: Redis配置类
 */
@Configuration
public class RedisConfig extends BaseRedisConfig{
}

4、创建 IRedisService 接口与 RedisServiceImpl 实现类

只写了一些基本使用方法，如有需要可以继续添加，在其他类里面注入即可使用~

/**
 * Description: Redis操作Service
 */
public interface IRedisService {

    /**
     * 保存属性
     *
     * @param key   key
     * @param value value
     * @param time  超时时间（秒）
     */
    void set(String key, Object value, long time);

    /**
     * 保存属性,无过期时间
     *
     * @param key   key
     * @param value value
     */
    void set(String key, Object value);

    /**
     * 获取属性
     *
     * @param key key
     * @return value
     */
    Object get(String key);

    /**
     * 设置过期时间
     *
     * @param key  key
     * @param time 超时时间（秒）
     * @return 是否设置成功
     */
    Boolean expire(String key, long time);

    /**
     * 删除key
     * @param key  key
     * @return 是否设置成功
     */
    Boolean delete(String key);

}
/**
 * Description: Redis操作实现类
 */
@RequiredArgsConstructor
@Service
public class RedisServiceImpl implements IRedisService {

    private final RedisTemplate<String, Object> redisTemplate;

    @Override
    public void set(String key, Object value, long time) {
        redisTemplate.opsForValue().set(key, value, time);
    }

    @Override
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public Boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    @Override
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }
}

5、进行 Junit 测试

@SpringBootTest
class SpringDataRedisDemoApplicationTests {

    @Resource
    private IRedisService redisService;

    @Test
    void contextLoads() {
        redisService.set("name", "xiaobai");
        System.out.println(redisService.get("name"));//xiaobai
    }
}

只展示了 Redis 的字符串的一些常用操作，如果有其他操作，可以在 IRedisService 中添加对应方法，然后在 RedisServiceImpl 中实现之后，在需要的地方进行调用。