SpringBoot中使用Redis的实践

SpringBoot中使用Redis的实践

Redis是一个高性能的内存数据库,在日常开发中运用非常的广泛,主要用作缓存。Redis提供了非常丰富的数据结构,有String,List,Set,ZSet,Hash,
Redis为这些数据结构提供了丰富的原子性操作。弥补了其他NoSQL如Memcached的不足。在SpringBoot中,由于Boot提供了强大的AutoConfiguration,
集成Redis变得非常简单。本文将介绍Redis在SpringBoot中的应用,包括手动使用RedisTemplate进行操作,和使用注解(@Cacheable等)把业务数据缓存到Redis中。

开始

环境:JDK1.8,Maven3+,Redis3
需要预先安装好Redis,也可以使用Docker快速部署一个Redis,可以参考我之前的文章

新建一个SpringBoot项目,引入需要用到的相关maven依赖

  <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--SpringBoot的Redis支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--SpringBoot缓存支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

在yaml文件中配置redis连接:

spring:
  redis:
    #Redis服务器地址,默认localhost
    host: localhost
    #Redis服务器端口,默认6379
    port: 6379
    pool:
      #连接池最大连接数
      max-active: 8
      #最大阻塞等待时间,-1表示没有限制
      max-wait: -1
      #最大空闲连接
      max-idle: 8
      #最小空闲连接
      min-idle: 0
    #连接超时时间
    timeout: 0

使用RedisTemplate操作Redis

spring-data-redis提供了一个RedisTemplate类,这个类封装了对Redis基本数据结构的常用操作,它的子类StringRedisTemplate提供了对字符串的常用
操作,接下来将使用StringRedisTemplate来操作Redis中的String和List类型。

注入StringRedisTemplate

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 操作字符串
     */
    private void operateString() &#123;
        stringRedisTemplate.opsForValue().set("author", "luoliang");
        String value = stringRedisTemplate.opsForValue().get("author");
        log.info("stringRedisTemplate输出值:&#123;&#125;", value);
    &#125;

    /**
     * Redis List操作,Redis列表是简单的字符串列表,按照插入顺序排序。可以添加一个元素到列表的头部(左边)或者尾部(右边)
     */
    private void operateList() &#123;
        String key = "website";
        ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
        //从左压入栈
        listOperations.leftPush(key, "Github");
        listOperations.leftPush(key, "CSDN");
        //从右压入栈
        listOperations.rightPush(key, "SegmentFault");
        log.info("list size:&#123;&#125;", listOperations.size(key));
        List<String> list = listOperations.range(key, 0, 2);
        list.forEach(log::info);
    &#125;

上面涉及到的两种类型的操作,都是针对的字符串,可不可以存取对象呢?答案当然是可以的。我们使用Hash来存取对象,首先新建一个User类,用于存取
使用。

此处需要注意,User类需要实现Serializable接口,否则无法序列化

@Data
@Builder
public class User implements Serializable &#123;
    private String id;

    private String name;

    private Integer age;
&#125;

这时候就不能再使用StringRedisTemplate了,所以需要配置针对Object的RedisTemplate实例,这里可以使用默认的JdkSerializationRedisSerializer
序列化,也可以自己实现RedisSerializer接口来自定义序列化

@Configuration
public class RedisConfig &#123;
    @Resource
    private JedisConnectionFactory jedisConnectionFactory;

    @Bean
    public RedisTemplate<String, Object> objRedisTemplate() &#123;
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new JdkSerializationRedisSerializer());
        return template;
    &#125;
&#125;

操作Hash

    @Resource
    private RedisTemplate<String, Object> objRedisTemplate;

    /**
     * 操作hash,存放User对象
     */
    private void operateHash() &#123;
        String key = "user";
        HashOperations<String, String, User> hashOperations = objRedisTemplate.opsForHash();
        hashOperations.put(key, "user1", User.builder().name("Hulk").age(50).build());
        hashOperations.put(key, "user2", User.builder().name("Thor").age(1500).build());
        hashOperations.put(key, "user3", User.builder().name("Rogers").age(150).build());
        log.info("hash size:&#123;&#125;", hashOperations.size(key));
        log.info("--------拿到Map的key集合--------");
        Set<String> keys = hashOperations.keys(key);
        keys.forEach(log::info);
        log.info("--------拿到Map的value集合--------");
        List<User> users = hashOperations.values(key);
        users.forEach(user -> log.info(user.toString()));
        log.info("--------拿到user1的value--------");
        User user = hashOperations.get(key, "user1");
        log.info(user.toString());
    &#125;

