Redis是什么

Redis是一个开源的，高性能的，基于键值对的缓存与存储系统，通过提供多种建值数据类型来适应不同场景下的缓存与存储需求。

Redis特性

存储结构

Redis支持的健值数据类型如下：字符串类型，散列类型，列表类型，集合类型，有序集合类型

内存存储与持久化

Redis数据库中所有的数据都存储在内存中。Redis提供了对持久化的支持，即可以将内存中的数据异步写入到磁盘中，同时不影响继续提供服务

功能丰富

Redis可以作为缓存，消息队列等

简单稳定

Redis直观的存储结构使得通过程序与Redis交互十分简单。

Redis常用的数据类型

String（字符串），List（列表），Set（集合），Hash（哈希），Zset（有序集合）

Springboot中如何对Redis进行操作

Springboot提供了两个操作Redis的类：RedisTemplate、StringRedisTemplate

这两个类的区别为：

两者的关系是StringRedisTemplate继承RedisTemplate。
两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。
RedisTemplate使用的是JdkSerializationRedisSerializer 存入数据会将数据先序列化成字节数组然后在存入Redis数据库。 StringRedisTemplate使用的是StringRedisSerializer。

如何进行选择：

当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可。

但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。

Springboot集成Redis

快速创建springboot项目：https://start.spring.io/

选择Project，Language，Springboot版本。填写Group，Artifact，Name，选择packaging，

添加依赖

点击第一个按钮，导出项目。导出项目后解压，导入到开发工具中，pom配置如下：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.13.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.redisexample</groupId>
	<artifactId>redisdemo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>redisdemo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<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-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
		</dependency>
		
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

在application.properties文件中加入Redis配置：

spring:
  redis:
    host: 127.0.0.1
    port: 6379

新建一个测试类：

package com.redisexample.redisdemo;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.redisexample.redisdemo.pojo.User;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = RedisdemoApplication.class)
public class Test2 {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void TestRedis() {
        User user = new User();
        user.setAddress("上海市浦东新区");
        user.setName("张三");
        user.setAge(25);
        redisTemplate.opsForValue().set("user", user);

    }
}

User 实体代码如下:

package com.redisexample.redisdemo.pojo;

import java.io.Serializable;

public class User implements Serializable {
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    private String name;
    private int    age;
    private String address;

}

运行测试类后使用RedisDesktopManager查看

使用默认的序列化方式存储到redis的数据人工不可读，key 和 value 都会携带类似\xac\xad\这样的字符串，因此我们都把redis的序列化改成json或者string可读性比较强的方式。下面我们自定义RedisTemplate（需要在pom中加入jackson-databind，jackson-annotations依赖）

package com.redisexample.redisdemo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class RedisConfig {

    /**
     * 自定义 RedisTemplate 
     *
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 为开发方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        // Json序列化配置
        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);

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

在运行上面的测试案例，使用RedisDesktopManager查看如下：

遇到的问题

在不自定义RedisTemplate时

启动Redis报错 java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload

原因：实体类是一个对象，在redis序列化的时候采用的是 jdk序列化。

解决办法：类implements Serializable，不然redis不知道此类是可以被序列化的。

No qualifying bean of type ‘org.springframework.data.redis.core.RedisTemplate< java.lang.String, java.lang.Object>

解决办法：RedisTemplate< String, Object>注入时用到了@Autowired，@Autowired默认按照类型装配的修改为@Resource

使用redisTemplate取值的时候会无法获取导出数据，获得的值为null

redisTemplate 中存取数据都是字节数组。当redis中存入的数据是可读形式而非字节数组时。可以使用 StringRedisTemplate 。

Springboot中如何使用Redis