Redis

已于 2022-04-29 23:46:00 修改
阅读量1k 收藏
点赞数
分类专栏： 缓存 文章标签： redis 缓存 java
于 2022-04-29 23:30:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53060535/article/details/124506284
版权

Redis

1.Redis快速入门

1.1 什么是Redis

redis是一款非关系型(NoSql)键值对数据库

1.2 SQL 和 NOSQL的区别

在这里插入图片描述

1.3 Redis安装

1.Redis基于C语言编写 所以需要安装redis所需要的gcc依赖

yum install -y gcc tcl

2.下载redis安装包到指定目录并解压

3.进入redis目录 执行编译命令

make && make install

4.指定redis以后台方式启动 并开机自启

修改redis.conf配置文件 (先拷贝一份)

# 允许访问的地址，默认是127.0.0.1，会导致只能在本地访问。修改为0.0.0.0则可以在任意IP访问，生产环境不要设置为0.0.0.0
bind 0.0.0.0
# 守护进程，修改为yes后即可后台运行
daemonize yes 
# 密码，设置后访问Redis必须输入密码
requirepass 123456

其它常见配置

# 监听的端口
port 6379
# 工作目录，默认是当前目录，也就是运行redis-server时的命令，日志、持久化等文件会保存在这个目录
dir .
# 数据库数量，设置为1，代表只使用1个库，默认有16个库，编号0~15
databases 1
# 设置redis能够使用的最大内存
maxmemory 512mb
# 日志文件，默认为空，不记录日志，可以指定日志文件名
logfile "redis.log"

redis命令

- redis-cli：是redis提供的命令行客户端
- redis-server：是redis的服务端启动脚本
- redis-sentinel：是redis的哨兵启动脚本

通过配置文件设置开机自启 首先新建一个系统服务文件

vi /etc/systemd/system/redis.service

内容如下

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/bin/redis-server /usr/local/src/redis-6.2.6/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

重载系统服务 并设置开机自启

systemctl daemon-reload 
systemctl enable redis
systemctl start redis

Redis 可视化工具

https://github.com/lework/RedisDesktopManager-Windows/releases

1.4 Redis数据结构的使用![

在这里插入图片描述

1.4.1 String常用命令
1.String字符串类型

在这里插入图片描述

2.Hash 哈希类型 ----------> 无序字典

在这里插入图片描述

3.List 列表 ------------> 双向链表结构

在这里插入图片描述

4.Set 无序集合

在这里插入图片描述

5.Zest有序集合 -----常用于排行榜

在这里插入图片描述

1.5 Redis客户端

在这里插入图片描述

SpringDataRedis快速入门

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址：https://spring.io/projects/spring-data-redis
提供了对不同Redis客户端的整合（Lettuce和Jedis）
提供了RedisTemplate统一API来操作Redis
支持Redis的发布订阅模型
支持Redis哨兵和Redis集群
支持基于Lettuce的响应式编程
支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
支持基于Redis的JDKCollection实现

在这里插入图片描述

1.导入依赖

// redis依赖       
<dependency>
   <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>
// 连接池依赖
<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-pool2</artifactId>
</dependency>

​ 2.配置文件

spring:
  redis:
    host: 
    port: 6379
    password:
    lettuce:
      pool:
        max-active: 8  #最大连接
        max-idle: 8 #最大空闲连接
        min-idle: 0 #最小空闲连接
        max-wait: 100 #连接等待时间

@SpringBootTest
public class JedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        // 插入String类型数据
        redisTemplate.opsForValue().set("name", "abc");
        // 读取一条String类型数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

在这里插入图片描述

得到的结果却是字节形式？

因为RedisTemplate可以接收到任意Object作为写入Redis，但采用的是JDK序列化，

在这里插入图片描述

方案一 : 自定义序列化方式

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)throws UnknownHostException {   
    // 创建Template   
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    // 设置连接工厂    
    redisTemplate.setConnectionFactory(redisConnectionFactory);    
    // 设置序列化工具    
    GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
    // key和 hashKey采用 string序列化   
    redisTemplate.setKeySerializer(RedisSerializer.string());    
    redisTemplate.setHashKeySerializer(RedisSerializer.string());
    // value和 hashValue采用 JSON序列化   
    redisTemplate.setValueSerializer(jsonRedisSerializer);    
    redisTemplate.setHashValueSerializer(jsonRedisSerializer);
    return redisTemplate;
}

