倚楼听风雨
淡看江湖路
        找回密码
当前位置：高老四博客 程序员 数据库 正文

[Windows] 分享一下最新可用的 RedisDesktopManager 2020.5 Redis 桌面可视化客户端 持续更新

2018-11-29 12:55:41 本文来源：高老四博客 分类：数据库 / 软件源码 阅读() 评论(16)

2020-11-12 更新：

现在已经不推荐使用 RedisDesktopManager 了，由于作者要恰饭，所以自己编译的版本已经不支持 SSH 连接，喜欢这款工具的人可以花钱支持一下，一年 99 块钱。所以呢，这里老四推荐另一款 Redis 可视化连接客户端，这一款软件也是因为 RedisDesktopManager 不支持 SSH 连接而诞生的，所以名称叫做「AnotherRedisDesktopManager」，目前全部开源并且官方直接提供 Windows、Mac 的安装包，老四测试了一下，虽然某些 SSH 连接情况下存在一些不稳定，但是基本功能相对来讲比较全面，还支持软件的在线更新，是  RedisDesktopManager 非常好的替代者。

[Windows] 分享一下最新可用的 RedisDesktopManager 2020.5 Redis 桌面可视化客户端的图片-高老四博客 第1张

分享软件之前顺便啰嗦浅析一些 Redis 相关的基础知识，毕竟能看到这篇文章的人肯定也都是有要学习的目的的，就当做是复习一下吧。

在现今互联网应用中，NoSQL己经广为应用，在互联网中起到加速系统的作用。有两种 NoSQL 使用最为广泛，那就是 Redis 和 MongoDB。Redis 是一种运行在内存的数据库，支持7种数据类型的存储。同时 Redis 是一个开源、使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存亦可持久化的日志型、键值数据库，并提供多种语言的 API。因为 Redis 是基于内存的，所以运行速度很快，大约是关系数据库几倍到几十倍的速度。Redis 可以在 1 秒内完成 10 万次的读写，性能十分高效。如果我们将常用的数据存储在 Redis 中，用来代替关系数据库的查询访问，网站性能将可以得到大幅提高。

Redis 支持的 7 种数据类型列表如下：string（字符串），hash（哈希），list（列表），set（集合）及 zset（sorted set：有序集合）。

  • 字符串(string)
  • 散列(哈希吗，hash)
  • 列表(链表，list)
  • 集合(set)
  • 有序集合(sorted set)
  • 基数(HyperLogLog)
  • 地理位置(GEO)

Redis 的应用场景（包括但不限于以下列表）:

  • 缓存
  • 任务队列
  • 网站访问统计
  • 数据过期处理
  • 应用排行榜
  • 分布式集群架构中的 session 分离

在现实中，查询数据要远远多于更新数据，一般一个正常的网站查询和更新的比例大约是 1:9 到 3:7，在查询比例较大的网站使用 Redis 可以数倍地提升网站的性能。例如，当一个会员登录网站，我们就把其常用数据从数据库一次性查询出来存放在 Redis 中，那么之后大部分的查询只需要基于 Redis 完成便可以了，这样将很大程度上提升网站的性能。除此之外，Redis 还提供了简单的事务机制，通过事务机制可以有效保证在高并发的场景下数据的一致性。

程序员这个行业的从业人员应该都知道 Redis 没有官方的 Windows 版本，但是伟大（无论怎样都是伟大的）的微软开源技术团队（Microsoft Open Tech group）一直在开发和维护着 Redis 的 Windows 版本，并且一直提供 release 的 64 位版本下载，也支持 32 位版本，但需要自行编译（有几个程序员使用 32 位操作系统的？）。

接下来老四就简单（其实不怎么简单）浅析一下 Redis 在 Spring Boot 中的一些基本知识和应用。Redis 可视化连接工具会在讲完技术之后分享，不想看的直接拉到最后，哈~~~

Spring 中对 Redis 封装简介：

