spring-boot和redis的缓存使用

1.运行环境

开发工具：intellij idea

JDK版本：1.8

项目管理工具：Maven 4.0.0

2.Maven Plugin管理

pom.xml配置代码：

 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>

     <groupId>com.goku</groupId>
     <artifactId>spring-boot-redis</artifactId>
     <version>1.0-SNAPSHOT</version>
   <build>
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
           <source>1.7</source>
           <target>1.7</target>
         </configuration>
       </plugin>
     </plugins>
   </build>

   <!-- Spring Boot 启动父依赖 -->
   <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>1.5.6.RELEASE</version>
   </parent>

   <dependencies>
     <!-- Spring Boot web依赖 -->
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <!-- Spring Boot test依赖 -->
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
     </dependency>
     <!-- Spring Boot redis 依赖 -->
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
     </dependency>
   </dependencies>

 </project>

3.application.properties编写

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

4.Value序列化缓存方法编写

 package com.goku.demo.config;

 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.serializer.support.DeserializingConverter;
 import org.springframework.core.serializer.support.SerializingConverter;
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.serializer.SerializationException;
 /**
  * Created by nbfujx on 2017/11/8.
  */
 public class RedisObjectSerializer implements RedisSerializer<Object> {
     private Converter<Object, byte[]> serializer = new SerializingConverter();
     private Converter<byte[], Object> deserializer = new DeserializingConverter();
     private static final byte[] EMPTY_ARRAY = new byte[0];

     @Override
     public Object deserialize(byte[] bytes) {
         if (isEmpty(bytes)) {
             return null;
         }
         try {
             return deserializer.convert(bytes);
         } catch (Exception ex) {
             throw new SerializationException("Cannot deserialize", ex);
         }
     }

     @Override
     public byte[] serialize(Object object) {
         if (object == null) {
             return EMPTY_ARRAY;
         }
         try {
             return serializer.convert(object);
         } catch (Exception ex) {
             return EMPTY_ARRAY;
         }
     }

     private boolean isEmpty(byte[] data) {
         return (data == null || data.length == 0);
     }
 }

5.Redis缓存配置类RedisConfig编写

添加注解@EnableCaching，开启缓存功能

 package com.goku.demo.config;

 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.CachingConfigurerSupport;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.StringRedisSerializer;

 /**
  * Created by nbfujx on 2017-12-07.
  */
 @SuppressWarnings("SpringJavaAutowiringInspection")
 @Configuration
 @EnableCaching
 public class RedisConfig extends CachingConfigurerSupport {

     @Bean
     public CacheManager cacheManager(RedisTemplate<Object, Object> redisTemplate) {
         RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
         cacheManager.setDefaultExpiration(1800);
         return cacheManager;
     }

     @Bean
     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
         RedisTemplate<Object, Object> template = new RedisTemplate<>();
         template.setConnectionFactory(factory);
         template.setKeySerializer(new StringRedisSerializer());
         template.setValueSerializer(new RedisObjectSerializer());
         return template;
     }
 }

6.Application启动类编写

 package com.goku.demo;

 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.servlet.ServletComponentScan;

 /**
  * Created by nbfujx on 2017/11/20.
  */
 // Spring Boot 应用的标识
 @SpringBootApplication
 @ServletComponentScan
 public class DemoApplication {

     public static void main(String[] args) {
         // 程序启动入口
         // 启动嵌入式的 Tomcat 并初始化 Spring 环境及其各 Spring 组件
         SpringApplication.run(DemoApplication.class,args);
     }
 }

7.测试用例编写

实体类User编写

 package test.com.goku.demo.model;

 import java.io.Serializable;

 /**
  * Created by nbfujx on 2017-12-07.
  */
 public class User implements Serializable {

     private static final long serialVersionUID = -1L;

     private String username;
     private Integer age;

     public User(String username, Integer age) {
         this.username = username;
         this.age = age;
     }

     public String getUsername() {
         return username;
     }

     public void setUsername(String username) {
         this.username = username;
     }

     public Integer getAge() {
         return age;
     }

     public void setAge(Integer age) {
         this.age = age;
     }
 }

测试方法编写，包含缓存字符和实体

 package test.com.goku.demo;

 import com.goku.demo.DemoApplication;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import test.com.goku.demo.model.User;

 import java.io.Serializable;

 /**
  * Created by nbfujx on 2017-12-07.
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @SpringBootTest(classes = DemoApplication.class)
 public class TestRedis implements Serializable{

     private final Logger logger = LoggerFactory.getLogger(getClass());

     @Autowired
     private RedisTemplate redisTemplate;

     @Test
     public void test() throws Exception {
         // 保存字符串
         redisTemplate.opsForValue().set("数字", "111");
         this.logger.info((String) redisTemplate.opsForValue().get("数字"));
     }

     @Test
     public void testobject() throws Exception {
         User user = new User("用户1", 20);
         redisTemplate.opsForValue().set("用户1",user);
         // 保存对象
         User user2= (User) redisTemplate.opsForValue().get("用户1");
         this.logger.info(String.valueOf(user2.getAge()));
     }

 }

8.查看测试结果

字符串测试

实体测试

9.GITHUB地址

https://github.com/nbfujx/springBoot-learn-demo/tree/master/spring-boot-redis