Redis缓存中使用Kryo序列化工具并且修改内容同时更新缓存

背景

缓存做为加速数据访问的途径在许多的系统开发中已经是必不可少。在实际的使用中存在这样一个场景：

对象的的内容非常庞大，一次数据查询量比较大，在并发访问时频繁访问数据库会造成性能瓶颈，实际使用中就会使用缴存，对对象进行更新操作的时候需要对更新的内容入库。但是不希望删除缓存中的对象，而是只更新缓存中的内容，这样就可以减少数据库的访问。提升应用的访问性能

基于此场景，本示例做了一个用例，可以实用于真实例项目中。

项目路径【Redis使用Kryo序列化工具】

实现

下面只讲解了部分关键代码，完整理示例见项目路径
代码结构

pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example.spring.boot.redis</groupId>
    <artifactId>004-Redis使用Kryo序列化工具</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.8.4</version>
        </dependency>

        <dependency>
            <groupId>com.esotericsoftware</groupId>
            <artifactId>kryo</artifactId>
            <version>4.0.0</version>
        </dependency>

        <dependency>
            <groupId>de.javakaffee</groupId>
            <artifactId>kryo-serializers</artifactId>
            <version>0.41</version>
        </dependency>

    </dependencies>
</project>

AppConfig.java

package com.example.spring.boot.redis.common;

import com.example.spring.boot.redis.entity.RedisConfig;
import com.example.spring.boot.redis.mapper.RedisConfigMapper;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import javax.sql.DataSource;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;


/**
 * Author: 王俊超
 * Date: 2017-05-07 10:02
 * All Rights Reserved !!!
 */
@Configuration

@MapperScan(basePackages = "com.example.spring.boot.redis.mapper")
public class AppConfig {


    /**
     * 设置mybatis会话工厂
     * @param ds
     * @return
     * @throws Exception
     */
    @Primary
    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(DataSource ds) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(ds);

        // 设置mybatis xml文件扫描路径
        factory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath*:mapper/*Mapper.xml"));
        return factory.getObject();
    }

    /**
     * Redis连接工厂
     * @param mapper 这个非常重要，必须在mapper被创建了之后才能创建Redis连接工厂
     * @return
     */
    @Primary
    @Bean("redisConnectionFactory")
    public RedisConnectionFactory redisConnectionFactory(RedisConfigMapper mapper) {

        // 获取redis连接信息
        List<RedisConfig> redisConfigs = mapper.getRedisConfig();
        List<String> clusterNodes = new ArrayList<>();
        for (RedisConfig rc : redisConfigs) {
            clusterNodes.add(rc.getUrl() + ":" + rc.getPort());
        }

        // 获取Redis集群配置信息
        RedisClusterConfiguration rcf = new RedisClusterConfiguration(clusterNodes);

        return new JedisConnectionFactory(rcf);
    }

    /**
     * 创建redis模板
     *
     * @param redisConnectionFactory
     * @return
     * @throws UnknownHostException
     */
    @Primary
    @Bean("redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // redis value使用的序列化器
        template.setValueSerializer(new KryoRedisSerializer<>());
        // redis key使用的序列化器
        template.setKeySerializer(new KryoRedisSerializer<>());
        template.setHashKeySerializer(new KryoRedisSerializer<>());
        template.setHashValueSerializer(new KryoRedisSerializer<>());

        template.afterPropertiesSet();
        return template;
    }
}

KryoRedisSerializer.java

package com.example.spring.boot.redis.common;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.util.Arrays;

/**
 * Author: 王俊超
 * Date: 2017-05-31 21:43
 * All Rights Reserved !!!
 */
public class KryoRedisSerializer<T> implements RedisSerializer<T> {
    private Kryo kryo = new Kryo();

    @Override
    public byte[] serialize(T t) throws SerializationException {

        System.out.println("[serialize]" + t);

        byte[] buffer = new byte[2048];
        Output output = new Output(buffer);
        kryo.writeClassAndObject(output, t);
        return output.toBytes();
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {

        System.out.println("[deserialize]" + Arrays.toString(bytes));

        Input input = new Input(bytes);
        @SuppressWarnings("unchecked")
        T t = (T) kryo.readClassAndObject(input);
        return t;
    }

}

RedisClient.java

package com.example.spring.boot.redis.common;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;


/**
 * Author: 王俊超
 * Date: 2017-06-04 19:57
 * All Rights Reserved !!!
 */
@Component("redisClient")
public class RedisClient {
    @Autowired
    RedisTemplate<Object, Object> redisTemplate;

