redis缓存实战

最新推荐文章于 2024-05-03 14:07:57 发布

魔笑

最新推荐文章于 2024-05-03 14:07:57 发布

阅读量1.6k

点赞数 5

分类专栏：学习和分享文章标签： redis

本文链接：https://blog.csdn.net/weixin_44291453/article/details/107326253

版权

学习和分享专栏收录该内容

18 篇文章 3 订阅

订阅专栏

四，springboot cache结合redis的使用

五，redis实现分布式集群环境session共享

六，排行榜功能

redis缓存实战

如果想了解redis ，可以去看我的另一篇关于redis的文章，很全，写的不好，请多指教：

https://blog.csdn.net/weixin_44291453/article/details/107283384

这里说一下，window连接redis:

打开cmd ,进入 redis安装目录，然后输入"redis-cli",如图，就可以在里面操作，和看数据了：

redis作为二级缓存

让我们看看什么是一级缓存和二级缓存：

一级缓存是：sqlSession，sql建立连接到关闭连接的数据缓存

在操作数据库时会建立一个sqlSession，在对象中有一个数据结构用于存储缓存数据，第一次查询就会把数据进行缓存，第二次就会从缓存中获取，当sqlSession执行commit，即“增删改”，就会清空缓存
二级缓存是：全局

为什么要二级缓存，当spring和mybatis整合时，每次查询都要进行sqlSession关闭，关闭之后缓存会被清空，如果没有事务一级缓存没有意义

这里用spring boot来整合redis进行讲解

一，搭建redis

首先在你的pom,xml里面加上下面的依赖：

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

然后在，*.properties添加如下配置：

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=

下面是redis的配置类和简单的操做：


  /**
   * 实例化 RedisTemplate 对象
   *
   * @return
   */
//表明他是一个配置类
@Configuration
public class RedisConfig {
    //交个spring容器进行管理，生成bean
    @Bean
    public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

  /**
   * 设置数据存入 redis 的序列化方式,并开启事务
   * 
   * @param redisTemplate
   * @param factory
   */
  private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
      //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！  
      redisTemplate.setKeySerializer(new StringRedisSerializer());
      redisTemplate.setHashKeySerializer(new StringRedisSerializer());
      redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
      redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
      // 开启事务
      redisTemplate.setEnableTransactionSupport(true);
      redisTemplate.setConnectionFactory(factory);
  }


}




//表明它是controller层，并且返回json
@RestController
public class RedisController {
    //将redisTemplate注入进来
    @Resource
    private RedisTemplate redisTemplate;

    //访问路径
    @RequestMapping("/redis/setAndGet")
    @ResponseBody
    public String setAndGetValue(String name,String value){
        redisTemplate.opsForValue().set(name,value);
        return (String) redisTemplate.opsForValue().get(name);
}

二，讲解一下 redisTemplate

这是redisTemplate里面的部分源码

public SetOperations<K, V> opsForSet() {
        if (this.setOps == null) {
            this.setOps = new DefaultSetOperations(this);
        }

        return this.setOps;
}


public ValueOperations<K, V> opsForValue() {
        if (this.valueOps == null) {
            this.valueOps = new DefaultValueOperations(this);
        }

        return this.valueOps;
}


public ZSetOperations<K, V> opsForZSet() {
        if (this.zSetOps == null) {
            this.zSetOps = new DefaultZSetOperations(this);
        }

        return this.zSetOps;
}


public ListOperations<K, V> opsForList() {
        if (this.listOps == null) {
            this.listOps = new DefaultListOperations(this);
        }

        return this.listOps;
}



public <HK, HV> HashOperations<K, HK, HV> opsForHash() {
        return new DefaultHashOperations(this);
}

这里介绍一下这五种api对应的用法：

opsForValue 操作String，Key，Value，包含过期key，setBit位操作等
opsForSet 操作set
opsForHash 操作hash
opsForZset 操作SortSet
opsForList 操作list队列

例如：opsForValue这个方法，他返回的DefaultValueOperations<K, V>类，这里就有相应的api对数据的操作,,这里只列举一部分：

class DefaultValueOperations<K, V> extends AbstractOperations<K, V> implements ValueOperations<K, V> {
    DefaultValueOperations(RedisTemplate<K, V> template) {
        super(template);
    }

