redis

基本语法

public void putObject() {
        Jedis jedis = new Jedis("localhost", 6379);
        System.out.println(jedis.ping());
        System.out.println("=======================");

        /*string*/
        jedis.set("str","hello redis");
        String jString=jedis.get("str");
        System.out.println(jString);

        /*map*/
        Map map = new HashMap();
        map.put("a", "a");
        map.put("b", "b");
        jedis.hmset("map", map);
        Map map1=jedis.hgetAll("map");
        System.out.println(jedis.hmget("map", "a", "b"));
        System.out.println(map1.keySet());

        /*list*/
        String[] li = {"a", "b", "c"};
        jedis.lpush("li", li);
        List list = jedis.lrange("li", 0, -1);
        System.out.println(list);
    }

springboot  配置

spring.cache.type=redis
spring.cache.redis.time-to-live=60000
# Redis数据库索引（默认为0）
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
#spring.redis.password=123456
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1ms
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=300
# 是否启用SSL连接.
#spring.redis.ssl=false

 service

@Service
@EnableCaching
public class CategoryService {
    @Autowired
    private CategoryMapper categoryMapper;
    @Cacheable(cacheNames = "cate", key = "#p0")
    public Category getById(Integer id) {
        return categoryMapper.getById(id);
    }

    @CachePut(cacheNames = "cate", key = "#p0.id")
    public Category updateCategoryById(Category category) {
        categoryMapper.updateCategoryById(category);
        return category;
    }
}

@Mapper
public interface CategoryMapper {
    @Select("select * from category where id = #{id}")
    Category getById(Integer id);

    @Update("update category set cateName=#{cateName}, date=#{date} where id=#{id} ")
    int updateCategoryById(Category category);
}

 redis配置类

@Configuration
public class MyRedisCacheConfiguration extends CachingConfigurerSupport {

    @Bean
    public CacheManager getRedisCacheManager(RedisConnectionFactory factory) {
        RedisCacheWriter writer = RedisCacheWriter.nonLockingRedisCacheWriter(factory);
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig(
                Thread.currentThread().getContextClassLoader()
        );
        config.entryTtl(Duration.ofHours(1));
        //值的序列化
        // Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        RedisSerializer<Object> jsonSerializer = new GenericJackson2JsonRedisSerializer();
        RedisSerializationContext.SerializationPair pair = RedisSerializationContext.SerializationPair
                .fromSerializer(jsonSerializer);
        config.serializeValuesWith(pair);
        RedisCacheManager manager = new RedisCacheManager(writer, config);
        return manager;
    }
}

项目中使用了热部署，在自动装配bean获取CacheManager时

装载redisconfig，会使用到devtools容器，该容器具有缓存作用

读取redis数据进行反序列化，会出现类型转换错误

解决思路：

1.直接删除热部署

2.创建redisconfig时，指定装载器，不使用devtools

RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig(
        Thread.currentThread().getContextClassLoader()
);

mybatis整合redis缓存

自定义cache类

public class MybatisRedisCache implements Cache {
    private static Logger LOGGER = LoggerFactory.getLogger(MybatisRedisCache.class);
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private String id;
    private Jedis redisClient = createReids();

    public MybatisRedisCache(final String id) {
        if (id == null) {
            try {
                throw new IllegalAccessException("Cache instances require an ID");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        LOGGER.debug(">>>>>>>>>>>>>>>>>>>>>>>>MybatisRedisCache:id=" + id);
        this.id = id;
    }

    private static Jedis createReids() {
        JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);
        return jedisPool.getResource();
    }

    @Override
    public String getId() {
        return this.id;
    }

    @Override
    public void putObject(Object key, Object value) {
        LOGGER.debug(">>>>>>>>>>>>>>>>>>>>>>>>putObject:" + key + "=" + value);
        redisClient.set(SerializeUtil.serialize(key.toString()), SerializeUtil.serialize(value));
    }

    @Override
    public Object getObject(Object key) {
        Object value = SerializeUtil.unserialize(redisClient.get(SerializeUtil.serialize(key.toString())));
        LOGGER.debug(">>>>>>>>>>>>>>>>>>>>>>>>getObject:" + key + "=" + value);
        return value;
    }

    @Override
    public Object removeObject(Object key) {
        return redisClient.expire(SerializeUtil.serialize(key.toString()), 0);
    }

    @Override
    public void clear() {
        redisClient.flushDB();
    }

    @Override
    public int getSize() {
        return Integer.valueOf(redisClient.dbSize().toString());
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }
}

序列化和反序列化

public class SerializeUtil {

    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            // e.getCause().equals(NullPointerException.class);
            // e.printStackTrace();
        }
        return null;
    }
}

mapper.xml文件中配置 

<cache eviction="LRU" type="com.example.demo.util.MybatisRedisCache"/>

常用的淘汰算法：

FIFO：First In First Out，先进先出。判断被存储的时间，离目前最远的数据优先被淘汰。
LRU：Least Recently Used，最近最少使用。判断最近被使用的时间，目前最远的数据优先被淘汰。
LFU：Least Frequently Used，最不经常使用。在一段时间内，数据被使用次数最少的，优先被淘汰。

Redis提供的淘汰策略：

noeviction：达到内存限额后返回错误，客户尝试可以导致更多内存使用的命令（大部分写命令，但DEL和一些例外）
allkeys-lru：为了给新增加的数据腾出空间，驱逐键先试图移除一部分最近使用较少的（LRC）。
volatile-lru：为了给新增加的数据腾出空间，驱逐键先试图移除一部分最近使用较少的（LRC），但只限于过期设置键。
allkeys-random: 为了给新增加的数据腾出空间，驱逐任意键
volatile-random: 为了给新增加的数据腾出空间，驱逐任意键，但只限于有过期设置的驱逐键。
volatile-ttl: 为了给新增加的数据腾出空间，驱逐键只有秘钥过期设置，并且首先尝试缩短存活时间的驱逐键