Java 连接 Redis 有很多优秀的封装，但是广泛使用的就是 Jedis（此外还有 Lettuce、Jredis、Srp）了。Spring 通过提供 RedisConnectionFactory 接口生成 RedisConnection 接口对象，在通过实现 RedisConnection 实现对 Redis 底层接口的封装，JedisConnection 就是对 Redis 优秀的封装类，他通过去封装原有的 Jedis 对象从而实现对 Redis 的统一管理。

Spring对Redis的类设计示例图 第2张

图片来源于杨开振《深入浅出 Spring Boot 2.x》侵删

基本的 RedisConnectionFactory 对象创建连接 Redis 实例代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package com.glorze.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
 
/**
* Redis数据源配置
*
* @ClassName: RedisConfig
* @author: glorze.com_高老四
* @since: 2018/11/27 11:28
*/
@Configuration
public class RedisConfig {
 
    private RedisConnectionFactory redisConnectionFactory = null;
 
    /**
     * jedisConnection实现RedisConnection从而对redis进行封装
     * @Title: initConnectionFactory
     * @param []
     * @return org.springframework.data.redis.connection.RedisConnectionFactory
     * @author: 高老四博客
     * @since: 2018/11/27 11:42
     */
    @Bean(name = "redisConnectionFactory")
    public RedisConnectionFactory initConnectionFactory(){
        if(null != this.redisConnectionFactory){
            return this.redisConnectionFactory;
        }
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大空闲数
        jedisPoolConfig.setMaxIdle(88);
        // 最大连接数
        jedisPoolConfig.setMaxTotal(188);
        // 最大等待毫秒数
        jedisPoolConfig.setMaxWaitMillis(2000);
        // 创建Jedis连接工厂
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
        // 配置Redis连接服务器
        RedisStandaloneConfiguration rsc = jedisConnectionFactory.getStandaloneConfiguration();
        // Redis 地址
        rsc.setHostName("127.0.0.1");
        // 端口
        rsc.setPort(6379);
        // 密码，由于老四没有设置密码，所以注释掉
        // rsc.setPassword(RedisPassword.of("123456"));
        this.redisConnectionFactory = jedisConnectionFactory;
        return redisConnectionFactory;
    }
    
    /**
     * 通过RedisTemplate管理Redis连接
     * @Title: initRedisTemplate
     * @param []
     * @return org.springframework.data.redis.core.RedisTemplate<java.lang.Object，java.lang.Object>
     * @author: 高老四博客
     * @since: 2018/11/27 11:50
     */
    @Bean(name = "redisTemplate")
    public RedisTemplate<Object， Object> initRedisTemplate(){
        RedisTemplate<Object， Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(initConnectionFactory());
        RedisSerializer<String> stringRedisSerializer = redisTemplate.getStringSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(stringRedisSerializer);
        return redisTemplate;
    }
}

就像我们之前使用 JDBC 一样，如果每次都要获取连接，进行业务操作，然后在关闭连接是很麻烦的事情，为了简化开发，Spring 中设计了 RedisTemplate 类来进一步管理 Redis 的操作与连接，如上述代码 initRedisTemplate() 方法所示，RedisTemplate 可以自动从 RedisConnectionFactory 获取连接，执行命令，最后也会主动关闭 Redis 连接。

Jedis 中的序列化：

如果 Redis 存储 Java 对象就离不开将对象进行序列化操作，所以 Spring 也提供了序列化机制 – RedisSerializer 接口（实现序列化和反序列化）。同样，RedisTemplate 也对序列化器进行了良好的封装，表格如下：

属性

 描述 备注

defaultSerializer

 默认序列化器 如果没有设置，则使用 JDKSerializationRedisSerializer

keySerializer

 Redis 键序列化器 如果没有设置，则使用默认序列化器

valueSerializer

 Redis 值序列化器 如果没有设置，则使用默认序列化器
hashKeySerializer Redis 散列结构 field 序列化器

