2016-10-16

Redis 集成

如果数据每次都从数据库查询，当并发大的时候，性能就会急剧的下降，常用、很少变化的数据可以采用 Redis 作为缓存，数据首先从 Redis 里查询，如果 Redis 里没有，然后才从数据库查询，并把查询到的结果放入 Redis。

Gradle 依赖

1 2	compile 'org.springframework.data:spring-data-redis:1.7.4.RELEASE' compile 'org.springframework.session:spring-session-data-redis:1.2.2.RELEASE'

为了方便且以后可能需要在集群里使用 Redis 存放 Session，故引入了 spring-session-data-redis
同时也指定了使用更新的 spring-data-redis

redis.xml

存放在 resources/config/redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"/>
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <!--<property name="hostName" value="${redis.host}" />-->
        <!--<property name="port" value="${redis.port}" />-->
        <!--<property name="password" value="${redis.password}" />-->
        <!--<property name="timeout" value="${redis.timeout}" />-->
        <property name="database" value="0"/>
        <property name="poolConfig" ref="jedisPoolConfig"/>
        <property name="usePool" value="true"/>
    </bean>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
    </bean>
</beans>

redisTemplate 用来访问 Redis

引入 redis.xml

在 web.xml 的 listener 中加载 redis.xml

<!-- 加载 MyBatis, Spring Security, Redis 配置等 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath:config/redis.xml
    </param-value>
</context-param>

<!-- Listener -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

使用 RedisTemplate 访问 Redis

@Autowired
private DemoMapper demoMapper;

@Autowired
private StringRedisTemplate redisTemplate;

@GetMapping("/demos/{id}")
@ResponseBody
public Demo findDemoById(@PathVariable int id) {
    // [1] 先从 Redis 查找
    // [2] 找到则返回
    // [3] 找不到则从数据库查询，查询结果放入 Redis
    Demo d = null;
    String redisKey = "demo_" + id;
    String json = redisTemplate.opsForValue().get(redisKey);

    if (json != null) {
        // 如果解析发生异常，有可能是 Redis 里的数据无效，故把其从 Redis 删除
        try {
            d = JSON.parseObject(json, Demo.class);
        } catch (Exception ex) {
            logger.warn(ex.getMessage());
            redisTemplate.delete(redisKey);
        }
    }

    if (d == null) {
        d = demoMapper.findDemoById(id);

        if (d != null) { // 这里需要仔细考虑，null 对象如果不放缓存，如果这个对象被大量访问，会导致缓存穿透，增加数据库的压力
            redisTemplate.opsForValue().set(redisKey, JSON.toJSONString(d));
        }
    }

    return d;
}

清空 Redis 里的数据

flushdb

查看 Redis 缓存是否生效

打印日志
查看数据库链接的非活跃时间，查询到了数据，但是非活跃时间越来越长，说明缓存生效了
- MySQL 执行 show full processlist

重构

观察从 Redis 取数据，没有再从数据库取，然后放入 Redis 的代码，除了 d = JSON.parseObject(json, Demo.class) 和 d = demoMapper.findDemoById(id) 这二句会根据不同的业务逻辑不同外，其他的代码都是不变的，所以可以使用策略模式进行重构。

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * 提供访问 Redis 缓存的功能，默认缓存时间为 1 个小时，也可以自己设置缓存时间
 */
@Service
public class RedisDao {
    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final long DEFAULT_CACHE_DURATION_IN_SECONDS = 3600; // 默认缓存时间为 1 小时 (3600 秒)

    /**
     * 缓存优先读取 JavaBean，如果缓存中没有，则从数据库查询并保存到缓存
     *
     * @param redisKey Redis 中缓存的 key
     * @param clazz    实体类型
     * @param supplier 缓存失败时的数据提供器， supplier == null 时 return null
     * @param <T>      类型约束
     * @return 实体对象
     */
    public <T> T get(String redisKey, Class<T> clazz, Supplier<T> supplier) {
        return get(redisKey, clazz, null, supplier, DEFAULT_CACHE_DURATION_IN_SECONDS);
    }

