Java 操作 Redis 五种数据类型

连接与释放

@Autowired
private JedisPool jedisPool;
​
private Jedis jedis = null;
​
// 初始化 jedis 对象实例
@Before
public void initConn(){
jedis = jedisPool.getResource();
}
​
// 释放资源
@After
public void closeConn(){
if (jedis!=null){
jedis.close();
}
}

操作 String

// 1. 操作 String
@Test
public void testString() {
// 添加一条数据
jedis.set(“username”, “zhangsan”);
jedis.set(“age”, “18”);

// 添加多条数据 参数奇数为 key 参数偶数为 value
jedis.mset(“address”, “bj”, “sex”, “1”);

// 获取一条数据
String username = jedis.get(“username”);
System.out.println(username);

// 获取多条数据
List<String> list = jedis.mget(“username”, “age”, “address”, “sex”);
for (String str : list) {
System.out.println(str);
}

// 删除
//jedis.del(“username”);
}

操作 hash

// 2. 操作 Hash
@Test
public void testHash() {
/*
* 添加一条数据
*     参数一：redis 的 key
*     参数二：hash 的 key
*     参数三：hash 的 value
*/
jedis.hset(“userInfo”, “name”, “lisi”);

// 添加多条数据
Map<String, String> map = new HashMap<>();
map.put(“age”, “20”);
map.put(“sex”, “1”);
jedis.hmset(“userInfo”, map);

// 获取一条数据
String name = jedis.hget(“userInfo”, “name”);
System.out.println(name);

// 获取多条数据
List<String> list = jedis.hmget(“userInfo”, “age”, “sex”);
for (String str : list) {
System.out.println(str);
}

// 获取 Hash 类型所有的数据
Map<String, String> userMap = jedis.hgetAll(“userInfo”);
for (Entry<String, String> userInfo : userMap.entrySet()) {
System.out.println(userInfo.getKey() + “–” + userInfo.getValue());
}

// 删除 用于删除 hash 类型数据
//jedis.hdel(“userInfo”, “name”);
}

操作 list

// 3. 操作 list
@Test
public void testList() {
// 左添加(上)
//   jedis.lpush(“students”, “Wang Wu”, “Li Si”);

// 右添加(下)
//   jedis.rpush(“students”, “Zhao Liu”);

// 获取 start 起始下标 end 结束下标 包含关系
List<String> students = jedis.lrange(“students”, 0, 2);
for (String stu : students) {
System.out.println(stu);
}

// 获取总条数
Long total = jedis.llen(“students”);
System.out.println(“ 总条数：” + total);

// 删除单条 删除列表中第一次出现的 Li Si
//   jedis.lrem(“students”, 1, “Li Si”);

// 删除多条
//   jedis.del(“students”);
}
​

操作 set

// 4. 操作 set- 无序
@Test
public void testSet() {
// 添加数据
jedis.sadd(“letters”, “aaa”, “bbb”, “ccc”, “ddd”, “eee”);

// 获取数据
Set<String> letters = jedis.smembers(“letters”);
for (String letter: letters) {
System.out.println(letter);
}

// 获取总条数
Long total = jedis.scard(“letters”);
System.out.println(total);

// 删除
//jedis.srem(“letters”, “aaa”, “bbb”);
}

操作 sorted set

// 5. 操作 sorted set- 有序
@Test
public void testSortedSet() {
Map<String, Double> scoreMembers = new HashMap<>();
scoreMembers.put(“zhangsan”, 7D);
scoreMembers.put(“lisi”, 3D);
scoreMembers.put(“wangwu”, 5D);
scoreMembers.put(“zhaoliu”, 6D);
scoreMembers.put(“tianqi”, 2D);

// 添加数据
jedis.zadd(“score”, scoreMembers);

// 获取数据
Set<String> scores = jedis.zrange(“score”, 0, 4);
for (String score: scores) {
System.out.println(score);
}

// 获取总条数
Long total = jedis.zcard(“score”);
System.out.println(“ 总条数：” + total);

// 删除
//jedis.zrem(“score”, “zhangsan”, “lisi”);
}

Redis 中以层级关系、目录形式存储数据

// Redis 中以层级关系、目录形式存储数据
@Test
public void testdir(){
jedis.set(“user:01”, “user_zhangsan”);
System.out.println(jedis.get(“user:01”));
}

设置 key 的失效时间

Redis 有四个不同的命令可以用于设置键的生存时间 (键可以存在多久) 或过期时间(键什么时候会被删除) :

EXPlRE <key> <ttl> : 用于将键 key 的生存时间设置为 ttl 秒。