如果没有设置，则使用默认序列化器
hashValueSerializer Redis 散列结构 value 序列化器

如果没有设置，则使用默认序列化器
stringSerializer 字符串序列化器

RedisTemplate 自动赋值为 StringRedisSerializer 对象

如上代码所示，initRedisTemplate() 方法就为字符串存储和哈希存储的键值设置 RedisTemplate 默认赋值的字符串序列化器。

除此之外，Spring 对 Redis 所有支持的存储数据类型进行了操作封装，而且都可以通过 RedisTemplate 使用，并且 Spring 也提供了对 Redis 同一键（key）连续多次操作的封装（BoundXXXOperations 接口，可以看后面老四的后面的 Redis 操作数据类型实例代码）。

  1. ValueOperations 字符串操作接口
  2. ListOperations 列表(链表)操作接口
  3. SetOperations 集合操作接口
  4. ZSetOperations 有序集合操作接口
  5. HashOperations 散列操作接口
  6. HyperLogLogOperations 基数操作接口
  7. GeoOperations  地理位置操作接口
  8. BoundValueOperations 绑定一个的键操作
  9. BoundListOperations 绑定一个的键操作
  10. BoundSetOperations 绑定一个的键操作
  11. BoundZSetOperations 绑定一个的键操作
  12. BoundHashOperations 绑定一个的键操作
  13. BoundGeoOperations 绑定一个的键操作

多提一嘴，前面的代码示例 RedisTemplate 虽然做到了帮助我们管理 Redis 连接（从 RedisConnectionFactory 获得连接并初始化常用的 Redis 操作对象），但是对 Redis 每一次操作都是一个打开连接 – 操作 – 关闭连接的一个过程，若想像关系型数据库连接池那样在一个 Redis 连接中一次性进行多种不同的操作需要我们使用 SessionCallback 或者 RedisCallback 接口，通过 RedisTemplate 进行回调实现，具体事例代码可以参考老四文末的具体项目完整代码演示。

实战 Spring-Data-Redis：

我们都知道 Spring Boot 整合了 Spring 各种复杂的配置，让我快速的简单的配置项目，对于 Redis 操作来讲也是一样，在 Spring Boot 中继承 Redis 也是十分简单，尤其是你在理解了上面的一些基本的底层知识之后，使用起来会很顺手。

下面的代码示例演示了在 Spring Boot 基本的操作 Redis 数据类型：

首先在 application.properties 文件配置 Redis 数据源以及一些基本属性配置：

1
2
3
4
5
6
7
8
9
10
11
# 配置连接池属性
spring.redis.jedis.pool.min-idle=5
spring.redis.jedis.pool.max-active=10
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.max-wait=2000
# Redis连接超时时间(毫秒)
spring.redis.timeout=2000
# Redis服务器属性
spring.redis.port=6379
spring.redis.host=127.0.0.1
spring.redis.password=

然后写一个控制器来实现一些 Redis 操作各种各样的数据类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
package com.glorze.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisZSetCommands;
import org.springframework.data.redis.core.*;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;
 
import java.util.*;
 
/**
* Redis在Spring Boot中的常用操作
*
* @ClassName: RedisOperationController
* @author: glorze.com_高老四
* @since: 2018/11/27 14:49
*/
@RestController
@RequestMapping("/redis")
public class RedisOperationController {
 
    @Autowired
    private RedisTemplate redisTemplate = null;
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate = null;
 