    /**
     * 缓存优先读取 JavaBean，如果缓存中没有，则从数据库查询并保存到缓存
     *
     * @param redisKey       Redis 中缓存的 key
     * @param clazz          实体类型
     * @param supplier       缓存失败时的数据提供器， supplier == null 时 return null
     * @param timeoutSeconds 缓存超时时间，单位为秒
     * @param <T>            类型约束
     * @return 实体对象
     */
    public <T> T get(String redisKey, Class<T> clazz, Supplier<T> supplier, long timeoutSeconds) {
        return get(redisKey, clazz, null, supplier, timeoutSeconds);
    }

    /**
     * 缓存优先读取 Collections Or Map，如果缓存中没有，则从数据库查询并保存到缓存
     *
     * @param redisKey      Redis 中缓存的 key
     * @param typeReference 反序列化集合时 FastJson 需要用 TypeReference 来指定类型，例如类型为 List<Demo>
     * @param supplier      缓存失败时的数据提供器，supplier == null 时 return null
     * @param <T>           类型约束
     * @return 实体对象
     */
    public <T> T get(String redisKey, TypeReference<T> typeReference, Supplier<T> supplier) {
        return get(redisKey, null, typeReference, supplier, DEFAULT_CACHE_DURATION_IN_SECONDS);
    }

    /**
     * 缓存优先读取 Collections Or Map，如果缓存中没有，则从数据库查询并保存到缓存
     *
     * @param redisKey       Redis 中缓存的 key
     * @param typeReference  反序列化集合时 FastJson 需要用 TypeReference 来指定类型，例如类型为 List<Demo>
     * @param supplier       缓存失败时的数据提供器，supplier == null 时 return null
     * @param timeoutSeconds 缓存超时时间，单位为秒
     * @param <T>            类型约束
     * @return 实体对象
     */
    public <T> T get(String redisKey, TypeReference<T> typeReference, Supplier<T> supplier, long timeoutSeconds) {
        return get(redisKey, null, typeReference, supplier, timeoutSeconds);
    }

    /**
     * 缓存优先读取缓存，如果缓存中没有，则从数据库查询并保存到缓存
     *
     * @param redisKey       Redis 中缓存的 key
     * @param clazz          对象的类型 (clazz 和 typeReference 互斥使用)
     * @param typeReference  反序列化集合时 FastJson 需要用 TypeReference 来指定类型，例如类型为 List<Demo>
     * @param supplier       缓存失败时的数据提供器，supplier == null 时 return null
     * @param timeoutSeconds 缓存超时时间，单位为秒
     * @param <T>            类型约束
     * @return 实体对象
     */
    private <T> T get(String redisKey, Class<T> clazz, TypeReference<T> typeReference, Supplier<T> supplier, long timeoutSeconds) {
        T d = null;
        String json = redisTemplate.opsForValue().get(redisKey);

        if (json != null) {
            // 如果解析发生异常，有可能是 Redis 里的数据无效，故把其从 Redis 删除
            try {
                if (clazz != null) {
                    d = JSON.parseObject(json, clazz);
                } else {
                    d = JSON.parseObject(json, typeReference);
                }
            } catch (Exception ex) {
                redisTemplate.delete(redisKey);
            }
        }

        if (d == null && supplier != null) {
            d = supplier.get();
            // 这里需要考虑，null 对象如果不放缓存，如果这个对象被大量访问，会导致缓存穿透，增加数据库的压力
            // 综合考虑, null 时可缓存 2s, 这样可以防止短时间内的大量访问穿透缓存, 又能不被 null 占据缓存
            if (d != null) {
                redisTemplate.opsForValue().set(redisKey, JSON.toJSONString(d), timeoutSeconds, TimeUnit.SECONDS);
            }
        }

        return d;
    }

