（一）Spring-Boot-操作-Redis

ゝ一世哀愁。 2023-02-23 10:54 25阅读 0赞

### Spring-Boot-操作-Redis ###

*  1、Spring Data Redis
 *   *  1.1 引入依赖
     *  1.2 配置 Redis 信息
     *  1.3 使用
 *  2、Spring Cache
 *   *  2.1 引入依赖
     *  2.2 基本配置
     *  2.3 缓存使用
     *   *  2.3.1 @CacheConfig
         *  2.3.2 @Cacheable
         *  2.3.3 @CachePut
         *  2.3.4 @CacheEvict
 *  3、直接使用 Jedis 或者 其他的客户端工具来操作 Redis

在 Spring Boot 中，默认集成的 Redis 就是 Spring Data Redis，默认底层的连接池使用了 lettuce ，开发者可以自行修改为自己的熟悉的，例如 Jedis。

Spring Data Redis 针对 Redis 提供了非常方便的操作模板 RedisTemplate 。

# 1、Spring Data Redis #

## 1.1 引入依赖 ##

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>

引入了 Spring Data Redis + 连接池。

## 1.2 配置 Redis 信息 ##

接下来配置 Redis 的信息，信息包含两方面，一方面是 Redis 的基本信息，另一方面则是连接池信息:

spring.redis.database=0
    spring.redis.password=123
    spring.redis.port=6379
    spring.redis.host=192.168.66.128
    spring.redis.lettuce.pool.min-idle=5
    spring.redis.lettuce.pool.max-idle=10
    spring.redis.lettuce.pool.max-active=8
    spring.redis.lettuce.pool.max-wait=1ms
    spring.redis.lettuce.shutdown-timeout=100ms

自动配置  
当开发者在项目中引入了 Spring Data Redis ，并且配置了 Redis 的基本信息，此时，自动化配置就会生效。

我们从 Spring Boot 中 Redis 的自动化配置类中就可以看出端倪：