    public V get(Object key) {
        return this.execute(new AbstractOperations<K, V>.ValueDeserializingRedisCallback(key) {
            protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
                return connection.get(rawKey);
            }
        }, true);
    }

    public V getAndSet(K key, V newValue) {
        final byte[] rawValue = this.rawValue(newValue);
        return this.execute(new AbstractOperations<K, V>.ValueDeserializingRedisCallback(key) {
            protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
                return connection.getSet(rawKey, rawValue);
            }
        }, true);
    }


    public void set(K key, V value) {
        final byte[] rawValue = this.rawValue(value);
        this.execute(new AbstractOperations<K, V>.ValueDeserializingRedisCallback(key) {
            protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
                connection.set(rawKey, rawValue);
                return null;
            }
        }, true);
    }

}

三，redis作为mybatis缓存

1，用户第一次访问的时候，获取数据库的值，然后将从数据库查处来的值缓存进redis数据库，并且设置过期时间，

2，再次访问时直接从缓存中获取数据

3，String类型常用于登陆，比如缓存token

用如下方法，time就是设定他的过期时间：

 /**
     * set值和get值的时候序列化方式必须保持一致
     * @param id
     * @return
     */
    @RequestMapping("/getUserCache")
    @ResponseBody
    public User getUseCache(String id) {

        //step1 先从redis里面取值
        User user =  (User)redisService.get(key + id);

        //step2 如果拿不到则从DB取值
        if (user == null) {
            User userDB = userMapper.find(id);
            System.out.println("fresh value from DB id:" + id);

            //step3 DB非空情况刷新redis值
            if (userDB != null) {
                redisService.set(key + id, userDB，24*3600L);
                return userDB;
            }
        }
        return user;
    }


/**
	 * 普通缓存放入并设置时间
	 * 
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public boolean set(String key, Object value, long time) {
		try {
			if (time > 0) {
				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
			} else {
				set(key, value);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

四，springboot cache结合redis的使用

为什么要用 springboot cache：可以使用注解就能完成数据进入缓存

spring cache包含两个顶级接口，cache(缓存)和cacheManager(缓存管理器)，顾名思义，cacheManager去管理一堆Cache

看一下，他支持多种缓存，如：redis,ehcache

1，首先添加如下依赖

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

2，开启缓存注解： @EnableCaching，这里的注解放在配置类redisconfig里，即可

3，下面对注解的简单介绍

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

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

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

@CacheEvict（删除）：
对于从缓存中删除陈旧或未使用的数据非常有用，指示缓存范围内的驱逐是否需要执行而不仅仅是一个条目驱逐

4，我们用简单的实例看看怎么用：

@Service
@CacheConfig(cacheNames="userInfoCache") // 本类内方法指定使用缓存时，默认的名称就是userInfoCache
public class UserService {
    @Nullable
    @Cacheable(key="#p0") // @Cacheable 会先查询缓存，如果缓存中存在，则不执行方法
    public User findById(String id){
        System.err.println("根据id=" + id +"获取用户对象，从数据库中获取");
        Assert.notNull(id,"id不用为空");
        return this.userMapper.find(id);
    }


}

第一，生成key：userInfoCache::1，过于简单，容易冲突，所以我们得配置一下

第二，无法设置过期时间，默认过期时间为永久不过期。我们也得配置一下

第三，配置序列化方式，默认的是序列化JDKSerialazable。我们根据自己的项目情况进行配置

RedisConnectionFactory 它的实现类是有两个，一个是LettuceConnectionFactory，还有一个是JedisConnectionFactory

我们找到 RedisCacheManager这个类，如图，里面有个RedisCacheConfiguration配置类，那么下面的配置代码就好理解了：

@Configuration
@EnableCaching
public class RedisConfig {

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

    /*
     * 配置key(类名+方法名+参数)"
     * o(类)
     * method(方法名)
     * objects(参数)
     */

    @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();
        };
    }

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

    /**
     *
     * 给指定的key配置过期时间
     */
    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;
    }

    /**
     * 配置序列化方式
     *默认序列化JDKSerialazable
     *
     */
    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;
    }

}

简单的案例：

@Service
@CacheConfig(cacheNames="userInfoCache") // 本类内方法指定使用缓存时，默认的名称就是userInfoCache
public class UserService {
    @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);
    }

}

