redis基础介绍+mybatis二级缓存+排行榜实现

作者: 越走越远的风 | 来源:发表于2019-12-19 20:52 被阅读0次

1.redis定义

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构，如字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等。

2.redis数据结构

String类型

    set/get
        设置key对应的值为String类型的value
        获取key对应的值
    mget
        批量获取多个key的值，如果可以不存在则返回nil
    incr && incrby
        incr对key对应的值进行加加操作，并返回新的值;incrby加指定值
    incr && incrby
        incr对key对应的值进行加加操作，并返回新的值;incrby加指定值
    setnx
        设置key对应的值为String类型的value，如果key已经存在则返回0
    setex
        设置key对应的值为String类型的value，并设定有效期 
    其他命令
        getrange 获取key对应value的子字符串
        mset 批量设置多个key的值，如果成功表示所有值都被设置，否则返回0表示没有任何值被设置
        msetnx，同mset，不存在就设置，不会覆盖已有的key
        getset 设置key的值，并返回key旧的值
        append：给指定key的value追加字符串，并返回新字符串的长度

hash类型

Hash是一个String类型的field和value之间的映射表

redis的Hash数据类型的key（hash表名称）对应的value实际的内部存储结构为一个HashMap

Hash特别适合存储对象

相对于把一个对象的每个属性存储为String类型，将整个对象存储在Hash类型中会占用更少内存。

所存储的成员较少时数据存储为zipmap，当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。

运用场景：如用一个对象来存储用户信息，商品信息，订单信息等等。

hset——设置key对应的HashMap中的field的value
hget——获取key对应的HashMap中的field的value
hgetall——获取key对应的HashMap中的所有field的value
hlen--返回key对应的HashMap中的field的数量

list类型

    lpush——在key对应的list的头部添加一个元素
    lrange——获取key对应的list的指定下标范围的元素，-1表示获取所有元素
    lpop——从key对应的list的尾部删除一个元素，并返回该元素
    rpush——在key对应的list的尾部添加一个元素
    rpop——从key对应的list的尾部删除一个元素，并返回该元素

set类型

    sadd——在key对应的set中添加一个元素
    smembers——获取key对应的set的所有元素
    spop——随机返回并删除key对应的set中的一个元素
    suion——求给定key对应的set并集
    sinter——求给定key对应的set交集

SortSet类型

set的基础增加顺序score，再根据score进行排序

zadd ——在key对应的zset中添加一个元素
zrange——获取key对应的zset中指定范围的元素，-1表示获取所有元素
zrem——删除key对应的zset中的一个元素
zrangebyscore——返回有序集key中，指定分数范围的元素列表,排行榜中运用
zrank——返回key对应的zset中指定member的排名。其中member按score值递增(从小到大）； 排名以0为底，也就是说，score值最小的成员排名为0,排行榜中运用
set是通过hashmap存储，key对应set的元素，value是空对象 sortset是怎么存储并实现排序的呢，hashmap存储，还加了一层跳跃表 
跳跃表：相当于双向链表，在其基础上添加前往比当前元素大的跳转链接

3.redis作为mybatis二级缓存整合

1.引入pom.xml依赖
org.springframework.boot spring-boot-starter-cache
2.开启缓存注解： @EnableCaching
3.在方法上面加入SpEL

@CacheConfig(cacheNames="userInfoCache") 在同个redis里面必须唯一

@Cacheable(查) ：来划分可缓存的方法 - 即，结果存储在缓存中的方法，以便在后续调用（具有相同的参数）时，返回缓存中的值而不必实际执行该方法

@CachePut（修改、增加）：当需要更新缓存而不干扰方法执行时，可以使用@CachePut注释。也就是说，始终执行该方法并将其结果放入缓存中（根据@CachePut选项）

@CacheEvict（删除）：对于从缓存中删除陈旧或未使用的数据非常有用，指示缓存范围内的驱逐是否需要执行而不仅仅是一个条目驱逐
4.springboot cache 存在什么问题
-- 1.生成key过于简单，容易冲突userCache::3
自定义KeyGenerator
-- 2.无法设置过期时间，默认过期时间为永久不过期
自定义cacheManager，设置缓存过期时间
-- 3.配置序列化方式，默认的是序列化JDKSerialazable
自定义序列化方式，Jackson

package com.fandf.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 * @author fandongfeng
 * @created 2019/12/8 17:27
 * @description
 */
@Configuration
@EnableCaching
@EnableRedisHttpSession(maxInactiveIntervalInSeconds= 50)
public class RedisConfig {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    /**
     * 生成key名，类名+方法+参数  UserInfoList::UserService.findByIdTtl[1]
     * @return
     */
    @Bean
    public KeyGenerator simpleKeyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(o.getClass().getSimpleName());
            stringBuilder.append(".");
            stringBuilder.append(method.getName());
            stringBuilder.append("[");
            for (Object obj : objects) {
                stringBuilder.append(obj.toString());
            }
            stringBuilder.append("]");

            return stringBuilder.toString();
        };
    }

    /**
     * 自定义cacheManager，设置缓存过期时间
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl(600), // 默认策略，未配置的 key 会使用这个
                this.getRedisCacheConfigurationMap() // 指定 key 策略
        );
    }

    /**
     * 初始化map
     * @return
     */
    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(100));
        redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(18000));
        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> 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);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }

}