    /**
     * 取redis连接
     *
     * @return
     */
    private RedisConnection getConnection() {
        return redisTemplate.getConnectionFactory().getConnection();
    }

    /**
     * 获取缓存的key
     *
     * @param id
     * @return
     */
    private <T> byte[] getKey(T id) {
        // 在spring data redis中，使用@CachePut,@CacheEvict,@Cacheable其缓存名都是
        // CachePut,@CacheEvict,@Cacheable中的cacheNames（即value）值+“:”+key
        // 因为本示例中使用了kryo对象作为redis的对象序列化的工具所以
        // 对cacheName:key要使用序列化，先将“cacheNames:”的值序列化，再对key进行序列化，
        // 将这两部分的byte数组合并起来做为key
        RedisSerializer serializer = redisTemplate.getKeySerializer();
        byte[] idBytes = serializer.serialize(id);
        byte[] prefixBytes = (RedisConst.PERSON_CACHE_NAME + ":").getBytes();
        byte[] key = new byte[prefixBytes.length + idBytes.length];
        System.arraycopy(prefixBytes, 0, key, 0, prefixBytes.length);
        System.arraycopy(idBytes, 0, key, prefixBytes.length, idBytes.length);

        System.out.println(new String(key));
        return key;
    }

    /**
     * 删除redis中的对象
     *
     * @param t
     */
    public <T> void delete(T t) {
        getConnection().del(getKey(t));
    }

    /**
     * 更新缓存中的对象，也可以在redis缓存中存入新的对象
     *
     * @param id
     * @param t
     * @param <T>
     */
    public <T> void set(Long id, T t) {
        byte[] key = getKey(id);
        RedisSerializer serializer = redisTemplate.getValueSerializer();
        byte[] val = serializer.serialize(t);
        getConnection().set(key, val);

    }

    /**
     * 从缓存中取对象
     *
     * @param id
     * @param <T>
     * @return
     */
    public <T> T getObject(Long id) {
        byte[] key = getKey(id);
        byte[] result = getConnection().get(key);
        return (T) redisTemplate.getValueSerializer().deserialize(result);
    }


}

RedisServiceImpl.java

package com.example.spring.boot.redis.service.impl;

import com.example.spring.boot.redis.common.RedisClient;
import com.example.spring.boot.redis.common.RedisConst;
import com.example.spring.boot.redis.entity.Person;
import com.example.spring.boot.redis.mapper.PersonMapper;
import com.example.spring.boot.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * Author: 王俊超
 * Date: 2017-05-07 09:58
 * All Rights Reserved !!!
 */
@Service
@Transactional(readOnly = true)
public class RedisServiceImpl implements RedisService {
    @Autowired
    private PersonMapper personRepository;

    @Autowired
    private RedisClient redisClient;

    /**
     * 创建对象，并且将person对象入缓存，key是person对象的id
     *
     * @param person
     * @return
     */
    @Override
    @CachePut(value = RedisConst.PERSON_CACHE_NAME, key = "#person.id")
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Person save(Person person) {
        personRepository.save(person);
        System.out.println("为id、key为:" + person.getId() + "数据做了缓存");
        return person;
    }

    /**
     * 从缓存中删除person对象，key是person对象的id
     *
     * @param id
     */
    @Override
    @CacheEvict(value = RedisConst.PERSON_CACHE_NAME) //2
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void remove(Long id) {
        System.out.println("删除了id、key为" + id + "的数据缓存");
        //这里不做实际删除操作
    }

    /**
     * 查询对象，并且将person对象入缓存，key是person对象的id
     *
     * @param person
     * @return
     */
    @Override
    @Cacheable(value = RedisConst.PERSON_CACHE_NAME, key = "#person.id") //3
    public Person findOne(Person person) {
        Person p = personRepository.findOne(person.getId());
        System.out.println("为id、key为:" + p.getId() + "数据做了缓存");
        return p;
    }

    /**
     * 更新对象，并且将对象入缓存，减少入缓存需要重新查询
     *
     * @param person
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void update(Person person) {
        personRepository.update(person);
        redisClient.set(person.getId(), person);
    }
}

测试

使用手工方式向redsi服务器中插入数据

使用手工方式取数据

使用redis托管方式取数据

使用手工方式删除数据