步骤1，先回去看缓存里面有没有数据

步骤2，没有数据就会去数据库里面查，

步骤3，把查到的数据放入缓存

根据配置，它的缓存为100秒，它生成的key 为：UserInfoList::userService.findByIdTtl[1]，这个1就是参数

五，redis实现分布式集群环境session共享

多机器部署同一套服务（代码），性能更好，更承受更高的用户并发

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

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

2、redis实现分布式集群配置过程：

1）.引入依赖：

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

2) @EnableRedisHttpSession 开启redis session缓存

maxInactiveIntervalInSeconds指定缓存的时间

下面是setSession和getsession的简单例子：

@RestController
public class SessionController {

    @RequestMapping(value = "/setSession", method = RequestMethod.GET)
    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;
    }

    @RequestMapping(value = "/getSession", method = RequestMethod.GET)
    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;
    }
}

六，redis实现排行榜功能排行榜功能

排行榜功能是一个很普遍的需求。使用 Redis 中有序集合的特性来实现排行榜是又好又快的选择。一般排行榜都是有实效性的，比如“用户积分榜”，游戏中活跃度排行榜，游戏装备排行榜等。

先看排行榜需要那些表

score_flow（积分流水表），用于排行比如：top100

user_score（用户积分表总表），查用户的排名

这是我简单建立的用户表和数据：

1、添加用户积分,这里只是部分代码

里面key是用id+name组成的，查找缓存可以看到用户的姓名

public class RangingService implements InitializingBean {

    private static final String SALESCORE = "sale_score_rank:";
  

 public void increSaleSocre(String uid, Integer score) {
        //从用户表查询数据
        User user = userMapper.find(uid);
        if (user == null) {
            return;
        }

        int uidInt = Integer.parseInt(uid);
        long socreLong = Long.parseLong(score + "");
        String name = user.getName();
        String key = uid + ":" + name;
        //将用户id，name,score插入score_flow（积分流水表）
        scoreFlowMapper.insertSelective(new ScoreFlow(socreLong, uidInt, name));
        //将用户id，name,score插入user_score（用户积分表总表）
        userScoreMapper.insertSelective(new UserScore(uidInt, socreLong, name);
        //将用户缓存；key："sale_score_rank:" value: map<key,score>
        redisTemplate.opsForZSet().incrementScore(SALESCORE,key,score);
    }
}

这里面的redisTemplate.opsForZSet().incrementScore(SALESCORE,key,score),incrementScore方法底层用的是：zIncrBy命令

Zincrby 命令对有序集合中指定成员的分数加上增量 increment，就是当对同一个对象插入分数时，他会对分数进行累加

2.根据用户ID获取排行

 public Map<String, Object> userRank(String uid, String name) {
        Map<String, Object> retMap = new LinkedHashMap<>();
        String key = uid + ":" + name;
        //查找用户的排名
        Integer rank =redisTemplate.opsForZSet().rank(SALESCORE, key).intValue();
        //查找用户的分数
        Long score = redisTemplate.opsForZSet().score(SALESCORE, key).longValue();
        retMap.put("userId", uid);
        retMap.put("score", score);
        retMap.put("rank", rank);
        return retMap;
    }

redisTemplate.opsForZSet().score(SALESCORE, key)，score方法里用的是：zScore命令

zScore　是返回key的分数。

如图：

redisTemplate.opsForZSet().rank(SALESCORE, key)，rank方法里用的是：zrank命令

zrank——返回key对应的SortSet中指定member的排名。其中member按score值递增(从小到大）；
排名以0为底，也就是说，score值最小的成员排名为0，排行榜越高的，值越大,排行榜中运用

2、获取top N 排行

public List<Map<String, Object>> reverseZRankWithRank(long start, long end) {
        //获取指定的范围的排名，比如，获取前100的排名，成员按 score 值递减的次序排列
        Set<ZSetOperations.TypedTuple<Object>> setObj = redisTemplate.opsForZSet().reverseRangeWithScores(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;
}

有如果对你帮助，请点个赞呗

魔笑

关注

5
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
redis缓存实战

这里我分享一下redis实战，如果想了解redis ，可以去看我的这篇文章，很全，希望能对你有帮助这里用spring boot来整合redis进行讲解首先在你的pom,xml里面加上下面的依赖：<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactI.
复制链接

扫一扫