弊端：会将类的class类型写入json结果中存入redis 带来额外的内存开销

在这里插入图片描述

方案二 : 使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

在这里插入图片描述

@SpringBootTest
public class JedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    void testString() throws Exception {
        User user = new User("ab", 22);
        // 序列化
        String json = mapper.writeValueAsString(user);
        redisTemplate.opsForValue().set("user", json);
        // 反序列化
        String o = (String) redisTemplate.opsForValue().get("user");
        User user1 = mapper.readValue(o, User.class);
        System.out.println(user1);
    }
}

2.Redis实战篇

2.1 redis常见问题

缓存穿透:指用户请求的数据缓存中和数据库都没有，这样缓存永远不会生效，请求都会打到数据库从而导致数据库压力过大而宕机

解决方案:

  1. 增加id的复杂度，给数据做好基础格式校验
  2. 缓存null值
  3. 引入布隆过滤器(数据库的数据会通过某种哈希算法得到哈希值 然后进行二进制转换存储到过滤器中)

缓存雪崩:指同一时间大量key失效,或者redis宕机，导致大量请求到数据库带来数据库的巨大压力

解决方案:

  1. key随机设置过期时间
  2. 利用redis集群提高服务的可用性
  3. 给缓存业务做限流处理
  4. 给业务添加多级缓存

缓存击穿:被高并发访问并且缓存重建业务较复杂的key突然失效了，无数请求在瞬间给数据库进行巨大冲击

解决方案：

  1. 互斥锁

    优点: 没有额外的内存消耗 保证一致性 实现简单 缺点： 线程需要等待 性能受影响 可能会有死锁风险
    在这里插入图片描述

    代码实现

    String key = RedisConstants.CACHE_SHOP + id;
        String shop = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isNotBlank(shop)) {
            return JSONUtil.toBean(shop, Shop.class);
        }
        // 不为空 返回错误信息
        if (shop != null) {
            return null;
        }
        // 获取每个店铺的锁
        String lockKey = RedisConstants.LOCK_SHOP + id;
        Shop shopDo = null;
        try {
            boolean b = tryLock(lockKey);
            if (!b) {
                // 获取锁失败 重试
                Thread.sleep(50);
                queryWithMutex(id);
            }
            // 成功 查询数据库
            shopDo = getById(id);
            if (Objects.isNull(shopDo)) {
                // 防止缓存穿透
                stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP + shopDo.getId(), "", 1, TimeUnit.MINUTES);
                return null;
            }
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP + shopDo.getId(), JSONUtil.toJsonStr(shopDo), 30, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException();
        } finally {
            // 释放锁
            unLock(lockKey);
        }
        return shopDo;

  2. 逻辑过期

    优点：线程无需等待，性能较好 缺点：不保证一致性 有额外内存消耗 实现复杂

在这里插入图片描述

代码实现

        String key = RedisConstants.CACHE_SHOP + id;
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isBlank(shopJson)) {
            return null;
        }
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
        if (redisData.getExpiration().isAfter(LocalDateTime.now())) {
            // 缓存时间在当前时间之后  未过期 直接返回
            return shop;
        }
        // 过期 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP + id;
        boolean lock = tryLock(lockKey);
        if (lock) {
            // 开启独立线程查询数据
            cache_rebuild_executor.submit(() -> {
                try {
                    // 设置数据到缓存中
                    this.saveRedisShop(id, 20L);
                } catch (Exception e) {
                    throw new RuntimeException();
                } finally {
                    unLock(lockKey);
                }
            });
        }
        return shop;

2.2 基于Redis生成分布式全局唯一ID

     LocalDateTime localDateTime = LocalDateTime.now();
        long nowSecond = localDateTime.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;
        // 获取当前时间
        String date = localDateTime.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        // 自增长
        long count = redisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
        // 拼接并返回
        return timestamp << 32 | count;

2.3 Redisson实现分布式锁

    @Resource
    private RedissonClient redissonClient;

    void testRedisson() throws InterruptedException {
        // 获取锁（可重入）,指定锁的名称
        RLock lock = redissonClient.getLock("redissonLock");
        // 尝试获取锁 获取锁的最大等待时间(期间会重试)，锁到时间自动释放
        boolean tryLock = lock.tryLock(1, 10, TimeUnit.SECONDS);
        if (tryLock) {
            try {
                System.out.println("执行业务");
            } finally {
                // 释放锁
                lock.unlock();
            }
        }
    }

