15、SpringBoot2.0中使用Redis（十五）

最新推荐文章于 2021-09-05 09:20:34 发布

Rsun04551

最新推荐文章于 2021-09-05 09:20:34 发布

阅读量200

点赞数

分类专栏： SpringBoot2.0

本文链接：https://blog.csdn.net/yang_guang3/article/details/100154243

版权

SpringBoot2.0 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

Redis 是目前业界使用最广泛的内存数据存储。相比 Memcached，Redis 支持更丰富的数据结构，例如 hash, set, lists, sets 等，支持五种数据类型：String、List、Set、Hash、SortedSet（zset），同时支持数据持久化。除此之外，Redis 还提供一些类数据库的特性，比如事务，HA，主从库。可以说 Redis 兼具了缓存系统和数据库的一些特性，因此有着丰富的应用场景。本文介绍 Redis 在 Spring Boot 中两个典型的应用场景。
五种数据类型的具体介绍请查看：
https://blog.csdn.net/yang_guang3/article/details/100169171
1、添加pom依赖：

<!--redis相关-->
 <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>
  <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
  </dependency>

Spring Boot 提供了对 Redis 集成的组件包：spring-boot-starter-data-redis，spring-boot-starter-data-redis依赖于spring-data-redis 和 lettuce 。Spring Boot 1.0 默认使用的是 Jedis 客户端，2.0 替换成 Lettuce，但如果你从 Spring Boot 1.5.X 切换过来，几乎感受不大差异，这是因为 spring-boot-starter-data-redis 为我们隔离了其中的差异性。

Lettuce 是一个可伸缩线程安全的 Redis 客户端，多个线程可以共享同一个 RedisConnection，它利用优秀 netty NIO 框架来高效地管理多个连接。
2、在application.properties中添加：

# REDIS
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0

3、添加RedisConfig类：

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.lang.reflect.Method;

