Redis入门及java操作redis的5种数据类型

Redis

一、redis是什么

redis是一个开源的，用c语言编写的，支持网络、基于内存的可持久化、日志型、key-value型非关系型数据库并提供多种语言的 API。no-sql 型的数据库

二、redis的优点及使用场景

因为是非关系型数据库，切基于内存，所以读写速度非常的快

下面是官方的 bench-mark 数据：
测试完成了 50 个并发执行 100000 个请求。
设置和获取的值是一个 256 字节字符串。
结果:读的速度是 110000 次/s,写的速度是 81000 次/s

支持多种语言

[外链图片转存失败(img-S3L74XFr-1566285121417)(C:\Users\ADMINI~1\AppData\Local\Temp\1566222346134.png)]

支持的数据类型

string、hash、list、set、sorted set(有序列表)

三、java操作redis

1、首先创建一个maven的quickstart项目

[外链图片转存失败(img-PzLdGYj5-1566285121421)(C:\Users\ADMINI~1\AppData\Local\Temp\1566222648113.png)]

2.添加依赖

[外链图片转存失败(img-jxyA8tFw-1566285121429)(C:\Users\ADMINI~1\AppData\Local\Temp\1566222628339.png)]

<!-- Redis 依赖 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>

3.通过jedis实现连接redis的工具类

package com.shsxt.util;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* 实例化 Jedis 对象工具类
*/
public final class JedisUtil {
//Redis 服务器 IP
private static String ADDR = "192.168.10.100";
//Redis 的端口号
private static int PORT = 6379;
// 访问密码
private static String AUTH = "root";
// 可用连接实例的最大数目，默认值为 8 ；
// 如果赋值为 -1 ，则表示不限制；如果 pool 已经分配了 maxActive 个 jedis 实例，则
此时 pool 的状态为 exhausted( 耗尽 ) 。
private static int MAX_ACTIVE = 1024;
// 控制一个 pool 最多有多少个状态为 idle( 空闲的 ) 的 jedis 实例，默认值也是 8 。
private static int MAX_IDLE = 200;
// 等待可用连接的最大时间，单位毫秒，默认值为 -1 ，表示永不超时。如果超过等待时
间，则直接抛出 JedisConnectionException ；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
// 在 borrow 一个 jedis 实例时，是否提前进行 validate 操作；如果为 true ，则得到
的 jedis 实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
/**
* 初始化 Redis 连接池
*/
static {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
 config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取 Jedis 实例
*
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null)
return jedisPool.getResource();
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 释放 jedis 资源
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.close();
}
}
}

4.Java 操作 s Redis 五种数据

Jedis jedis = null;
/**
 * 连接 Redis
*/
@Before
public void initConn() {
jedis = JedisUtil.getJedis();
}
------------------------------------------------------------------------------------------------
// 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");
}

------------------------------------------------------------------------------------------------
// 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");
}
------------------------------------------------------------------------------------------------
// 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");
}

------------------------------------------------------------------------------------------------
/**
* 释放资源
*/
@After
public void close() {
JedisUtil.returnResource(jedis);
}

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

// Redis 中以层级关系、目录形式存储数据
jedis.set("user:01", "user_zhangsan");
System.out.println(jedis.get("user:01"));

6.设置 key 的失效时间

Redis 有四个不同的命令可以用于设置键的生存时间(键可以存在多久)或过期时间(键什么
时候会被删除) :
 EXPlRE 命令用于将键 key 的生存时间设置为 ttl 秒。
 PEXPIRE 命令用于将键 key 的生存时间设置为 ttl 毫秒。
 EXPIREAT < timestamp> 命令用于将键 key 的过期时间设置为 timestamp 所指
定的秒数时间戳。
 PEXPIREAT < 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");// 获取毫秒
// 方法三：
/*
第一个参数： key
第二个参数： value
第三个参数： NX 是不存在时才 set ， XX 是存在时才 set
第四个参数： EX 是秒， PX 是毫秒
*/
jedis.set("asd", "test", "NX", "EX", 180);
jedis.ttl("code");// 获取秒
}

7.获取所有 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");
}

8.操作 byte

序列化和反序列化工具类

package com.shsxt.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类

package com.shsxt.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 + '\'' +
'}';
}
}

存入二进制数据到ruedis/从redis读取二进制数据

// 操作 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);
}

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