    /**
     * Redis操作字符串和哈希数据类型的基本操作
     * @Title: testStringAndHash
     * @param []
     * @return java.lang.String
     * @author: 高老四博客
     * @since: 2018/11/27 15:05
     */
    @RequestMapping("/stringAndHash")
    public String testStringAndHash() {
        redisTemplate.opsForValue().set("redis"， "redis常规操作举例");
        // 默认使用的是JDK的序列化器，所以Redis保存的时候不是整数，即不能做运算操作
        redisTemplate.opsForValue().set("int_key"， "1");
        // 使用stringRedisTemplate可以进行运算操作
        stringRedisTemplate.opsForValue().set("int"， "1");
        stringRedisTemplate.opsForValue().increment("int"， 1);
        // 使用Redis底层进行减一操作，RedisTemplate不支持decr命令
        Jedis jedis = (Jedis) stringRedisTemplate.getConnectionFactory().getConnection().getNativeConnection();
        jedis.decr("int");
 
        // hash操作
        Map<String， String> hash = new HashMap<>(16);
        hash.put("site"， "http://www.glorze.com");
        hash.put("siteName"， "高老四程序员技术博客");
        // 存入一个散列数据类型
        stringRedisTemplate.opsForHash().putAll("hash"， hash);
        // 新增一个字段
        stringRedisTemplate.opsForHash().put("hash"， "siteAuthor"， "高老四");
        // 绑定散列操作的key，这样可以连续对同一个散列数据类型进行操作
        BoundHashOperations hashOps = stringRedisTemplate.boundHashOps("hash");
        // 删除两个个字段
        // hashOps.delete("site"， "siteName");
        // 新增一个字段
        hashOps.put("siteEnglish"， "Glorze");
        return "success";
    }
 
    /**
     * 操作Redis中的列表(链表)类型
     * @Title: testList
     * @param []
     * @return java.util.Map<java.lang.String，java.lang.Object>
     * @author: 高老四博客
     * @since: 2018/11/27 15:08
     */
    @RequestMapping("/list")
    public String testList() {
        // 链表从左到右顺序为10，8，6，4，2
        stringRedisTemplate.opsForList().leftPushAll("list1"， "2"， "4"， "6"， "8"， "10");
        // 链表从左到右顺序为1，3，5，7，9
        stringRedisTemplate.opsForList().rightPushAll("list2"， "1"， "3"， "5"， "7"， "9"， "10");
        // 绑定list2链表操作
        BoundListOperations listOps = stringRedisTemplate.boundListOps("list2");
        // 从右边弹出一个成员
        Object result1 = listOps.rightPop();
        // 获取定位元素，Redis从0开始计算，这里值为"2"
        Object result2 = listOps.index(1);
        // 从左边插入链表
        listOps.leftPush("1");
        // 求链表长度
        Long size = listOps.size();
        // 求链表下标区间成员，整个链表下标范围为0到size-1，这里不取最后一个元素
        List elements = listOps.range(0， size - 2);
        return "success";
    }
 
    /**
     * 操作集合 散列表无须不重复 set
     * @Title: testSet
     * @param []
     * @return java.util.Map<java.lang.String，java.lang.Object>
     * @author: 高老四博客
     * @since: 2018/11/27 15:14
     */
    @RequestMapping("/set")
    public String testSet() {
        // 集合不允许重复，这里只会插入5个成员到集合中
        stringRedisTemplate.opsForSet().add("set1"， "1"， "1"， "2"， "3"， "4"， "5");
        stringRedisTemplate.opsForSet().add("set2"， "2"， "4"， "6"， "8");
        // 绑定set1集合操作
        BoundSetOperations setOps = stringRedisTemplate.boundSetOps("set1");
        // 增加两个元素
        setOps.add("6"， "7");
        // 删除两个元素
        setOps.remove("1"， "7");
        // 返回所有元素
        Set<String> set1 = setOps.members();
        // 求成员数
        Long size = setOps.size();
        // 求交集
        Set<String> inter = setOps.intersect("set2");
        // 求交集，并且用新集合inter保存
        setOps.intersectAndStore("set2"， "inter");
        // 求差集
        Set diff = setOps.diff("set2");
        // 求差集，并且用新集合diff保存
        setOps.diffAndStore("set2"， "diff");
        // 求并集
        Set union = setOps.union("set2");
        // 求并集，并且用新集合union保存
        setOps.unionAndStore("set2"， "union");
        return "success";
    }
 
