Question

关系型数据库在性能上总是存在一些这样那样的缺陷，所以大家有时候在使用传统关系型数据库时，会与具有高效存取功能的缓存系统结合使用，以提高系统的访问性能。在很多流行的缓存系统中，Redis 是一个不错的选择。Redis 是一种可以持久存储的缓存系统，是一个高性能的 key-value 数据库，它使用键-值对的方式来存储数据。

2.2.1 Redis 依赖配置

需要使用 Redis，可在工程的 Maven 配置中加入 spring-boot-starter-redis 依赖，如代码清单 2-9 所示。其中 gson 是用来转换 Json 数据格式的工具，mysql 是引用了上一节的模块，这里使用 2.1 节定义的实体对象来存取数据，演示在 Redis 中的存取操作。

代码清单 2-9 Redis 模块的 Maven 依赖配置

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.2.4</version>
    </dependency>
    <dependency>
        <groupId>springboot.db</groupId>
        <artifactId>mysql</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

2.2.2 创建 Redis 服务类

Redis 提供了下列几种数据类型可供存取：

- string；

- hash；

- list；

- set 及 zset。

在实例中，将使用 string 即字符串的类型来演示数据的存取操作。对于 Redis，Spring Boot 没有提供像 JPA 那样相应的资源库接口，所以只能仿照上一节中 Repository 的定义编写一个实体 User 的服务类，如代码清单 2-10 所示。这个服务类可以存取对象 User 以及由 User 组成的列表 List，同时还提供了一个删除的方法。所有这些方法都是使用 RedisTemplate 来实现的。

代码清单 2-10 用户实体的 Redis 服务类

@Repository
public class UserRedis {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    public void add(String key, Long time,User user) {
        Gson gson = new Gson();
        redisTemplate.opsForValue().set(key, gson.toJson(user), time, TimeUnit.
MINUTES);
    }
    public void add(String key, Long time, List<User> users) {
        Gson gson = new Gson();
        redisTemplate.opsForValue().set(key, gson.toJson(users), time, TimeUnit.
MINUTES);
    }
    public User get(String key) {
        Gson gson = new Gson();
        User user = null;
        String userJson = redisTemplate.opsForValue().get(key);
        if(!StringUtils.isEmpty(userJson))
            user = gson.fromJson(userJson, User.class);
        return user;
    }
    public List<User> getList(String key) {
        Gson gson = new Gson();
        List<User> ts = null;
        String listJson = redisTemplate.opsForValue().get(key);
        if(!StringUtils.isEmpty(listJson))
            ts = gson.fromJson(listJson, new TypeToken<List<User>>(){}.getType());
        return ts;
    }
    public void delete(String key){
        redisTemplate.opsForValue().getOperations().delete(key);
    }
}

Redis 没有表结构的概念，所以要实现 MySQL 数据库中表的数据（即普通 Java 对象映射的实体数据）在 Redis 中存取，必须做一些转换，使用 JSON 格式的文本作为 Redis 与 Java 普通对象互相交换数据的存储格式。这里使用 Gson 工具将类对象转换为 JSON 格式的文本进行存储，要取出数据时，再将 JSON 文本数据转化为 Java 对象。

因为 Redis 使用了 key-value 的方式存储数据，所以存入时要生成一个唯一的 key，而要查询或者删除数据时，就可以使用这个唯一的 key 进行相应的操作。

保存在 Redis 数据库中的数据默认是永久存储的，可以指定一个时限来确定数据的生命周期，超过指定时限的数据将被 Redis 自动清除。在代码清单 2-10 中我们以分钟为单位设定了数据的存储期限。

另外，为了能正确调用 RedisTemplate，必须对其进行一些初始化工作，即主要对它存取的字符串进行一个 JSON 格式的系列化初始配置，如代码清单 2-11 所示。

代码清单 2-11 RedisTemplate 初始化

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, String> redisTemplate(
            RedisConnectionFactory factory) {
        StringRedisTemplate 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;
    }
}

2.2.3 Redis 测试

如果还没有安装 Redis 服务器，可以参照本书附录 C 提供的方法安装，然后在工程的配置文件 application.yml 中配置连接 Redis 服务器等参数，如代码清单 2-12 所示。其中 host 和 port 分别表示 Redis 数据库服务器的 IP 地址和开放端口，database 可以不用指定，由 Redis 根据存储情况自动选定（注：测试时这些配置是集成在一个配置类中实现的）。

代码清单 2-12 Redis 配置

spring:
    redis:
    # database: 1
        host: 192.168.1.214
        port: 6379
        pool:
            max-idle: 8
            min-idle: 0
            max-active: 8
            max-wait: -1

现在编写一个 JUint 测试程序，来演示如何在 Redis 服务器中存取数据，如代码清单 2-13 所示。测试程序创建一个部门对象并将其命名为“开发部”，创建一个角色对象并把它命名为 admin，创建一个用户对象并把它命名为 user，同时设定这个用户属于“开发部”，并把 admin 这个角色分配给这个用户。接着测试程序使用类名等参数生成一个 key，并使用这个 key 清空原来的数据，然后用这个 key 存储现在这个用户的数据，最后使用这个 key 查询用户，并将查到的信息打印出来。

代码清单 2-13 Redis 测试程序

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RedisConfig.class, UserRedis.class})
public class RedisTest {
    private static Logger logger = LoggerFactory.getLogger(RedisTest.class);
    @Autowired
    UserRedis userRedis;
    @Before
    public void setup(){
        Deparment deparment = new Deparment();
        deparment.setName("开发部




");
        Role role = new Role();
        role.setName("admin");
        User user = new User();
        user.setName("user");
        user.setCreatedate(new Date());
        user.setDeparment(deparment);
        List<Role> roles = new ArrayList<>();
        roles.add(role);
        user.setRoles(roles);
        userRedis.delete(this.getClass().getName()+":userByname:"+user.getName());
        userRedis.add(this.getClass().getName()+":userByname:"+user.getName(), 10L, user);
    }
    @Test
    public void get(){
        User user = userRedis.get(this.getClass().getName()+":userByname:
user");
        Assert.notNull(user);
        logger.info("======user====== name:{}, deparment:{}, role:{}",
            user.getName(), user.getDeparment().getName(), user.getRoles().get(0).
getName());
    }
}

要运行这个测试程序，可以在 IDEA 的 Run/Debug Configuration 配置中增加一个 JUint 配置项目，模块选择 redis，工作目录选择模块所在的根目录，类选择这个测试程序即 dbdemo.redis.test.RedisTest，并将配置保存为 redistest。

使用 Debug 方式运行测试项目 redistest。如果测试通过，会输出一个用户的用户名、所属部门和拥有角色等简要信息，如下所示：

dbdemo.redis.test.RedisTest - ======user====== name:user, deparment:开发部




, role:admin

对于 Redis 的使用，还可以将注解方式与调用数据库的方法相结合，那样就不用再编写像上面那样的服务类，并且使用起来更加简单，这将在后面的章节中介绍。