二级缓存查询

    /**
     * 从二级缓存中获取数据
     * @param id
     * @return
     */
    @RequestMapping("/getByCache")
    @ResponseBody
    public User getByCache(String id) {
        User user = userService.findById(id);
        return user;
    }


    @Nullable
    @Cacheable(key="#p0", unless = "#result == null") // @Cacheable 会先查询缓存，如果缓存中存在，则不执行方法
    public User findById(String id){
        System.err.println("根据id=" + id +"获取用户对象，从数据库中获取");
        Assert.notNull(id,"id不用为空");
        return this.userMapper.find(id);
    }

    // 因为必须要有返回值，才能保存到数据库中，如果保存的对象的某些字段是需要数据库生成的，
    // 那保存对象进数据库的时候，就没必要放到缓存了
    @CachePut(key="#p0.id")  //#p0表示第一个参数
    //必须要有返回值，否则没数据放到缓存中
    public User insertUser(User u){
        this.userMapper.insert(u);
        //u对象中可能只有只几个有效字段，其他字段值靠数据库生成，比如id
        return this.userMapper.find(u.getId());
    }

    @CachePut(key="#p0.id")
    public User updateUser(User u){
        this.userMapper.update(u);
        //可能只是更新某几个字段而已，所以查次数据库把数据全部拿出来全部
        return this.userMapper.find(u.getId());
    }

    @CacheEvict(key="#p0")  //删除缓存名称为userInfoCache,key等于指定的id对应的缓存
    public void deleteById(String id){
        this.userMapper.delete(id);
    }

    //清空缓存名称为userInfoCache（看类名上的注解)下的所有缓存
    //如果数据失败了，缓存时不会清除的
    @CacheEvict(allEntries = true)
    public void deleteAll(){
        this.userMapper.deleteAll();
    }

    /**
     * 指定生成key的格式
     * @param id
     * @return
     */
    @Nullable
    @Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator") // @Cacheable 会先查询缓存，如果缓存中存在，则不执行方法
    public User findByIdTtl(String id){
        System.err.println("根据id=" + id +"获取用户对象，从数据库中获取");
        Assert.notNull(id,"id不用为空");
        return this.userMapper.find(id);
    }

4.redis实现分布式集群环境session共享

cookie与session

Cookie是什么？ Cookie 是一小段文本信息，伴随着用户请求和页面在 Web 服务器和浏览器之间传递。
Cookie 包含每次用户访问站点时 Web 应用程序都可以读取的信息，我们可以看到在服务器写的cookie，
会通过响应头Set-Cookie的方式写入到浏览器

HTTP协议是无状态的，并非TCP一样进行三次握手，对于一个浏览器发出的多次请求，WEB服务器无法
区分是不是来源于同一个浏览器。所以服务器为了区分这个过程会通过一个 sessionid来区分请求，而这个
sessionid是怎么发送给服务端的呢。cookie相对用户是不可见的，用来保存这个sessionid是最好不过了

redis实现分布式集群配置过程
org.springframework.session spring-session-data-redis
@EnableRedisHttpSession 开启redis session缓存
maxInactiveIntervalInSeconds指定缓存的时间 spring:session:sessions:expires:+‘sessionId’的过期时间

package com.fandf.redis.controller;

import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * @author fandongfeng
 * @created 2019/12/8 16:51
 * @description
 */
@RestController
public class SessionController {

    @PostMapping(value = "/setSession")
    public Map<String, Object> setSession (HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        request.getSession().setAttribute("request Url", request.getRequestURL());
        map.put("request Url", request.getRequestURL());
        return map;
    }

    @GetMapping(value = "/getSession")
    public Object getSession (HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        map.put("sessionIdUrl",request.getSession().getAttribute("request Url"));
        map.put("sessionId", request.getSession().getId());
        return map;
    }
}

5.redis实现排行榜功能