    /**
     * 通过TypedTuple接口操作Redis有序集合
     * @Title: testZset
     * @param []
     * @return java.lang.String
     * @author: 高老四博客
     * @since: 2018/11/27 15:20
     */
    @RequestMapping("/zset")
    public String testZset() {
        Set<ZSetOperations.TypedTuple<String>> typedTupleSet = new HashSet<>();
        int magicNum = 9;
        for (int i = 1; i <= magicNum; i++) {
            // 分数
            double score = i * 0.1;
            // 创建一个TypedTuple对象，存入值和分数
            ZSetOperations.TypedTuple<String> typedTuple = new DefaultTypedTuple<String>("value" + i， score);
            typedTupleSet.add(typedTuple);
        }
        // 往有序集合插入元素
        stringRedisTemplate.opsForZSet().add("zset1"， typedTupleSet);
        // 绑定zset1有序集合操作
        BoundZSetOperations<String， String> zsetOps = stringRedisTemplate.boundZSetOps("zset1");
        // 增加一个元素
        zsetOps.add("value10"， 0.26);
        Set<String> setRange = zsetOps.range(1， 6);
        // 按分数排序获取有序集合
        Set<String> setScore = zsetOps.rangeByScore(0.2， 0.6);
        // 定义值范围
        RedisZSetCommands.Range range = new RedisZSetCommands.Range();
        // 大于value3
        range.gt("value3");
        // 大于等于value3
        // range.gte("value3");
        // 小于value8
        // range.lt("value8");
        // 小于等于value8
        range.lte("value8");
        // 按值排序，按字符串排序
        Set<String> setLex = zsetOps.rangeByLex(range);
        // 删除元素
        zsetOps.remove("value9"， "value2");
        // 求分数
        Double score = zsetOps.score("value8");
        // 在下标区间下，按分数排序，同时返回value和score
        Set<ZSetOperations.TypedTuple<String>> rangeSet = zsetOps.rangeWithScores(1， 6);
        // 在分数区间下，按分数排序，同时返回value和score
        Set<ZSetOperations.TypedTuple<String>> scoreSet = zsetOps.rangeByScoreWithScores(1， 6);
        // 按从大到小排序
        Set<String> reverseSet = zsetOps.reverseRange(2， 8);
        return "success";
    }
}

除了我们项目中常用的这些 Redis 操作，其实 Redis 还支持事务，流水线（批量执行命令，SessionCallback 接口实现），发布订阅，Lua 脚本等，但是基本在我们的使用当中这些都有更好的产品替代，所以老四也不过多介绍了，感兴趣的可以自行研究一下。

Spring 注解使用 Redis 缓存：

Redis 正是因为其良好的存储性能广泛应用于项目的缓存，比如说用户信息，热门商品（有序结合）等等，因为 Spring Boot 主张注解开发，尽可能减少配置文件，所以在 Spring Boot 中我们可以通过一系列的注解来实现缓存业务，Spring 支持各种各样的缓存，Redis 中提供的是 RedisCacheManager 类，在 Spring Boot 中我们只需要配置 spring.cache.type=REDIS，Spring 就会为我们自动生成 RedisCacheManager 对象。老四也手写了一份基本的使用缓存管理用户信息的 Spring Boot 项目帮助来了解 Spring 缓存注解的使用。具体可以参考一下文末的项目源码。

Spring 支持的缓存产品列表以及 Redis 缓存配置示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 缓存配置
# 缓存类型，自动生成RedisCacheManager对象，默认情况下Spring会根据上下文探测
spring.cache.type=REDIS
spring.cache.cache-names=redisCache # 缓存名称，多个使用"，"分隔
#spring.cache.redis.use-key-prefix=false # 是否启用Redis的键前缀
#spring.cache.redis.cache-null-values=true # 是否允许Redis缓存空值
#spring.cache.redis.key-prefix= # Redis的键前缀
#spring.cache.redis.time-to-live=600000 # 缓存超时时间戳，配置为0则不设置超时时间
 
