JRedis
参考
JavaWeb——（17）Redis和Jedis_javaweb jedis工具类-CSDN博客
(48条消息) 使用Java操作Redis_一心同学的博客-CSDN博客_java操作redis
(48条消息) Jedis常用方法_雨后浅浅唱的博客-CSDN博客_jedis方法
目录
前言
一、准备步骤
二、Jedis连接Redis
三、基本操作
3.1 操作String数据类型
3.2 操作List数据类型
3.3 事务操作
四、SpringBoot集成Redis
4.1 介绍
4.2 集成Redis
4.3 保存对象
一、准备步骤
修改配置文件redis.conf:
（1）注释以下属性，因为我们是需要进行远程连接的：
（2）将protected-mode 设置为no
（3）设置为允许后台连接
注意：
在远程服务器进行连接需要确保将以下三个步骤都完成：
（1）设置服务器的安全组开放6379端口
（2）防火墙开放端口：
firewall-cmd --zone=public --add-port=6379/tcp --permanet
|
（3）重启防火墙：
systemctl restart firewalld.service
|
二、Jedis连接Redis
（1）创建一个Maven项目，并导入以下依赖：
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.62</version>
</dependency>
</dependencies>
|
（2）测试连接：
package com.yixin;
import redis.clients.jedis.Jedis;
public class RedisTest {
public static void main(String[] args) {
//连接本地的 Redis 服务
Jedis jedis = new Jedis("服务器地址", 6379);
String response = jedis.ping();
System.out.println(response); // PONG
}
}
|
看到PONG说明我们成功连接上了我们服务器上的Redis了！
三、基本操作
3.1 操作String数据类型
package com.yixin;
import redis.clients.jedis.Jedis;
import java.util.Set;
public class Redis_String {
public static void main(String[] args) {
//连接本地的 Redis 服务
Jedis jedis = new Jedis("服务器地址", 6379);
String response = jedis.ping();
System.out.println(response); // PONG
//删除当前选择数据库中的所有key
System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());
//Spring实例
//设置 redis 字符串数据
//新增<'name','yixin'>的键值对
jedis.set("name", "yixin");
// 获取存储的数据并输出
System.out.println("redis 存储的字符串为: "+ jedis.get("name"));
//判断某个键是否存在
System.out.println("判断某个键是否存在："+jedis.exists("name"));
//系统中所有的键
Set<String> keys = jedis.keys("*");
System.out.println(keys);
//按索引查询
System.out.println("按索引查询："+jedis.select(0));
//查看键name所存储的值的类型
System.out.println("查看键name所存储的值的类型："+jedis.type("name"));
// 随机返回key空间的一个
System.out.println("随机返回key空间的一个："+jedis.randomKey());
//重命名key
System.out.println("重命名key："+jedis.rename("name","username"));
System.out.println("取出改后的name："+jedis.get("username"));
//删除键username
System.out.println("删除键username:"+jedis.del("username"));
//删除当前选择数据库中的所有key
System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());
//查看当前数据库中key的数目
System.out.println("返回当前数据库中key的数目："+jedis.dbSize());
//删除数据库中的所有key
System.out.println("删除所有数据库中的所有key："+jedis.flushAll());
}
}
|
3.2 操作List数据类型
package com.yixin;
import redis.clients.jedis.Jedis;
import java.util.List;
public class Redis_List {
public static void main(String[] args) {
//连接本地的 Redis 服务
Jedis jedis = new Jedis("服务器地址", 6379);
String response = jedis.ping();
System.out.println(response); // PONG
System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());
//List实例
//存储数据到列表中
jedis.lpush("list", "num1");
jedis.lpush("list", "num2");
jedis.lpush("list", "num3");
// 获取存储的数据并输出
List<String> list = jedis.lrange("list", 0 ,-1);
for(int i=0; i<list.size(); i++) {
System.out.println("列表项为: "+list.get(i));
}
}
}
|
3.3 事务操作
package com.yixin;
import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
public class Redis_Transaction {
public static void main(String[] args) {
//连接本地的 Redis 服务
Jedis jedis = new Jedis("服务器地址", 6379);
String response = jedis.ping();
System.out.println(response); // PONG
//事务测试
jedis.flushDB();
JSONObject jsonObject = new JSONObject();
jsonObject.put("hello","world");
jsonObject.put("name","yixin");
//开启事务
Transaction multi = jedis.multi();
String result = jsonObject.toJSONString();
// jedis.watch(result)
try {
multi.set("user1", result);
multi.set("user2", result);
int i = 1 / 0; // 代码抛出异常事务，执行失败！
multi.exec(); // 执行事务！
}catch (Exception e){
multi.discard();// 放弃事务
e.printStackTrace();
}finally {
System.out.println(jedis.get("user1"));
System.out.println(jedis.get("user2"));
jedis.close();
}
}
}
|
四、SpringBoot集成Redis
4.1 介绍
这次我们并不使用jedis来进行连接，而是使用lettuce来进行连接，jedis和lettuce的对比如下：
jedis：采用的直连，多个线程操作的话，是不安全的；想要避免不安全，使用jedis pool连接池。更像BIO模式
lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况；可以减少线程数量。更像NIO模式
4.2 集成Redis
（1）创建Spring Boot项目
（2）导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
（3）编写配置文件
application.properties:
#配置redis
# Redis服务器地址
spring.redis.host=服务器地址
# Redis服务器连接端口
spring.redis.port=6379
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0
|
（4）编写测试类
package com.yixin;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
@SpringBootTest
class SpringbootRedisApplicationTests {
@Autowired
private RedisTemplate<String,String> redisTemplate;
@Test
void contextLoads() {
redisTemplate.opsForValue().set("name","yixin");
System.out.println(redisTemplate.opsForValue().get("name"));
}
}
|
在这种连接方式中，redisTemplate操作着不同的数据类型，api和我们的指令是一样的。
opsForValue：操作字符串 类似String
opsForList：操作List 类似List
opsForSet：操作Set，类似Set
opsForHash：操作Hash
opsForZSet：操作ZSet
opsForGeo：操作Geospatial
opsForHyperLogLog:操作HyperLogLog
|
除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务，和基本的CRUD。
4.3 保存对象
（1）编写实体类
注意：要实现序列号Serializable。
package com.yixin.pojo;
import java.io.Serializable;
public class User implements Serializable {
private String name;
private int age;
public User(){
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
|
（2）编写RedsTemplate配置
Tip:在开发当中，我们可以直接把这个模板拿去使用。
package com.yixin.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
//为了自己开发方便，一般直接使用 <String, Object>
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
// Json序列化配置
Jackson2JsonRedisSerializer 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);
// String 的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
|
（3）存储对象
package com.yixin;
import com.yixin.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
@SpringBootTest
class SpringbootRedisApplicationTests {
@Autowired
private RedisTemplate<String,Object> redisTemplate;
@Test
void contextLoads() {
User user=new User("yixin",18);
redisTemplate.opsForValue().set("user",user);
System.out.println(redisTemplate.opsForValue().get("user"));
}
}
|