/**
 * 〈redis配置类〉
 *
 * @author Barrett
 * @version 1.0.0
 * @time 2019/8/30
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
}

注意我们使用了注解：@EnableCaching来开启缓存。
4、接下来使用RedisTemplate操作Redis
spring-data-redis提供了一个RedisTemplate类，这个类封装了对Redis基本数据结构的常用操作，它的子类StringRedisTemplate提供了对字符串的常用操作，接下来将使用StringRedisTemplate来操作Redis中的String和List类型。

  @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate redisTemplate;

    //往redis中添加字符串类型数据
    @RequestMapping(value = "/operateString")
    public String operateString() {
        stringRedisTemplate.opsForValue().set("operateString","李现个小婊砸");
        String operateString = stringRedisTemplate.opsForValue().get("operateString");
        System.out.println(operateString);
        return operateString;
    }

    @RequestMapping(value = "/operateList")
    public List<String> operateList(){
        String key = "operateList";
        ListOperations<String,String> operateList = stringRedisTemplate.opsForList();
        //从左压入栈
        operateList.leftPush(key, "Github");
        operateList.leftPush(key, "CSDN");
        //从右压入栈
        operateList.rightPush(key, "SegmentFault");
        System.out.println(operateList.size(key));
        List<String> list = operateList.range(key, 0, 2);
        list.forEach(obj -> System.out.println("测试:" + obj));
        return list;
    }

    @RequestMapping(value = "/operateHash")
    public void operateHash(){
        String key = "operateHash";
        User user = new User();User user1 = new User();User user2 = new User();
        user.setId(111);user.setName("刘亦菲");user.setAge(111);
        user1.setId(222);user1.setName("杨幂");user1.setAge(222);
        user2.setId(333);user2.setName("舒畅");user2.setAge(333);
        HashOperations<String, String, User> hashOperations = redisTemplate.opsForHash();
        hashOperations.put(key,"user",user);
        hashOperations.put(key,"user1",user1);
        hashOperations.put(key,"user2",user2);
        Set<String> keys = hashOperations.keys(key);
        keys.forEach(obj -> System.out.println("测试:" + obj));
        List<User> values = hashOperations.values(key);
        values.forEach(obj -> System.out.println("测试:" + obj));
        User user11 = hashOperations.get(key, "user1");
        System.out.println(user11);
    }

使用注解方式缓存数据

上面的操作方式，是手动操作Redis进行存取，在真实的业务场景中，我们并不想这样去使用，而是把Redis当做一种缓存来使用，把service或者dao层的数据进行缓存，
最简单的方式就是通过注解。在SpringBoot中使用Redis做缓存也非常简单，只需要在pom中引入spring-boot-starter-cache即可。

下面列出的是Spring缓存的常用注解（来自@程序猿DD）：

@CacheConfig：主要用于配置该类中会用到的一些共用的缓存配置。在这里@CacheConfig(cacheNames = “users”)：配置了该数据访问对象中返回的
内容将存储于名为users的缓存对象中，我们也可以不使用该注解，直接通过@Cacheable自己配置缓存集的名字来定义。
@Cacheable：配置了findByName函数的返回值将被加入缓存。同时在查询时，会先从缓存中获取，若不存在才再发起对数据库的访问。该注解主要有下面几个参数：

value、cacheNames：两个等同的参数（cacheNames为Spring4新增，作为value的别名），用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig，
因此在Spring 3中原本必须有的value属性，也成为非必需项了
key：缓存对象存储在Map集合中的key值，非必需，缺省按照函数的所有参数组合作为key值，若自己配置需使用SpEL表达式，比如：@Cacheable(key = “#p0”)：
使用函数第一个参数作为缓存的key值，更多关于SpEL表达式的详细内容可参考官方文档
condition：缓存对象的条件，非必需，也需使用SpEL表达式，只有满足表达式条件的内容才会被缓存，比如：@Cacheable(key = “#p0”, condition = “#p0.length() < 3”)，
表示只有当第一个参数的长度小于3的时候才会被缓存，若做此配置上面的AAA用户就不会被缓存，读者可自行实验尝试。
unless：另外一个缓存条件参数，非必需，需使用SpEL表达式。它不同于condition参数的地方在于它的判断时机，该条件是在函数被调用之后才做判断的，
所以它可以通过对result进行判断。
keyGenerator：用于指定key生成器，非必需。若需要指定一个自定义的key生成器，我们需要去实现org.springframework.cache.interceptor.KeyGenerator接口，
并使用该参数来指定。需要注意的是：该参数与key是互斥的
cacheManager：用于指定使用哪个缓存管理器，非必需。只有当有多个时才需要使用
cacheResolver：用于指定使用那个缓存解析器，非必需。需通过org.springframework.cache.interceptor.CacheResolver接口来实现自己的
缓存解析器，并用该参数指定。

@CachePut：配置于函数上，能够根据参数定义条件来进行缓存，它与@Cacheable不同的是，它每次都会真实调用函数，所以主要用于数据新增和修改操作上
。它的参数与@Cacheable类似，具体功能可参考上面对@Cacheable参数的解析。
@CacheEvict：配置于函数上，通常用在删除方法上，用来从缓存中移除相应数据。除了同@Cacheable一样的参数之外，它还有下面两个参数：

allEntries：非必需，默认为false。当为true时，会移除所有数据

beforeInvocation：非必需，默认为false，会在调用方法之后移除数据。当为true时，会在调用方法之前移除数据。

@RequestMapping(value = "/getUser")
 @Cacheable(value = "user-key")
 public User getUser(){
     User user = new User();
     user.setId(666);
     user.setAge(16);
     user.setName("李现");
     System.out.println("若下面没出现“无缓存的时候调用”字样且能打印出数据表示测试成功");
     return user;
 }

 @Autowired
 private UserService userService;

 @RequestMapping(value = "/getUserList")
 @Cacheable(value = "userList")
 public List<User> getUserList() {
     System.out.println("存放用户列表数据！！！");
     return userService.findAll();
 }

共享 Session

分布式系统中，Session 共享有很多的解决方案，其中托管到缓存中应该是最常用的方案之一
Spring Session 提供了一套创建和管理 Servlet HttpSession 的方案。Spring Session 提供了集群 Session（Clustered Sessions）功能，默认采用外置的 Redis 来存储 Session 数据，以此来解决 Session 共享的问题。
1、引入依赖

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

2、创建SessionConfig类：
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 86400*30)
public class SessionConfig {

}

maxInactiveIntervalInSeconds: 设置 Session 失效时间，使用 Redis Session 之后，原
Spring Boot 的 server.session.timeout 属性不再生效。

3、添加测试方法：

  @RequestMapping("/uid")
    String uid(HttpSession session) {
        UUID uid = (UUID) session.getAttribute("uid");
        if (uid == null) {
            uid = UUID.randomUUID();
        }
        session.setAttribute("uid", uid);
        return session.getId();
    }

4、登录 Redis 输入 keys ‘sessions’
在这里插入图片描述
其中 1472976480000 为失效时间，意思是这个时间后 Session 失效，db031986-8ecc-48d6-b471-b137a3ed6bc4 为 sessionId,登录 http://localhost:8080/uid 发现会一致，就说明 Session 已经在 Redis 里面进行有效的管理了。