    /**
     * 使用 Redis Set 缓存数据，如果缓存没有命中，则使用提供器的数据并保存到缓存
     *
     * @param redisKey       Redis 中缓存的 key
     * @param supplier       缓存失败时的数据提供器
     * @param timeoutSeconds 缓存超时时间，单位为秒
     * @param <T>            类型约束
     * @return 对象集合
     */
    public <T> Set<T> getFromSet(String redisKey, Class<T> clazz, @Nullable Supplier<Set<T>> supplier, long timeoutSeconds) {
        BoundSetOperations<String, String> operations = redisTemplate.boundSetOps(redisKey);
        Set<String> members = operations.members(); // members 有可能返回 null

        if (members != null && !members.isEmpty()) {
            return members.stream().map(member -> JSON.parseObject(member, clazz)).collect(Collectors.toSet());
        } else if (supplier != null) {
            Set<T> newSet = supplier.get();

            if (newSet != null && !newSet.isEmpty()) {
                String[] array = newSet.stream().map(JSON::toJSONString).toArray(String[]::new);
                operations.add(array);
                operations.expire(timeoutSeconds, TimeUnit.SECONDS);

                return newSet;
            }
        }

        return Collections.emptySet();
    }

    /**
     * 指定的 value 是否在 Set values 中。
     * <p>
     * 如果未命中缓存，可能key对应的values未放入缓存或数据过期，考虑把数据放入缓存后再检索
     *
     * @param redisKey key
     * @param value    value
     * @return 是否命中缓存
     */
    public boolean isMember(String redisKey, String value) {
        Boolean is = redisTemplate.boundSetOps(redisKey).isMember(value); // isMember 有可能返回 null
        return is == null ? false : is;
    }

    /**
     * 删除 key 的缓存
     *
     * @param key 缓存的 key
     */
    public void deleteCache(String key) {
        redisTemplate.delete(key);
    }
}

@GetMapping("/demos/{id}")
@ResponseBody
public Demo findDemoById(@PathVariable int id) {
    String redisKey = "demo_" + id;
    Demo d = redisDao.get(redisKey, Demo.class, () -> demoMapper.findDemoById(id));

    return d;
}

不同业务场景可以使用 Lambda 表达式实现 RedisDao.get() 的最后一个参数 Supplier，不需要再关心从 Redis 取数据和存储数据到 Redis 的代码了。

Spring 注解使用 Redis

还可以使用 spring-data-redis 的注解 @Cacheable, @CacheEvict 实现缓存 (使用注解操作 Redis 中的缓存), 但也有缺点, 例如缓存时间只能统一配置, 不能为特定的 key 设置缓存时间, 是否缓存 null 值也不能自定义, 怎么解决缓存穿透是个问题.

Redis 配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/cache
       http://www.springframework.org/schema/cache/spring-cache.xsd">
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"/>
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="poolConfig" ref="jedisPoolConfig"/>
        <property name="usePool"    value="true"/>
        <property name="database"   value="0"/>
    </bean>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
    </bean>

    <bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg ref="redisTemplate"/>
        <property name="defaultExpiration" value="3000"/>
        <property name="transactionAware" value="true"/>
        <property name="usePrefix" value="true"/>
    </bean>

    <!-- 启用缓存注解功能，这个是必须的，否则注解不会生效: 使用 cacheManager -->
    <cache:annotation-driven/>

    <bean id="redisUserService" class="com.xtuer.RedisUserService"/>
</beans>

数据访问服务

使用缓存注解 @Cacheable 和 @CacheEvict

package com.xtuer;

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class RedisUserService {
    /**
     * 第一次查询时从数据库读取, 并保存到 Redis.
     *
     * value 为 Redis 键的前缀, 不能为空
     * key   为 Redis 键的动态部分, 由传入的参数确定, 使用
     *       Spring Expression Language (SpEL) expression for computing the key dynamically.
     *
     * 调用函数 findUserById(123) Redis 中生成缓存的 key 为: user:id_123
     */
    @Cacheable(value="user", key="'id_' + #id")
    public String findUserById(int id) {
        System.out.println("Find user: " + id);
        return "User_" + id;
    }

    /**
     * 删除用户, 并删除 Redis 中的的缓存
     */
    @CacheEvict(value="user", key="'id_' + #id")
    public void deleteUser(int id) {
        System.out.println("Delete user: " + id);
    }
}

测试

import com.xtuer.RedisUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class RedisTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("redis-cache.xml");
        RedisUserService service = context.getBean("redisUserService", RedisUserService.class);

        System.out.println(service.findUserById(123)); // 创建对象, 生成缓存
        System.out.println(service.findUserById(123)); // 直接从缓存读取
        service.deleteUser(123); // 删除缓存
    }
}