最后,验证我们的操作,可以看到,结果和预期相同。

2018-05-22 10:45:07.754  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : ----------Operate String----------
2018-05-22 10:45:07.820  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : stringRedisTemplate输出值:luoliang
2018-05-22 10:45:07.821  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : ----------Operate List----------
2018-05-22 10:45:07.832  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : list size:57
2018-05-22 10:45:07.836  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : CSDN
2018-05-22 10:45:07.836  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : Github
2018-05-22 10:45:07.836  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : CSDN
2018-05-22 10:45:07.836  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : ----------Operate Hash----------
2018-05-22 10:45:07.858  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : hash size:3
2018-05-22 10:45:07.858  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : --------拿到Map的key集合--------
2018-05-22 10:45:07.865  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : user2
2018-05-22 10:45:07.866  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : user1
2018-05-22 10:45:07.866  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : user3
2018-05-22 10:45:07.866  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : --------拿到Map的value集合--------
2018-05-22 10:45:07.870  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : User(id=null, name=Thor, age=1500)
2018-05-22 10:45:07.870  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : User(id=null, name=Hulk, age=50)
2018-05-22 10:45:07.870  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : User(id=null, name=Rogers, age=150)
2018-05-22 10:45:07.870  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : --------拿到user1的value--------
2018-05-22 10:45:07.873  INFO 42127 --- [           main] org.boot.redis.BootRedisApplication      : User(id=null, name=Hulk, age=50)

使用Annotation缓存数据

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