#spring.cache.caffeine.spec= # caffeine缓存配置细节
#spring.cache.couchbase.expiration=0ms # couchbase缓存超时时间
#spring.cache.ehcache.config= # 配置ehcache缓存初始化文件路径
#spring.cache.infinispan.config= # infinispan缓存配置文件
#spring.cache.jcache.config= # jcache缓存配置文件
#spring.cache.jcache.provider= # jcache缓存提供者配置

基本的用户管理缓存配置重点在于 UserServiceImpl 实现类中的注解配置，源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package com.glorze.service.impl;
 
import com.glorze.dao.UserDao;
import com.glorze.entity.User;
import com.glorze.service.UserService;
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.Transactional;
 
import java.util.List;
 
/**
* 用户操作业务层实现类
*
* @ClassName: UserServiceImpl
* @author: glorze.com_高老四
* @since: 2018/11/27 16:43
*/
@Service
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserDao userDao = null;
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    @Cacheable(value = "redisCache"， key = "'redis_user_'+#id")
    public User getUser(Long id) {
        return userDao.getUser(id);
    }
 
    /**
     * MyBatis回填主键用户编号，将其缓存
     * #ressult代表返回的结果对象
     * @Title: insertUser
     * @param user
     * @return com.glorze.entity.User
     * @author: 高老四博客
     * @since: 2018/11/27 16:45
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    @CachePut(value = "redisCache"， key = "'redis_user_'+#result.id")
    public User insertUser(User user) {
        userDao.insertUser(user);
        return user;
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    @CachePut(value = "redisCache"， condition = "#result != 'null'"， key = "'redis_user_'+#id")
    public User updateUserName(Long id， String userName) {
        // 调用getUser方法，缓存注解会失效所以会继续执行SQL，将查询到数据库最新数据
        User user = this.getUser(id);
        if (user == null) {
            return null;
        }
        user.setUserName(userName);
        userDao.updateUser(user);
        return user;
    }
 
    @Override
    public List<User> findUsers(String userName， String note) {
        return userDao.findUsers(userName， note);
    }
 
    @Override
    @Transactional(rollbackFor = Exception.class)
    @CacheEvict(value = "redisCache"， key = "'redis_user_'+#id"， beforeInvocation = false)
    public int deleteUser(Long id) {
        return userDao.deleteUser(id);
    }
}

好了，基本知识就说这么多，以上所述的一些知识点完整源码老四放在了 GitHub 上面，包括测试 RedisTemplate 的连接，RedisTemplate 操作 Redis 基础数据类型 Redis 缓存管理器使用 Spring 注解实现一个简单的用户管理都在这份源码当中，感兴趣的可以参考一下：

好了，书接上回，我们知道微软为我们提供了 Windows 版本的 Redis，便于我们日常的开发操作，也顺便复习了一下 Redis 在 Spring Boot 中的整合，接着就是本文的最终目的 – Redis 可视化连接查看工具了。这款 RedisDesktopManager 也是开源的，但是自从 0.9.3 版本以后只有订阅（就是付费）或者是代码贡献者才能下载 release 安装包，要不然只能自己编译了。编译其实折腾起来也还好，但考虑到某些人懒，不爱折腾，所以老四索性共享出来一份以供你们使用，亲测win10完美运行。

RedisDesktopManager最新0.9.9windows安装包百度云下载 第3张

最后，喜欢折腾的极客可以参考如下编译过程下载官方源码自行编译使用：

  1. RedisDesktopManager-windows桌面redis连接管理可视化工具项目开源地址
  2. 下载 Visual Studio 2015，专业版社区版就可以，老四提供一个下载地址，Visual Studio 2015社区版下载地址点我。安装时选择自定义安装，必须选择安装 VC++6.0 插件。
  3. 安装 Qt 5.9.6，安装时必须选择 MSVC2015 32bit 编译器。
  4. 从 GitHub 上获取源代码: git clone –recursive https://github.com/uglide/RedisDesktopManager.git rdm && cd ./rdm
  5. 现在完成后进入 3rdparty/qredisclient/3rdparty/hiredis 目录，执行 git apply ../hiredis-win.patch
  6. 找到 src/rdm.pro 文件，右键使用 Qt Creator 打开，然后选择 MSVC2015 32bit 编译器并选择 release 方式构建运行项目，不出意外的话你会看到 RedisDesktopManager 的 GUI 界面自动弹出。
  7. 接下来编译成功需要我们打包成 exe 文件供其他人或者其他电脑安装使用软件，老四这里推荐（也是官方推荐的 NSIS 打包），安装 NSIS 点我下载。
  8. 打包过程中需要 python 定义软件版本，所以还需要安装一下 python 运行环境，自寻 python 官网安装一下 python。
  9. 设置 RedisDesktopManager 版本号：
    1
    2
    3
    4
    cd rdm
    set VERSION=0.9.9.99
    python.exe rdm\build\utils\set_version.py %VERSION% > .\src\version.h
    python.exe rdm\build\utils\set_version.py %VERSION% > .\3rdparty\crashreporter\src\version.h
  10. 编译 crashreporter.exe，由于老四没有编译成功，所以直接找到之前版本的 crashreporter.exe 文件（文末有下载），将 crashreporter.exe 放入到 rdm\bin\windows\release 目录下面。
  11. 最后进行打包 RedisDesktopManager.exe 操作，前提条件将 rdm\bin\windows\release\rdm.exe 文件拷贝到 rdm\build\windows\installer\resources 目录下面，将 rdm\bin\windows\release\rdm.pdb 文件拷贝到 rdm\build\windows\installer\resources 目录下面。
    1
    2
    3
    4
    5
    6
    7
    cd rdm
    rdm\3rdparty\gbreakpad\src\tools\windows\binaries\dump_syms.exe .\bin\windows\release\rdm.pdb > .\build\windows\installer\resources\rdm.sym
    cd rdm\build\windows\installer\resources
    Qt\Qt5.9.6\5.9.6\msvc2015\bin\windeployqt --no-angle --no-opengl-sw --no-compiler-runtime --no-translations --release --force --qmldir rdm\src\qml rdm.exe
    目录rdm\build\windows\installer\resources里面的qmltooling、QtGraphicalEffects文件夹，imageformats文件夹内的qtiff.dll、qwebp.dll可以删除掉
    cd rdm
    call "NSIS安装目录\\NSIS\\makensis.exe" /V1 /DVERSION=%VERSION% rdm\build\windows\installer\installer.nsi
  12. 打包后的可执行 exe 文件可以在 rdm\build\windows\installer 中找到。

注意：以上教程仅适用于 RedisDesktopManager 0.9.9 及以上版本的编译，之前版本据此有区别，自行寻找教程。另外本次老四测试 RedisDesktopManager 0.9.9 版本编译之后存在语言无法切换为中文简体语言的问题，所以老四在文末也提供了相对较稳定的 0.9.8 的打包版本，0.9.8 可以使用简体中文。本文会持续更新 RedisDesktopManager 最新版本 release 发布包分享下载。RedisDesktopManager 0.9.9 和 RedisDesktopManager 0.9.8 两版在老四的 win10 64位 和 win7 64 位亲测完美运行。

本文所述资源合集文末自助下载，下载需要登陆，没有账号的童鞋使用邮箱注册一下即可，资源分享包括：

  • Windows 版本 Redis 最新 msi 安装包
  • Spring-Data-Redis 之 Spring Boot 整合 Redis 示例项目完整源码
  • 桌面连接管理 Redis 可视化工具 RedisDesktopManager 0.9.9 最新版本 exe 安装程序
  • 桌面连接管理 Redis 可视化工具 RedisDesktopManager0.9.8 稳定可使用简体中文版本 exe 安装程序
  • 编译工具 crashreporter.exe 文件

相关文章阅读

  1. 《Java 知识体系思维导图 GitHub 开源分享之 Redis 脑图总结》

更博不易，如果觉得文章对你有帮助并且有能力的老铁烦请捐赠盒烟钱，点我去赞助。或者扫描文章下面的微信/支付宝二维码打赏任意金额（点击「给你买杜蕾斯」），也可以加入本站封闭式交流论坛「DownHub」开启新世界的大门，老四这里抱拳谢谢诸位了。捐赠时请备注姓名或者昵称，因为您的署名会出现在赞赏列表页面，您的捐赠钱财也会被用于小站的服务器运维上面，再次抱拳感谢。

资源下载

隐藏内容：******，购买后可见！

下载价格：0 G币

您需要先后，才能购买资源

欢迎访问高老四博客(glorze.com),本站技术文章代码均为老四亲自编写或者借鉴整合,其余资源多为网络收集,如涉及版权问题请与站长联系。如非特殊说明,本站所有资源解压密码均为:glorze.com。

赞(48) 给你买杜蕾斯
本站原创文章受自媒体平台原创保护,未经允许不得转载高老四博客 » [Windows] 分享一下最新可用的 RedisDesktopManager 2020.5 Redis 桌面可视化客户端
分享到

Glorze

倚楼听风雨 淡看江湖路

相关推荐

开始你的表演 16

取消

  1. #1

    一定要购买吗

    logosty6年前 (2018-11-30)回复

    • 不需要购买啊,老四已经给你们编译好了,直接安装就能使用,并且持续更新。官方只是开源了源代码,但是官方现在不免费发布Windows和Mac OS的安装包了,需要订阅付费购买,老四为了自己和你们使用,自己搭建编译环境免费分享出来的。但愿我的解释你能看懂,在我这里下载不花钱,只需要注册账号登录就可以获取到下载链接了

      Glorze6年前 (2018-11-30)回复
  2. #2

    网盘密码

    cike6年前 (2018-12-03)回复

    • 下载页面有个隐藏字段,那四个字符就是网盘提取码。老铁,看网页要仔细啊~~~

      Glorze6年前 (2018-12-03)回复

      • 感谢，瞎了瞎了

        cike6年前 (2018-12-03)回复

        • 没事,助人为快乐之本

          Glorze6年前 (2018-12-03)回复
  3. #3

    博主能否编译一个带SSH支持的版本 拜谢
    Connection error: QRedisClient compiled without ssh support.

    admin6年前 (2018-12-07)回复

    • 您好,最新版本现在已经不包含ssh支持了,如果您想用ssh版本的请使用老四提供的0.9.8版本,从0.9.9以后不再包含ssh模块了。所以老四也没研究,如果后续版本能继续支持ssh,我到时候研究一下会编译出来发布一下

      Glorze6年前 (2018-12-07)回复

      • 好的 感谢 ~

        admin6年前 (2018-12-07)回复
  4. #4

    服务器上用，就不用中文了，英文更适合！

    davidsmithgf6年前 (2018-12-11)回复
  5. #5

    怎么选择中文不起作用

    8586088236年前 (2018-12-16)回复

    • 老四已经在文章中有所说明,可能是作者代码的bug,这一版本的汉化不起作用,下一版本可能会修复。如果不习惯英文请使用老四提供的0.9.8版本,这一版本支持中文。

      Glorze6年前 (2018-12-16)回复
  6. #6

    感谢博主！！

    firework_dks6年前 (2019-03-21)回复
爆款热文

骚话合集

撩妹撩小哥哥骚话大全

支付宝扫码领红包

高老四博客官方支付宝扫码领红包

热门文章

归档

觉得文章有用就打赏一下老四,鼓励我更好的创作

非常感谢你的打赏，我们将继续给力更多优质内容，让我们一起创建更加美好的网络世界！

支付宝扫一扫打赏

微信扫一扫打赏

登录

找回密码

注册