PEXPIRE <key> <ttl>: 用于将键 key 的生存时间设置为ttl 毫秒。

EXPIREAT <key> < timestamp>: 用于将键 key 的过期时间设置为 timestamp 所指定的秒数时间戳。

PEXPIREAT <key> < timestamp >: 用于将键 key 的过期时间设置为 timestamp 所指定的毫秒数时间戳。

TTL: 获取的值为 - 1 说明此 key 没有设置有效期，当值为 - 2 时证明过了有效期。

@Test
public void testExpire() {
// 方法一：
jedis.set(“code”, “test”);
jedis.expire(“code”, 180);// 180 秒
jedis.pexpire(“code”, 180000L);// 180000 毫秒
jedis.ttl(“code”);// 获取秒
​
// 方法二：
jedis.setex(“code”, 180, “test”);// 180 秒
jedis.psetex(“code”, 180000L, “test”);// 180000 毫秒
jedis.pttl(“code”);// 获取毫秒
​
// 方法三：
SetParams setParams = new SetParams();
// 不存在的时候才能设置成功
// setParams.nx();
// 存在的时候才能设置成功
setParams.xx();
// 设置失效时间，单位秒
// setParams.ex(30);
// 查看失效时间，单位毫秒
setParams.px(30000);
jedis.set(“code”,”test”,setParams);
}

获取所有 key& 事务 & 删除

// 获取所有 key
@Test
public void testAllKeys() {
// 当前库 key 的数量
System.out.println(jedis.dbSize());
// 当前库 key 的名称
Set<String> keys = jedis.keys(“*”);
for (String key: keys) {
System.out.println(key);
}
}
​
// 操作事务
@Test
public void testMulti() {
Transaction tx = jedis.multi();
// 开启事务
tx.set(“tel”, “10010”);

// 提交事务
//   tx.exec();

// 回滚事务
tx.discard();
}

// 删除
@Test
public void testDelete() {
// 删除 通用 适用于所有数据类型
jedis.del(“score”);
}

操作 byte

SerializeUtil.java