下面列出的是Spring缓存的常用注解(来自@程序猿DD):

  • @CacheConfig:主要用于配置该类中会用到的一些共用的缓存配置。在这里@CacheConfig(cacheNames = “users”):配置了该数据访问对象中返回的
    内容将存储于名为users的缓存对象中,我们也可以不使用该注解,直接通过@Cacheable自己配置缓存集的名字来定义。
  • @Cacheable:配置了findByName函数的返回值将被加入缓存。同时在查询时,会先从缓存中获取,若不存在才再发起对数据库的访问。该注解主要有下面几个参数:
    1. value、cacheNames:两个等同的参数(cacheNames为Spring4新增,作为value的别名),用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig,
      因此在Spring 3中原本必须有的value属性,也成为非必需项了
    2. key:缓存对象存储在Map集合中的key值,非必需,缺省按照函数的所有参数组合作为key值,若自己配置需使用SpEL表达式,比如:@Cacheable(key = “#p0”):
      使用函数第一个参数作为缓存的key值,更多关于SpEL表达式的详细内容可参考官方文档
    3. condition:缓存对象的条件,非必需,也需使用SpEL表达式,只有满足表达式条件的内容才会被缓存,比如:@Cacheable(key = “#p0”, condition = “#p0.length() < 3”),
      表示只有当第一个参数的长度小于3的时候才会被缓存,若做此配置上面的AAA用户就不会被缓存,读者可自行实验尝试。
    4. unless:另外一个缓存条件参数,非必需,需使用SpEL表达式。它不同于condition参数的地方在于它的判断时机,该条件是在函数被调用之后才做判断的,
      所以它可以通过对result进行判断。
    5. keyGenerator:用于指定key生成器,非必需。若需要指定一个自定义的key生成器,我们需要去实现org.springframework.cache.interceptor.KeyGenerator接口,
      并使用该参数来指定。需要注意的是:该参数与key是互斥的
    6. cacheManager:用于指定使用哪个缓存管理器,非必需。只有当有多个时才需要使用
    7. cacheResolver:用于指定使用那个缓存解析器,非必需。需通过org.springframework.cache.interceptor.CacheResolver接口来实现自己的
      缓存解析器,并用该参数指定。
  • @CachePut:配置于函数上,能够根据参数定义条件来进行缓存,它与@Cacheable不同的是,它每次都会真实调用函数,所以主要用于数据新增和修改操作上
    。它的参数与@Cacheable类似,具体功能可参考上面对@Cacheable参数的解析。
  • @CacheEvict:配置于函数上,通常用在删除方法上,用来从缓存中移除相应数据。除了同@Cacheable一样的参数之外,它还有下面两个参数:
    1. allEntries:非必需,默认为false。当为true时,会移除所有数据
    2. beforeInvocation:非必需,默认为false,会在调用方法之后移除数据。当为true时,会在调用方法之前移除数据。

由于本项目没有涉及到数据库的链接,下面,我们来模拟数据库的操作,并把结果缓存到Redis中

@Service
@Slf4j
@CacheConfig(cacheNames = "users")
public class RedisCacheServiceImpl implements RedisCacheService &#123;

    @Override
    @CachePut(key = "#p0.id")
    public User save(User user) &#123;
        log.info("-----执行数据库更新操作");
        log.info("-----数据库更新完成,返回结果");

        return user;
    &#125;

    @Override
    @Cacheable(key = "#p0")
    public User get(String id) &#123;
        log.info("-----执行数据库查询操作");
        User user = User.builder().id(id).name("spring").age(18).build();
        log.info("-----数据库查询完成,返回结果");
        return user;
    &#125;

    @Override
    @CacheEvict(key = "#p0")
    public void delete(String id) &#123;
        log.info("-----执行数据库删除操作");
        log.info("-----数据库删除完成,返回结果");
    &#125;
&#125;

在Junit中进行测试

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
@Slf4j
public class RedisCacheServiceTest &#123;
    @Resource
    private RedisCacheService redisCacheService;

    @Test
    public void testGet() &#123;
        User user = redisCacheService.get("1111111");
        log.info(user.toString());
    &#125;

    @Test
    public void testSave() &#123;
        User user = User.builder().id("1111111").name("spring").age(20).build();
        redisCacheService.save(user);
    &#125;

    @Test
    public void testDelete() &#123;
        redisCacheService.delete("1111111");
    &#125;
&#125;

先调用get方法,此时,Redis中没有此数据,会进入方法,拿到数据之后返回,并且把数据缓存到Redis中,结果如下:

2018-05-22 10:57:57.532  INFO 42313 --- [           main] o.b.r.s.impl.RedisCacheServiceImpl       : -----执行数据库查询操作
2018-05-22 10:57:57.533  INFO 42313 --- [           main] o.b.r.s.impl.RedisCacheServiceImpl       : -----数据库查询完成,返回结果
2018-05-22 10:57:57.557  INFO 42313 --- [           main] o.b.redis.service.RedisCacheServiceTest  : User(id=1111111, name=spring, age=18)

再调用一次get方法,此时将不会进入方法中,直接从缓存中拿到数据并返回,结果如下:

2018-05-22 10:57:57.557  INFO 42313 --- [           main] o.b.redis.service.RedisCacheServiceTest  : User(id=1111111, name=spring, age=18)

再调用save方法,会把缓存中ID为1111111的User年龄更新为20,调用delete方法会删除缓存,和预期的结果一致,这里就不贴结果了,感兴趣的同学可以自行验证。

总结

至此,整篇文章就结束了,文章包含了RedisTemplate的使用,以及Spring提供的@Cacheable等注解的使用,都是日常开发中常常用到的东西。

最后,附上github源码,欢迎star,一起交流。boot-redis


   转载规则

本文不允许转载。
 上一篇
Java并发之多线程 Java并发之多线程
Java并发之多线程什么是线程? 通常我们在使用桌面操作系统的时候,说的都是XXX进程。比如我们启动一个Java程序,那操作系统中就会新建一个Java进程。那线程是什么呢?线程是比进程更加轻量级的调度单位,在现代操作系统中,线程就是最小的调
下一篇 
Spring之IOC的注入方式 Spring之IOC的注入方式
Spring之IOC的注入方式 在java中,要使用一个对象,必须先创建一个实例,但是有了IOC之后,对象的创建与销毁都交给了IOC容器,不用我们手动创建,而是直接从IOC容器中获取,达到了解耦的效果。IOC是一种思想,在Spring中,实
2018-05-09
  目录