访问Redis

    • Lettuce：一个基于Netty的高性能Redis客户端；
    • RedisTemplate：一个类似于JdbcTemplate的接口，用于简化Redis的操作。

    因为Spring Data Redis引入的依赖项很多，如果只是为了使用Redis，完全可以只引入Lettuce，剩下的操作都自己来完成。

    本节我们稍微深入一下Redis的客户端，看看怎么一步一步把一个第三方组件引入到Spring Boot中。

    首先，我们添加必要的几个依赖项：

    • io.lettuce:lettuce-core
    • org.apache.commons:commons-pool2

    注意我们并未指定版本号，因为在spring-boot-starter-parent中已经把常用组件的版本号确定下来了。

    第一步是在配置文件application.yml中添加Redis的相关配置：

    然后，通过RedisConfiguration来加载它：

    1. @ConfigurationProperties("spring.redis")
    2. public class RedisConfiguration {
    3.     private String host;
    4.     private int port;
    5.     private String password;
    6.     private int database;
    8.     // getters and setters...
    9. }

    再编写一个@Bean方法来创建RedisClient，可以直接放在RedisConfiguration中：

    1. @ConfigurationProperties("spring.redis")
    2. public class RedisConfiguration {
    3.     ...
    5.     @Bean
    6.     RedisClient redisClient() {
    7.         RedisURI uri = RedisURI.Builder.redis(this.host, this.port)
    8.                 .withPassword(this.password)
    9.                 .withDatabase(this.database)
    10.                 .build();
    11.         return RedisClient.create(uri);
    12.     }
    13. }
    1. @SpringBootApplication
    2. @Import(RedisConfiguration.class) // 加载Redis配置
    3. public class Application {
    4.     ...

    注意：如果在RedisConfiguration中标注@Configuration，则可通过Spring Boot的自动扫描机制自动加载，否则，使用@Import手动加载。

    紧接着，我们用一个RedisService来封装所有的Redis操作。基础代码如下：

    注意到上述代码引入了Commons Pool的一个对象池，用于缓存Redis连接。因为Lettuce本身是基于Netty的异步驱动，在异步访问时并不需要创建连接池，但基于Servlet模型的同步访问时，连接池是有必要的。连接池在@PostConstruct方法中初始化，在@PreDestroy方法中关闭。

    下一步，是在中添加Redis访问方法。为了简化代码，我们仿照JdbcTemplate.execute(ConnectionCallback)方法，传入回调函数，可大幅减少样板代码。

    首先定义回调函数接口SyncCommandCallback：

    1. @FunctionalInterface
    2. public interface SyncCommandCallback<T> {
    3.     // 在此操作Redis:
    4.     T doInConnection(RedisCommands<String, String> commands);
    5. }

    编写executeSync方法，在该方法中，获取Redis连接，利用callback操作Redis，最后释放连接，并返回操作结果：

    1. public <T> T executeSync(SyncCommandCallback<T> callback) {
    2.     try (StatefulRedisConnection<String, String> connection = redisConnectionPool.borrowObject()) {
    3.         connection.setAutoFlushCommands(true);
    4.         RedisCommands<String, String> commands = connection.sync();
    5.         return callback.doInConnection(commands);
    6.     } catch (Exception e) {
    7.         logger.warn("executeSync redis failed.", e);
    8.         throw new RuntimeException(e);
    9.     }
    10. }

    有的童鞋觉得这样访问Redis的代码太复杂了，实际上我们可以针对常用操作把它封装一下，例如set和get命令：

    1. public String set(String key, String value) {
    2.     return executeSync(commands -> commands.set(key, value));
    3. }
    5. public String get(String key) {
    6.     return executeSync(commands -> commands.get(key));
    7. }

    常用命令可以提供方法接口，如果要执行任意复杂的操作，就可以通过executeSync(SyncCommandCallback<T>)来完成。

    完成了RedisService后，我们就可以使用Redis了。例如，在UserController中，我们在Session中只存放登录用户的ID，用户信息存放到Redis，提供两个方法用于读写：

    1. @Controller
    2. public class UserController {
    3.     public static final String KEY_USER_ID = "__userid__";
    4.     public static final String KEY_USERS = "__users__";
    6.     @Autowired ObjectMapper objectMapper;
    7.     @Autowired RedisService redisService;
    9.     // 把User写入Redis:
    10.     private void putUserIntoRedis(User user) throws Exception {
    11.         redisService.hset(KEY_USERS, user.getId().toString(), objectMapper.writeValueAsString(user));
    13.     // 从Redis读取User:
    14.     private User getUserFromRedis(HttpSession session) throws Exception {
    15.         Long id = (Long) session.getAttribute(KEY_USER_ID);
    16.         if (id != null) {
    17.             String s = redisService.hget(KEY_USERS, id.toString());
    18.             if (s != null) {
    19.                 return objectMapper.readValue(s, User.class);
    20.             }
    21.         }
    22.         return null;
    23.     }
    24.     ...
    25. }

    用户登录成功后，把ID放入Session，把User实例放入Redis：

    1. @PostMapping("/signin")
    2. public ModelAndView doSignin(@RequestParam("email") String email, @RequestParam("password") String password, HttpSession session) throws Exception {
    3.     try {
    4.         User user = userService.signin(email, password);
    5.         session.setAttribute(KEY_USER_ID, user.getId());
    6.         putUserIntoRedis(user);
    7.     } catch (RuntimeException e) {
    8.         return new ModelAndView("signin.html", Map.of("email", email, "error", "Signin failed"));
    9.     }
    10.     return new ModelAndView("redirect:/profile");
    11. }

    需要获取User时，从Redis取出：

    1. @GetMapping("/profile")
    2. public ModelAndView profile(HttpSession session) throws Exception {
    3.     User user = getUserFromRedis(session);
    4.     if (user == null) {
    5.         return new ModelAndView("redirect:/signin");
    6.     }
    7.     return new ModelAndView("profile.html", Map.of("user", user));
    8. }

    从Redis读写Java对象时，序列化和反序列化是应用程序的工作，上述代码使用JSON作为序列化方案，简单可靠。也可将相关序列化操作封装到中，这样可以提供更加通用的方法：

    从下载练习：在Spring Boot中访问Redis （推荐使用快速下载）

    Spring Boot默认使用Lettuce作为Redis客户端，同步使用时，应通过连接池提高效率。