@Configuration
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    @Import({  LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
    public class RedisAutoConfiguration { 
            @Bean
            @ConditionalOnMissingBean(name = "redisTemplate")
            public RedisTemplate<Object, Object> redisTemplate(
                            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { 
                    RedisTemplate<Object, Object> template = new RedisTemplate<>();
                    template.setConnectionFactory(redisConnectionFactory);
                    return template;
            }
            @Bean
            @ConditionalOnMissingBean
            public StringRedisTemplate stringRedisTemplate(
                            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { 
                    StringRedisTemplate template = new StringRedisTemplate();
                    template.setConnectionFactory(redisConnectionFactory);
                    return template;
            }
    }

这个自动化配置类很好理解：

首先标记这个是一个配置类，同时该配置在 RedisOperations 存在的情况下才会生效(即项目中引入了 Spring Data Redis)  
然后导入在 application.properties 中配置的属性  
然后再导入连接池信息（如果存在的话）  
最后，提供了两个 Bean ，RedisTemplate 和 StringRedisTemplate ，其中 StringRedisTemplate 是 RedisTemplate 的子类，两个的方法基本一致，不同之处主要体现在操作的数据类型不同，RedisTemplate 中的两个泛型都是 Object ，意味者存储的 key 和 value 都可以是一个对象，而 StringRedisTemplate 的 两个泛型都是 String ，意味者 StringRedisTemplate 的 key 和 value 都只能是字符串。如果开发者没有提供相关的 Bean ，这两个配置就会生效，否则不会生效。

## 1.3 使用 ##

接下来，可以直接在 Service 中注入 StringRedisTemplate 或者 RedisTemplate 来使用：

@Service
    public class HelloService { 
        @Autowired
        RedisTemplate redisTemplate;
        public void hello() { 
            ValueOperations ops = redisTemplate.opsForValue();
            ops.set("k1", "v1");
            Object k1 = ops.get("k1");
            System.out.println(k1);
        }
    }

Redis 中的数据操作，大体上来说，可以分为两种：

针对 key 的操作，相关的方法就在 RedisTemplate 中  
针对具体数据类型的操作，相关的方法需要首先获取对应的数据类型，获取相应数据类型的操作方法是 opsForXXX  
调用该方法就可以将数据存储到 Redis 中去了。

k1 前面的字符是由于使用了 RedisTemplate 导致的，RedisTemplate 对 key 进行序列化之后的结果。

RedisTemplate 中，key 默认的序列化方案是 JdkSerializationRedisSerializer 。

而在 StringRedisTemplate 中，key 默认的序列化方案是 StringRedisSerializer ，因此，如果使用 StringRedisTemplate ，默认情况下 key 前面不会有前缀。

不过开发者也可以自行修改 RedisTemplate 中的序列化方案，如下:

@Service
    public class HelloService { 
        @Autowired
        RedisTemplate redisTemplate;
        public void hello() { 
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            ValueOperations ops = redisTemplate.opsForValue();
            ops.set("k1", "v1");
            Object k1 = ops.get("k1");
            System.out.println(k1);
        }
    }

当然也可以直接使用 StringRedisTemplate：

@Service
    public class HelloService { 
        @Autowired
        StringRedisTemplate stringRedisTemplate;
        public void hello2() { 
            ValueOperations ops = stringRedisTemplate.opsForValue();
            ops.set("k2", "v2");
            Object k1 = ops.get("k2");
            System.out.println(k1);
        }
    }

另外需要注意 ，Spring Boot 的自动化配置，只能配置单机的 Redis ，如果是 Redis 集群，则所有的东西都需要自己手动配置。

# 2、Spring Cache #

## 2.1 引入依赖 ##

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

## 2.2 基本配置 ##

简单配置一下Redis，配置一下Cache。

spring.redis.port=6380
    spring.redis.host=192.168.66.128
    
    spring.cache.cache-names=c1

在配置类上添加如下代码，表示开启缓存：

@SpringBootApplication
    @EnableCaching
    public class RediscacheApplication { 
      public static void main(String[] args){ 
       SpringApplication.run(RediscacheApplication.class, args);
      }
    }

完成了这些配置之后，Spring Boot就会自动帮我们在后台配置一个RedisCacheManager，相关的配置是在org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration类中完成的。

## 2.3 缓存使用 ##

### 2.3.1 @CacheConfig ###

这个注解在类上使用，用来描述该类中所有方法使用的缓存名称，当然也可以不使用该注解，直接在具体的缓存注解上配置名称，示例代码如下：

@Service
    @CacheConfig(cacheNames = "c1")
    public class UserService { 
    }

### 2.3.2 @Cacheable ###

这个注解一般加在查询方法上，表示将一个方法的返回值缓存起来，默认情况下，缓存的key就是方法的参数，缓存的value就是方法的返回值。示例代码如下：

@Cacheable(key = "#id")
    public User getUserById(Integer id,String username) { 
       System.out.println("getUserById");
       return getUserFromDBById(id);
    }

当有多个参数时，默认就使用多个参数来做key，如果只需要其中某一个参数做key，则可以在@Cacheable注解中，通过key属性来指定key，如上代码就表示只使用id作为缓存的key，如果对key有复杂的要求，可以自定义keyGenerator。

### 2.3.3 @CachePut ###

这个注解一般加在更新方法上，当数据库中的数据更新后，缓存中的数据也要跟着更新，使用该注解，可以将方法的返回值自动更新到已经存在的key上，示例代码如下：

@CachePut(key = "#user.id")
    public User updateUserById(User user) { 
        return user;
    }

### 2.3.4 @CacheEvict ###

这个注解一般加在删除方法上，当数据库中的数据删除后，相关的缓存数据也要自动清除，该注解在使用的时候也可以配置按照某种条件删除（condition属性）或者或者配置清除所有缓存（allEntries属性），示例代码如下：

@CacheEvict()
    public void deleteUserById(Integer id) { 
        //在这里执行删除操作， 删除是去数据库中删除
    }

# 3、直接使用 Jedis 或者 其他的客户端工具来操作 Redis #