package com.xxxx.util;
​
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
​
/**
* 序列化工具类
*/
public class SerializeUtil {

/**
* 将 java 对象转换为 byte 数组 序列化过程
*/
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;
}
​
/**
* 将 byte 数组转换为 java 对象 反序列化
*/
public static Object unserialize(byte[] bytes) {
if(bytes == null)return null;
ByteArrayInputStream bais = null;
try {
// 反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}

User.java

package com.xxxx.entity;
​
import java.io.Serializable;
​
public class User implements Serializable {
​
private static final long serialVersionUID = 9148937431079191022L;
private Integer id;
private String username;
private String password;
​
public Integer getId() {
return id;
}
​
public void setId(Integer id) {
this.id = id;
}
​
public String getUsername() {
return username;
}
​
public void setUsername(String username) {
this.username = username;
}
​
public String getPassword() {
return password;
}
​
public void setPassword(String password) {
this.password = password;
}
​
@Override
public String toString() {
return “User{” +
“id=” + id +
“, username='” + username + ‘\” +
“, password='” + password + ‘\” +
‘}’;
}
}

JedisTest.java

// 操作 byte
@Test
public void testByte() {
User user = new User();
user.setId(2);
user.setUsername(“zhangsan”);
user.setPassword(“123”);
​
// 序列化
byte[] userKey = SerializeUtil.serialize(“user:” + user.getId());
byte[] userValue = SerializeUtil.serialize(user);
jedis.set(userKey, userValue);
​
// 获取数据
byte[] userResult = jedis.get(userKey);
​
// 反序列化
User u = (User) SerializeUtil.unserialize(userResult);
System.out.println(u);
}

Redis 搭建主从复用

Redis 支持主从复用。数据可以从主服务器向任意数量的从服务器上同步，同步使用的是发布 / 订阅机制。Mater Slave 的模式，从 Slave 向 Master 发起 SYNC 命令。

可以是 1 Master 多 Slave，可以分层，Slave 下可以再接 Slave，可扩展成树状结构。

因为没有两台电脑，所以只能在一台机器上搭建两个 Redis 服务端。

这里使用单机来模拟 redis 主从服务器，实现读写分离配置。

读写分离

创建三个目录（数据文件、日志文件、配置文件）

复制 redis.conf 至 /opt/redis/conf 目录下

修改 redis-common.conf 公共配置文件

注释掉 bind 127.0.0.1

关闭保护模式，修改为 no

注释公共配置端口

修改为后台启动

注释进程编号记录文件

注释公共配置日志文件

注释公共配置数据文件、修改数据文件路径

在默认情况下，Redis 将数据库快照保存在名字为 dump.rdb 的二进制文件中。当然，这里可以通过修改redis.conf 配置文件来对数据存储条件进行定义，规定在“N 秒内数据集至少有 M 个改动”这一条件被满足时, 自动保存一次数据集。也可以通过调用 save 或 bgsave , 手动让 Redis 进行数据集保存操作

dbfilename 和 dir 组合使用，dbfilename 找 dir 路径生成数据文件

添加从服务器访问主服务器认证

添加访问认证

注释公共配置追加文件

根据需求配置是否打开追加文件选项

appendonly yes -> 每当 Redis 执行一个改变数据集的命令时（比如 SET），这个命令就会被追加到 AOF 文件的末尾。这样的话，当 Redis 重新启时，程序就可以通过重新执行 AOF 文件中的命令来达到重建数据集的目的

appendfilename 和 dir 组合使用，找 dir(/opt/redis/data)路径生成数据文件

从服务器默认是只读不允许写操作(不用修改)

添加 3 个服务的私有配置文件

touch或者 vi 都可以创建空白文件

touch直接创建空白文件，vi创建并且进入编辑模式，:wq创建成功，否则不创建

redis-6379.conf

引用公共配置

include /opt/redis/conf/redis-common.conf

进程编号记录文件

pidfile /var/run/redis-6379.pid

进程端口号

port 6379

日志记录文件

logfile “/opt/redis/log/redis-6379.log”

数据记录文件

dbfilename dump-6379.rdb

追加文件名称

appendfilename “appendonly-6379.aof”

下面的配置无需在 6379 里配置

备份服务器从属于 6379 推荐配置配局域网 IP

slaveof 192.168.10.100 6379

复制 redis-6379.conf 的内容至 redis-6380.conf，redis-6381.conf 并且修改其内容，将 6379 替换即可。

运行 3 个 redis 进程

查看 redis 服务器主从状态

redis-6379

redis-6380

redis-6381

在主服务器下添加数据 并测试从服务器数据是否正常显示

从服务器只读，不允许写操作

主备切换

主从节点 redis.conf 配置

参照 读写分离 的相应配置

修改 sentinel-common.conf 哨兵公共配置文件

从 redis 解压目录下复制 sentinel.conf 至 /opt/redis/conf/

cp sentinel.conf /opt/redis/conf/sentinel-common.conf

注释哨兵监听进程端口号

指示 Sentinel 去监视一个名为 master 的主服务器，这个主服务器的 IP 地址为 127.0.0.1，端口号为 6379，而将这个主服务器判断为失效至少需要 1 个 (一般设置为 2 个)。Sentinel 同意（只要同意 Sentinel 的数量不达标，自动故障迁移就不会执行）。

这个要配局域网 IP，否则远程连不上。

设置 master 和 slaves 的密码

Sentinel认为服务器已经断线所需的毫秒数

若 sentinel 在该配置值内未能完成 failover 操作（即故障时 master/slave 自动切换），则认为本次 failover 失败。

关闭保护模式，修改为 no

修改为后台启动

添加 3 个哨兵的私有配置文件

touch或者 vi 都可以创建空白文件

touch直接创建空白文件，vi创建并且进入编辑模式，:wq创建成功，否则不创建

sentinel-26379.conf

引用公共配置

include /opt/redis/conf/sentinel-common.conf

进程端口号

port 26379

进程编号记录文件

pidfile /var/run/sentinel-26379.pid

日志记录文件(为了方便查看日志，先注释掉，搭好环境后再打开)

logfile “/opt/redis/log/sentinel-26379.log”

复制 sentinel-26379.conf 的内容至 sentinel-26380.conf ,sentinel-26381.conf 并且修改其内容，将 26379 替换即可。

启动测试

启动 3 个 redis 服务

/usr/local/redis/bin/redis-server /opt/redis/conf/redis-6379.conf
/usr/local/redis/bin/redis-server /opt/redis/conf/redis-6380.conf
/usr/local/redis/bin/redis-server /opt/redis/conf/redis-6381.conf

启动 3 个哨兵服务

/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26379.conf
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26380.conf
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26381.conf

查看主从状态

redis-6379

redis-6380

redis-6381

检测哨兵功能是否配置成功

kill -9 终止 redis-6379，查看哨兵是否选举了新的主节点

已选举 6380 为主节点，从节点目前只有 6381

重新启动 6379 节点，再次查看主从状态

发现 6379 已被发现且成为从节点

6380 之前不可以写操作，现在可以写操作，因为已成为主节点。

最后，公共配置文件修改为后台启动，私有配置文件打开日志记录文件，环境搭建成功。