SpringBoot整合Redis之SpringDataRedis-蒲公英云

添加依赖：

<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-data-redis</artifactId> 
lt;/dependency>

application.properties:

#redis配置
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=123
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.timeout=5000

配置类：

@Configuration
/**开启SpringBoot支持的缓存功能 使用Nosql或者数据库的时候 当查询的时候会缓存数据*/
@EnableCaching
public class RedisConfig { 
    @Bean
    public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
        CacheManager cacheManager = new RedisCacheManager(redisTemplate);
        return cacheManager;
    }
    @Primary
    @Bean
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
      /**spring data redis 提供多个序列化器 序列化转成json*/
       /* RedisTemplate template = new StringRedisTemplate(factory); Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jackson2JsonRedisSerializer.setObjectMapper(om); template.setValueSerializer(jackson2JsonRedisSerializer); template.afterPropertiesSet(); return template;*/
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate
                <String, Object>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
    @Bean
    public StringRedisTemplate stringRedisTemplate(JedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }
}

redis提供两种序列化方式：

一种是String的序列化策略（RedisTemplate）可以保存对象，一种是JDK的序列化策略（StringRedisTemplate）操作String数据。
除此之外：spring data redis 提供多个序列化器

GenericToStringSerializer：使用 Spring 转换服务进行序列化；
JacksonJsonRedisSerializer：使用 Jackson 1，将对象序列化为 JSON；
Jackson2JsonRedisSerializer：使用 Jackson 2，将对象序列化为 JSON；
JdkSerializationRedisSerializer：使用 Java 序列化；
OxmSerializer：使用 Spring O/X 映射的编排器和解排器（marshaler 和 unmarshaler）实
现序列化，用于 XML 序列化；
StringRedisSerializer：序列化 String 类型的 key 和 value。

redis的五种数据结构：

ValueOperations：字符串类型操作
ListOperations：列表类型操作
SetOperations：集合类型操作
ZSetOperations：有序集合类型操作
HashOperations：散列操作
spring 封装了 RedisTemplate 对象来进行对redis的各种操作，它支持所有的 redis 原生的 api。
RedisTemplate中定义了对5种数据结构操作
1 redisTemplate.opsForValue();//操作字符串
2 redisTemplate.opsForHash();//操作hash
3 redisTemplate.opsForList();//操作list
4 redisTemplate.opsForSet();//操作set
5 redisTemplate.opsForZSet();//操作有序set
BoundValueOperations：字符串类型操作
BoundListOperations：列表类型操作
BoundSetOperations：集合类型操作
BoundZSetOperations：有序集合类型操作
BoundHashOperations：散列操作
BoundValueOperations<String, String> valueOperations = stringRedisTemplate.boundValueOps("key");
BoundListOperations<String, String> listOperations = stringRedisTemplate.boundListOps("key");
BoundSetOperations<String, String> setOperations = stringRedisTemplate.boundSetOps("key");
BoundZSetOperations<String, String> zSetOperations = stringRedisTemplate.boundZSetOps("key");
BoundHashOperations<String, Object, Object> hashOperations = stringRedisTemplate.boundHashOps("key");

　redisTemplate有两个方法经常用到,一个是opsForXXX一个是boundXXXOps,XXX是value的类型,前者获取到一个Opercation,但是没有指定操作的key,可以在一个连接(事务)内操作多个key以及对应的value;后者会获取到一个指定了key的operation,在一个连接内只操作这个key对应的value.

Service:

@Service
public class RedisService { 
    /** * StringRedisTemplate * 也可以是RedisTemplate template; * 只是两种序列化策略不同 * 一种是String的序列化策略，储存String类型数据 * 一种是JDK的序列化策略。可以存储对象类型数据 **/
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    @Autowired
    RedisTemplate template;
    /** * 存储对象 */
    public void addUser(String key, User user) {
        template.opsForValue().set(key, user);
    }
    /** * 存储String数据 */
    public void addString(String key, String string) {
        stringRedisTemplate.opsForValue().set(key, string);
    }
    /** * 获取对象 */
    public User getUser(String key) {
        User user = (User) template.opsForValue().get(key);
        return user;
    }
    /** * 获取String */
    public String getString(String key) {
        String str = stringRedisTemplate.opsForValue().get(key);
        return str;
    }
    /** * 获取String */
    public String getString2(String key) {
/**和前面的方法一样 只不过绑定了key*/
        BoundValueOperations<String, String> boundValueOperations = stringRedisTemplate.boundValueOps(key);
        String str = boundValueOperations.get();
        return str;
    }
    /** * 存储String设置过期时间 */
    public String addStringLimitTime(String key, String value) {
/** 3秒过期*/
        stringRedisTemplate.opsForValue().set(key, value, 3, TimeUnit.SECONDS);
        return "ok";
    }
    /** * 删除redis存储所有的数据 */
    public void delete() {
        Set<String> set = stringRedisTemplate.keys("*");
        System.out.println(set.size());
        stringRedisTemplate.delete(set);
        System.out.println("删除成功");
    }
    /** * 删除redis存储所有的数据 */
    public void delete2() {
        Set<String> set = template.keys("*");
        System.out.println(set.size());
        template.delete(set);
        System.out.println("删除成功");
    }
}

Controller测试：

@Controller
public class RedisController { 
    @Autowired
    RedisService redisService;
    /** * 存储对象测试 */
    @RequestMapping("/addUser")
    @ResponseBody
    public String addUser() {
        User user = new User(1, "A", "123");
        redisService.addUser("userA", user);
        return "ok";
    }
    /** * 获取对象测试 */
    @RequestMapping("/getUser")
    @ResponseBody
    public User getUser() {
        User user = redisService.getUser("userA");
        return user;
    }
    /** * 存储String测试 */
    @RequestMapping("/addString")
    @ResponseBody
    public String addString() {
        redisService.addString("str1", "String1");
        return "ok";
    }
    /** * 获取String测试 */
    @RequestMapping("/getString")
    @ResponseBody
    public String getString() {
        String string = redisService.getString("str1");
        return string;
    }
    /** * 获取String测试 */
    @RequestMapping("/getString2")
    @ResponseBody
    public String getString2() {
        String string = redisService.getString2("str1");
        return string;
    }
    /** * 过期时间测试 */
    @RequestMapping("/addLimitTime")
    @ResponseBody
    public String addLimitTime() {
        String string = redisService.addStringLimitTime("time", "timeValue");
        return string;
    }
    /** * 过期时间测试 */
    @RequestMapping("/getLimitTime")
    @ResponseBody
    public String getLimitTime() {
        String string = redisService.getString("time");
        return string;
    }
    /**清除缓存*/
    @RequestMapping("/remove")
    @ResponseBody
    public String delete(){
         redisService.delete();
        return "ok";
    }
}