1.初始化加载数据
implements InitializingBean 接口实现afterPropertiesSet()方法
初始化将用户积分加载到redis缓存中
2.方法介绍
zset方法简单介绍

    private static final String RANKGNAME = "user_score";

    private static final String SALESCORE = "sale_score_rank:";

   /**
     * 添加积分
     *  uid = 1  score = 1
     *  uid = 2  score = 2
     *  uid = 3  score = 3
     * @param uid
     * @param score
     * @return
     */
    @ResponseBody
    @RequestMapping("/addScore")
    public String addRank(String uid, Integer score) {
        rankingService.rankAdd(uid, score);
        return "success";
    }

    public void rankAdd(String uid, Integer score) {
        redisService.zAdd(RANKGNAME, uid, score);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 添加指定分数
     * @param uid
     * @param score
     * @return
     */
    @ResponseBody
    @RequestMapping("/increScore")
    public String increScore(String uid, Integer score) {
        rankingService.increSocre(uid, score);
        return "success";
    }

    public void increSocre(String uid, Integer score) {
        redisService.incrementScore(RANKGNAME, uid, score);
    }

    /**
     * 有序集合添加指定分数
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementScore(String key, Object value, double score) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.incrementScore(key, value, score);
    }

    /**
     * 排序，从0开始,正序
     *  uid=1   0
     * @param uid
     * @return
     */
    @ResponseBody
    @RequestMapping("/rank")
    public Map<String, Long> rank(String uid) {
        Map<String, Long> map = new HashMap<>();
        map.put(uid, rankingService.rankNum(uid));
        return map;
    }

    public Long rankNum(String uid) {
        return redisService.zRank(RANKGNAME, uid);
    }

    /**
     * 有序集合获取排名
     * @param key 集合名称
     * @param value 值
     */
    public Long zRank(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rank(key,value);
    }

    /**
     * 查看自己分数
     * @param uid
     * @return
     */
    @ResponseBody
    @RequestMapping("/score")
    public Long rankNum(String uid) {
        return rankingService.score(uid);
    }

    public Long score(String uid) {
        Long score = redisService.zSetScore(RANKGNAME, uid).longValue();
        return score;
    }

  public Double zSetScore(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.score(key,value);
    }

/**
     * 正序排名，分数低的在前面
     *  // http://localhost:8080/scoreByRange?start=0&end=2
     *
     * [
     *   {
     *     "score": 1.0,
     *     "value": "1"
     *   },
     *   {
     *     "score": 2.0,
     *     "value": "2"
     *   },
     *   {
     *     "score": 3.0,
     *     "value": "3"
     *   }
     * ]
     * @param start
     * @param end
     * @return
     */
    @ResponseBody
    @RequestMapping("/scoreByRange")
    public Set<ZSetOperations.TypedTuple<Object>> scoreByRange(Integer start, Integer end) {
        return rankingService.rankWithScore(start,end);
    }

    public Set<ZSetOperations.TypedTuple<Object>> rankWithScore(Integer start, Integer end) {
        return redisService.zRankWithScore(RANKGNAME, start, end);
    }

    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end);
        return ret;
    }

    /**
     * 倒序查询排行榜,分数大的靠前
     * @param start
     * @param end
     * @return
     */
    @ResponseBody
    @RequestMapping("/sale/top")
    public List<Map<String,Object>> reverseZRankWithRank(long start,long end) {
        return rankingService.reverseZRankWithRank(start,end);
    }

public List<Map<String, Object>> reverseZRankWithRank(long start, long end) {
        Set<ZSetOperations.TypedTuple<Object>> setObj = redisService.reverseZRankWithRank(SALESCORE, start, end);
        List<Map<String, Object>> mapList = setObj.stream().map(objectTypedTuple -> {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("userId", objectTypedTuple.getValue().toString().split(":")[0]);
            map.put("userName", objectTypedTuple.getValue().toString().split(":")[1]);
            map.put("score", objectTypedTuple.getScore());
            return map;
        }).collect(Collectors.toList());
        return mapList;
    }


   /**
     * 与下面方法都可实现排名
     * 有序集合获取排名
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start,long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合获取排名
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }

redis 内部怎么实现它的String的？
redis构建了一个叫做简单动态字符串（Simple Dynamic String),简称sds
代码结构：

struct sdshdr {
        //记录已使用长度
        int len;
        //记录空闲未使用的长度
        int free;
        //字符数组
        char[] buf;
}

追加字符的时候有以下三个操作：
1.计算出大小是否足够
2.开辟空间至满足所需大小
3.开辟与已使用大小len相同长度的空闲free空间（如果len < 1M）
开辟1M长度的空闲free空间（如果len >= 1M）

redis字符串性能优势

快速获取字符串长度
--已记录在数据结构中
避免缓冲区溢出
--1计算大小是否足够
--2开辟空间至满足所需大小
降低空间分配次数提升内存使用效率
--空间预分配（即上面所说）

基本上利用zset的这几个方法就可以实现排行榜功能。
下篇在写redis实现分布式锁，持久化策略，布隆过滤器，及redis缓存穿透、雪崩、击穿等问题。

redis基础介绍+mybatis二级缓存+排行榜实现

1.redis定义

2.redis数据结构

3.redis作为mybatis二级缓存整合

4.redis实现分布式集群环境session共享

5.redis实现排行榜功能

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读