2.4 Redis基于Stream实现消息队列

Stream 是Redis 5.0 引入的新的数据类型，可以实现一个功能非常完善的消息队列

在这里插入图片描述

127.0.0.1:6379> xadd s1 * name aaa
"1648951747995-0"

在这里插入图片描述

127.0.0.1:6379> XREAD count 1 block 0 streams s1 $
1) 1) "s1"
   2) 1) 1) "1648951747995-0"
         2) 1) "name"
            2) "aaa"
(7.19s)

Stream类型消息队列XREAD的特点及缺点

  1. 消息可回溯(持久化)
  2. 一条消息可被多个消费者读取
  3. 可以阻塞读取

缺点:

  1. 会造成消息漏读($在处理最新消息时 后面又连续发了好几条消息 再去读取最新消息时 消息会漏掉)

解决:
在这里插入图片描述在这里插入图片描述

127.0.0.1:6379> XGROUP create s1  k1 0
OK

在这里插入图片描述

127.0.0.1:6379> XREADGROUP group  k1 c2  count 1 block 2000 streams s1 >
1) 1) "s1"
   2) 1) 1) "1648953762321-0"
         2) 1) "k1"
            2) "v3"

确认消息是否被消费过

127.0.0.1:6379> xack s1 k1  1648953760733-0 1648953762321-0
(integer) 2

pending list中查询未被确认的消息

127.0.0.1:6379> XPENDING s1 k1 - + 10

基于Stream实现异步秒杀

  private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    // 在服务启动之前初始化lua脚本
    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

    // 创建一个单列线程池
    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

    @PostConstruct
    private void init() {
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }

    private class VoucherOrderHandler implements Runnable {

        @Override
        public void run() {
            String queueName = "stream.orders";
            while (true) {
                try {
                    // 从消息队列中获取消息
                    List<MapRecord<String, Object, Object>> mapRecordList = stringRedisTemplate.opsForStream()
                            .read(Consumer.from("g1", "c1"),
                                    StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                                    StreamOffset.create(queueName, ReadOffset.lastConsumed()));
                    //  判断订单消息是否为空
                    if (CollectionUtil.isEmpty(mapRecordList)) {
                        continue;
                    }
                    // 解析数据 创建订单
                    MapRecord<String, Object, Object> entries = mapRecordList.get(0);
                    Map<Object, Object> value = entries.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                    createVoucherOrder(voucherOrder);
                    // 确定消息
                    stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", entries.getId());
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                    // 从pendlist中查询未消费的消息
                    handlePendingList();
                }
            }
        }

        private void handlePendingList() {
            String groupName = "stream.orders";
            while (true) {
                try {
                    // 从消息队列中获取消息
                    List<MapRecord<String, Object, Object>> mapRecordList = stringRedisTemplate.opsForStream()
                            .read(Consumer.from("g1", "c1"),
                                    StreamReadOptions.empty().count(1),
                                    StreamOffset.create(groupName, ReadOffset.from("0")));
                    //  判断订单消息是否为空
                    if (CollectionUtil.isEmpty(mapRecordList)) {
                        break;
                    }
                    // 解析数据 创建订单
                    MapRecord<String, Object, Object> entries = mapRecordList.get(0);
                    Map<Object, Object> value = entries.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                    createVoucherOrder(voucherOrder);
                    // 确定消息
                    stringRedisTemplate.opsForStream().acknowledge(groupName, "g1", entries.getId());
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                }
            }
        }
    }

    @Override
    public Result seckillVoucher(Long voucherId) {
        Long userId = UserHolder.getUser().getUserId();
        Long orderId = redisWorker.nextId("order");
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(), orderId.toString()
        );
        int value = result.intValue();
        if (value != 0) {
            // 不为0 代表没有购买资格
            return Result.fail(value == 1 ? "库存不足" : "不可重复下单");
        }
        // 返回订单id
        return Result.ok(orderId);
    }


    private void createVoucherOrder(VoucherOrder voucherOrder) {
        Long userId = voucherOrder.getUserId();
        Long voucherId = voucherOrder.getVoucherId();
        RLock lock = redissonClient.getLock("lock:order" + userId);
        boolean tryLock = lock.tryLock();
        // 获取锁
        if (!tryLock) {
            log.error("不允许重复下单");
            return;
        }
        try {
            // 5.1.查询订单
            int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
            // 5.2.判断是否存在
            if (count > 0) {
                // 用户已经购买过了
                log.error("不允许重复下单！");
                return;
            }
            boolean update = seckillVoucherService.update().setSql("stock = stock -1")
                    .eq("voucher_id", voucherId).gt("stock", 0)
                    .update();
            if (!update) {
                log.error("库存不足");
                return;
            }
            save(voucherOrder);
        } finally {
            lock.unlock();
        }
    }

-- 1.参数列表
-- 1.1.优惠券id
local voucherId = ARGV[1]
-- 1.2.用户id
local userId = ARGV[2]
-- 1.3.订单id
local orderId = ARGV[3]

-- 2.数据key
-- 2.1.库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2.订单key
local orderKey = 'seckill:order:' .. voucherId

-- 3.脚本业务
-- 3.1.判断库存是否充足 get stockKey
if (tonumber(redis.call('get', stockKey)) <= 0) then
    -- 3.2.库存不足，返回1
    return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if (redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3.存在，说明是重复下单，返回2
    return 2
end
-- 3.4.扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5.下单（保存用户）sadd orderKey userId
redis.call('sadd', orderKey, userId)
-- 3.6.发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0

2.5 GEO数据结构

常见命令

在这里插入图片描述

127.0.0.1:6379> GEOADD g1 116.378248 39.865275 x1 116.42803 39.903738 x2 116.322287 39.893729 x3
(integer) 3
// 查询距离
127.0.0.1:6379> GEOADD g1 116.378248 39.865275 x1 116.42803 39.903738 x2 116.322287 39.893729 bjx
(integer) 3
// 查询指定范围的数据
127.0.0.1:6379> GEOSEARCH g1 FROMLONLAT 116.378248 39.865275 BYRADIUS 10 km

使用GEO实现附近搜索功能

 @Override
    public Result queryShopByType(Integer typeId, Integer current, Double x, Double y) {
        if (x == null || y == null) {
            // 根据类型分页查询
            Page<Shop> page = query()
                    .eq("type_id", typeId)
                    .page(new Page<>(current, SystemConstants.DEFAULT_PAGE_SIZE));
            // 返回数据
            return Result.ok(page.getRecords());
        }

        int from = (current - 1) * SystemConstants.DEFAULT_PAGE_SIZE;
        int end = current * SystemConstants.DEFAULT_PAGE_SIZE;

        String key = "shop:geo:" + typeId;
        // 按照距离排序、分页。结果：shopId、distance
        GeoResults<RedisGeoCommands.GeoLocation<String>> results = stringRedisTemplate.opsForGeo().search(key,
                GeoReference.fromCoordinate(x, y),
                new Distance(5000),
                RedisGeoCommands.GeoSearchCommandArgs.newGeoSearchArgs().includeDistance().limit(end)
                // 无法进行分页 所以需要手动逻辑分页
        );
        if (results == null) {
            return Result.ok(Collections.emptyList());
        }
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> content = results.getContent();
        if (content.size() <= from) {
            return Result.ok(Collections.emptyList());
        }
        // 4.1.截取 from ~ end的部分
        List<Long> ids = new ArrayList<>(content.size());
        Map<String, Distance> distanceMap = new HashMap<>(content.size());
        content.stream().skip(from).forEach(result -> {
            // 4.2.获取店铺id
            String shopIdStr = result.getContent().getName();
            ids.add(Long.valueOf(shopIdStr));
            // 4.3.获取距离
            Distance distance = result.getDistance();
            distanceMap.put(shopIdStr, distance);
        });
        // 5.根据id查询Shop
        String idStr = StrUtil.join(",", ids);
        List<Shop> shops = query().in("id", ids).last("ORDER BY FIELD(id," + idStr + ")").list();
        for (Shop shop : shops) {
            shop.setDistance(distanceMap.get(shop.getId().toString()).getValue());
        }
        // 6.返回
        return Result.ok(shops);
    }

2.6 BitMap数据结构 主要场景签到表

常见命令

在这里插入图片描述

实现签到表功能

    @Override
    public Result sign() {
        Long userId = UserHolder.getUser().getUserId();
        LocalDateTime currentTime = LocalDateTime.now();
        String datetime = currentTime.format(DateTimeFormatter.ofPattern(":yyyyMM"));
        // key 用户id+年月
        String key = "sign:" + userId + datetime;
        stringRedisTemplate.opsForValue().setBit(key, currentTime.getDayOfMonth() - 1, true);
        return Result.ok();
    }

实现查看连续签到功能

  @Override
    public Result signCount() {
        Long userId = UserHolder.getUser().getUserId();
        LocalDateTime currentTime = LocalDateTime.now();
        String datetime = currentTime.format(DateTimeFormatter.ofPattern(":yyyyMM"));
        // key 用户id+年月
        String key = "sign:" + userId + datetime;
        // 获取本月截止今天为止的所有的签到记录，返回的是一个十进制的数字 BITFIELD sign:5:202204 GET u14 0
        List<Long> longList = stringRedisTemplate.opsForValue().bitField(key, BitFieldSubCommands.create()
                .get(BitFieldSubCommands.BitFieldType.unsigned(currentTime.getDayOfMonth())).valueAt(0));

        // 没有签到结果
        if (CollectionUtil.isEmpty(longList)) {
            return Result.ok(0);
        }
        Long num = longList.get(0);
        if (num == null || num == 0) {
            return Result.ok(0);
        }

        // 6.循环遍历
        int count = 0;
        while (true) {
            // 6.1.让这个数字与1做与运算，得到数字的最后一个bit位  // 判断这个bit位是否为0
            if ((num & 1) == 0) {
                // 如果为0，说明未签到，结束
                break;
            } else {
                // 如果不为0，说明已签到，计数器+1
                count++;
            }
            // 把数字右移一位，抛弃最后一个bit位，继续下一个bit位
            num >>>= 1;
        }
        return Result.ok(count);
    }

3.高级篇

3.1数据丢失问题

1.RDB redis数据备份文件 也叫Redis数据快照 将内存中所有的数据记录到磁盘中，当redis实例重启后 快速从磁盘中读取数据

​ RDB 使用bgsave命令 fork主进程得到子进程，子进程共享主进程的内存数据，完成fock后读取内存数据并写入rdb文件

​ 具体操作:

​ 因为在linux系统中主进程无法直接操作物理内存，所以系统会给每个进程分配一个虚拟内存，虚拟内存和物理内存形成的映射关系表叫页表，子进程会复制主进程的页表从而实现与主进程的数据共享，然后子进程读取内存中的数据并且写入rdb文件中。

2.AOF 命令日志文件

默认策略 everysec 每隔1秒将缓冲区数据写入AOF文件。 因为是记录文件，aof文件会被RDB文件大的多，且aop会记录对同一个key的多次操作，但只有最后一次操作才有意义，所以通过执行bgrewriteaof命令 可以使文件重写，用最少的命令达到相同效果

JustMove0n
关注
专栏目录
菜鸟项目练习：黑马点评项目总结
qq_47960640的博客
11-15 1万+
用来配合学习Redis的知识。1.1 项目使用的技术栈1.2项目架构采用单体架构后端部署在Tomcat上，前端部分部署在Nginx。
学生抢课接口(高并发入门)
Mark姚
01-01 1837
模拟在高并发环境下学生的抢课业务，解决可能存在的安全问题，并且完成系统性能的优化。
Redis消息队列 | 黑马点评
weixin_54232666的博客
01-25 3247
黑马Redis教程-基于redis实现消息队列-黑马点评项目。学习redis的消息队列，这一篇就够了！
redis入门指南 学习笔记(二) Redis的多数据库
八荒六合唯我独尊
05-05 1万+
Redis是一个字典结构的存储服务器，而实际上一个
Redis详解-持续更新中
靖节先生的博客
07-13 275
Redis详解1. Redis概述2. Redis客户端2.1 Redis可视化客户端2.2 Redis Desktop Manager2.3 Redis Client3. Redis原理 1. Redis概述 2. Redis客户端 2.1 Redis可视化客户端 Redis的可视化客户端目前较流行的有两个：Redis Desktop Manager 、 Redis Client 。 Redis官网地址：https://www.redis.com.cn/ 2.2 Redis Desktop Manager
若依前后端分离版去redis版/无redis版本
11-07
基于前后端分离的应用，无论是否使用Redis，都需要考虑如何进行数据的存储和缓存。下面我将分别介绍基于Redis和无Redis的两种版本的特点。 基于Redis的版本 特点 缓存处理：Redis作为内存数据库可以用来缓存频繁访问...
Windows 下 Redis 安装与配置 教程
热门推荐
小青龍 的博客
06-14 16万+
Windows下Redis安装与配置教程，Windows下安装Redis的几种方式，msi安装包安装，zip安装包安装。使用SC命令，手动创建Redis服务及注册表服务项，实现Redis服务后台运行及服务自启动。Redis服务配置查看及修改，Redis服务各配置项简要说明。
redis3.0安装包 window 64位
最新发布
11-09
（1）支持Lua脚本：Redis 3.0支持Lua脚本，可以在Redis中执行脚本，大大提高了Redis的灵活性和可扩展性； （2）可插拔模块化：Redis 3.0提供了可插拔的模块化功能，可以根据用户的需求，自定义模块，实现不同的功能...
redis-windows-7.0.11
05-05
Redis是一种开源的内存数据结构存储系统，它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。Redis可以用作数据库、缓存和消息中间件。Redis在性能、可扩展性和灵活性方面表现出色，因此被广泛应用于Web...
redis-windows-7.2.3.zip
11-09
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。它以其高效的数据处理能力，丰富的数据结构以及简单易用的API赢得了广大开发者青睐。...
Redis使用Geo数据结构完成同城店铺排序
qq_55272229的博客
01-02 871
黑马店铺中的业务处理方法
【Redis】GEO数据类型之附近的店铺实现
qq_61903414的博客
06-01 1027
指定圆心、半径、找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。在指定的范围内搜索member，并按照与指定点之间的距离进行排序后返回，这个范围可以是矩形也可以是圆形。向redis中添加一个地理空间信息，其中包含经度、维度、值（member）与第六个相同，不过该命令可以将结果存储到一个指定的key中。将指定member的坐标转为hash字符串形式并返回。计算两个指定点之间的距离并返回。返回指定member的左边。
day7_redis学习
奋斗的龙猫的博客
12-08 1003
Geo查找附近商铺 BitMap实现用户签到 UV统计
Redis实战——消息队列
qq_59212867的博客
12-12 2319
Redis实战——消息队列，基于Redis实现的三种队列的实现方法
关于List＜Map＜String, Object＞＞个人理解
lswaone的博客
10-30 4万+
首先map<String,Object>是定义了一个Map集合变量，然后list<map<String,Object>>是定义了一个List的集合变量，是map的一个集合；map是那个list的其中一个值。 List<Map<String,Object> list=new ArrayList<Map<String,Object&gt...
Redis 系列08--Redis GEO
fengxianaa的博客
04-24 1303
redis 地理位置 GEO
Redis实战篇（六）附近商铺、用户签到、UV统计
qq_38618691的博客
11-18 893
附近商铺、用户签到、UV统计
redis GEO详细分析和使用
eriz程序之路
07-14 1万+
需求分析： 在美团外卖或者其他软件上都会有显示商家距离你有多少米，这个我们可以利用redis的GEO地理定位计算可以得出，数据库中存放商家的经纬度（坐标），通过geo计算得出距离。 代码已上传至gitHub---->https://github.com/GitHubzcc/redisExample 关于 Redis Geo介绍 1、Redis 的 Geo 是在 3.2 版本才有的 ...
MongoDB的地理位置搜索GeoSearch使用方法探索
技术笔记
12-21 9497
mongoDB的GeoSearch geohash算法 mongoDB使用方法 建立索引 geo查询 方法一网上互相copy的方法 方法二官方文档的方法 方法三within方法mongoDB的GeoSearch 诸如陌陌，Wechat等附近的人功能，都是基于终端上传数据到服务器，然后服务器对以某一个位置为圆心，以一定范围进行搜索来实现的。  如果我们自己对地理位置坐标进行建模搜索附近的人，需要实现
Redis 3.0.0 安装教程
"Redis 是一个高性能的键值存储系统，常用于数据库、缓存和消息中间件等场景。本文档将指导你完成Redis的安装步骤。" 在安装Redis之前，你需要确保你的系统已经安装了GCC编译器，因为Redis源码包需要通过GCC来编译...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值