redis-Java集成Redis
redis整合java，springboot
·
一 Jedis整合redis
1.启动redis
2.引入Jedis依赖
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.1.1</version>
</dependency>
maven引入jedis之后就可在代码中使用jedis对象了
3.Jedis类使用
在Jedis类中数据的操作方法基本上和命令是同名的，返回值类型也是一样的，我们直接调用就可以啦
import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class JedisTest {
public static void main(String[] args) throws InterruptedException {
// 新建Jedis类对象
Jedis jedis = new Jedis("127.0.0.1", 6379);
// 测试Redis连接
System.out.println("redis连接测试：" + jedis.ping());
// 判断某个键是否存在
System.out.println("判断某个键是否存在：" + jedis.exists("mykey"));
// 获取所有的键
Set<String> keys = jedis.keys("*");
System.out.println(keys);
// 根据key去删除键值对
System.out.println("删除键" + jedis.del("mykey"));
/**
* String类型
*/
// 设置一个键值对
jedis.set("mykey1", "myValue1");
jedis.set("mykey2", "myValue2");
jedis.set("mykey3", "myValue3");
// 根据索引获取一个数据的值
System.out.println("得到的数值为：" + jedis.get("mykey2"));
System.out.println("获取多个键值对：" + jedis.mget("mykey1", "mykey2", "mykey3"));
System.out.println("获取mykey1的数据的长度：" + jedis.strlen("mykey1"));
System.out.println("返回key中字符串值的子串：" + jedis.getrange("mykey2", 1, 5));
System.out.println("字符串追加：" + jedis.append("mykey3", "hello"));
System.out.println("获取到mykey3的值：" + jedis.get("mykey3"));
/**
* Hash类型
*/
// 设置一个Hash数据
Map<String, String> valueMap = new HashMap<>();
valueMap.put("name", "huixiaoyuan");
valueMap.put("sex", "男");
valueMap.put("age", "3");
System.out.println("设置一个Hash数据" + jedis.hmset("myHash", valueMap));
System.out.println("获取指定哈希表中所有的字段和值：" + jedis.hgetAll("myHash"));
System.out.println("获取存储在哈希表中指定字段的值:" + jedis.hget("myHash", "name"));
System.out.println("删除一个或多个哈希表字段:" + jedis.hdel("myHash", "sex"));
System.out.println("获取哈希表中字段的数量：" + jedis.hlen("myHash"));
/**
* List类型
*/
System.out.println("将一个或多个元素插入列表表头:" + jedis.lpush("myList", "l1", "l2", "l3"));
System.out.println("将一个或多个元素插入列表尾部:" + jedis.rpush("myList", "l4"));
System.out.println("获取列表长度:" + jedis.llen("myList"));
System.out.println("通过索引获取列表中的元素:" + jedis.lindex("myList", 2));
System.out.println("移除并获取列表第一个元素:" + jedis.lpop("myList"));
System.out.println("移除并获取列表最后一个元素:" + jedis.rpop("myList"));
/**
* Hash类型
*/
System.out.println("设置一个Hash数据" + jedis.hmset("myHash", valueMap));
System.out.println("获取指定哈希表中所有的字段和值：" + jedis.hgetAll("myHash"));
System.out.println("获取存储在哈希表中指定字段的值:" + jedis.hget("myHash", "name"));
System.out.println("删除一个或多个哈希表字段:" + jedis.hdel("myHash", "sex"));
System.out.println("获取哈希表中字段的数量：" + jedis.hlen("myHash"));
/**
* Set类型
*/
System.out.println("向集合中添加一个或多个成员:" + jedis.sadd("mySet","s1","s2","s3"));
System.out.println("向集合中添加一个或多个成员:" + jedis.sadd("mySet2","s3","s4","s5"));
System.out.println("获取集合中成员的个数:" + jedis.scard("mySet"));
System.out.println("返回第一个集合与其他集合之间的差异:" + jedis.sdiff("mySet","mySet2"));
System.out.println("返回集合中的所有元素:" + jedis.smembers("mySet"));
/**
*ZSet类型
*/
System.out.println("向有序集合中添加一个或多个成员:" + jedis.zadd("myZset",1,"m1"));
System.out.println("向有序集合中添加一个或多个成员:" + jedis.zadd("myZset",2,"m2"));
System.out.println("向有序集合中添加一个或多个成员:" + jedis.zadd("myZset",3,"m3"));
System.out.println("获取有序集合的成员数:" + jedis.zcard("myZset"));
System.out.println("计算有序集合中指定区间分数的成员数:" + jedis.zcount("myZset",0,2));
System.out.println("移除有序集合中的一个或多个元素:" + jedis.zrem("myZset","m2"));
}
}
输出
com.msb.spring.redis.demo.JedisTest
redis连接测试：PONG
判断某个键是否存在：false
[myHash, mykey3, mykey2, mySet2, mykey1, mySet, myList, myZset]
删除键0
得到的数值为：myValue2
获取多个键值对：[myValue1, myValue2, myValue3]
获取mykey1的数据的长度：8
返回key中字符串值的子串：yValu
字符串追加：13
获取到mykey3的值：myValue3hello
设置一个Hash数据OK
获取指定哈希表中所有的字段和值：{name=huixiaoyuan, age=3, sex=男}
获取存储在哈希表中指定字段的值:huixiaoyuan
删除一个或多个哈希表字段:1
获取哈希表中字段的数量：2
将一个或多个元素插入列表表头:7
将一个或多个元素插入列表尾部:8
获取列表长度:8
通过索引获取列表中的元素:l1
移除并获取列表第一个元素:l3
移除并获取列表最后一个元素:l4
设置一个Hash数据OK
获取指定哈希表中所有的字段和值：{name=huixiaoyuan, age=3, sex=男}
获取存储在哈希表中指定字段的值:huixiaoyuan
删除一个或多个哈希表字段:1
获取哈希表中字段的数量：2
向集合中添加一个或多个成员:0
向集合中添加一个或多个成员:0
获取集合中成员的个数:3
返回第一个集合与其他集合之间的差异:[s1, s2]
返回集合中的所有元素:[s3, s1, s2]
向有序集合中添加一个或多个成员:0
向有序集合中添加一个或多个成员:1
向有序集合中添加一个或多个成员:0
获取有序集合的成员数:3
计算有序集合中指定区间分数的成员数:2
移除有序集合中的一个或多个元素:1
Process finished with exit code 0
二 SpringBoot 整合redis
1.启动redis
2.引入redis依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
3.application,yml
配置文件
##redis配置信息
spring:
redis:
database: 0 #redis数据库索引，默认为0
host: 127.0.0.1 #redis服务器地址
port: 6379 #redis服务器连接端口
# password: #redis服务器连接密码，默认为null
timeout: 5000 #redis连接超时时间
# ******** 如果不使用连接池，那么下面这部分可省略不写 ********
jedis:
pool: #连接池配置
max-active: 8 #连接池最大连接数
max-wait: -1 #连接池最大阻塞等待时间
max-idle: 8 #连接池中的最大空闲连接数
min-idle: 0 #连接池中的最小空闲连接数
配置完成之后可以使用RedisTemplate来操作redis
package com.spring.redis.demo;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestComponent;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
@Component
class SpringbootredisApplicationTests {
@Autowired
private StringRedisTemplate stringRedisTemplate;
//@Autowired
//private RedisTemplate redisTemplate;
@Autowired
private RedisTemplate redisTemplate;
/**
* 使用redisTemplate操作
*/
public void redisTest07() {
System.out.println("redisTemplate集成测试");
redisTemplate.opsForValue().set("姓名","灰小猿");
System.out.println("获取到的姓名：" + redisTemplate.opsForValue().get("姓名"));
// 数据库操作
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
// 清空当前数据库
// connection.flushDb();
// 清空所有数据库
// connection.flushAll();
}
public void redisTest08() {
User user = new User("灰小猿", 5);
redisTemplate.opsForValue().set("user", user);
System.out.println("获取到的数值：");
System.out.println(redisTemplate.opsForValue().get("user"));
}
}
运行该类
package com.msb.spring.redis.demo;
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 int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.msb.spring.redis.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);
//TestRedis redis = ctx.getBean(TestRedis.class);
//redis.testRedis();
SpringbootredisApplicationTests springbootredisApplicationTests
=ctx.getBean(SpringbootredisApplicationTests.class);
//springbootredisApplicationTests.redisTest07();
springbootredisApplicationTests.redisTest08();
}
//
//{"name":"灰小猿","age":5}
}
输出
User{name='灰小猿', age=5}
我们可以看到现在Redis是以默认的JBK的方式进行序列化的。得到的结果如上。
但是现在的项目更多的是采用的前后端分离的方式进行的，数据的传输一般都是以JSON的形式，尤其是对象的传输，
原因是：JSON 语法格式简单、层次结构清晰、并且在数据交换方面，JSON 所使用的字符要比 XML 少得多，可以大大得节约传输数据所占用的带宽。
所以对于Redis中的数据，在实际开发中，我们一般也会将其存储为JSON的形式，这个时候就需要我们通过自定义redisTemplate的方式将Redis默认的序列化方式改为JSON的形式，
自定义RedisTemplate
自定义redisTemplate的方法是：新建一个配置类RedisConfig，在其中注入一个Bean，并实现自定义的序列化方法。
package com.msb.spring.redis.demo;
import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
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.StringRedisSerializer;
@Configuration
public class RedisConfig {
@Bean("redisTemplate")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
// 为了开发方便，一般都使用<String, Object>类型
RedisTemplate<String, Object> template = new RedisTemplate();
// 连接工厂
template.setConnectionFactory(factory);
// 序列化配置
FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer(Object.class);
// value值的序列化采用FastJsonRedisSerializer
template.setValueSerializer(fastJsonRedisSerializer);
// hash值的序列化采用FastJsonRedisSerializer的方式
template.setHashValueSerializer(fastJsonRedisSerializer);
// key的序列化采用StringRedisSerializer
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
template.setKeySerializer(stringRedisSerializer);
// hash的key的序列化采用StringRedisSerializer的方式
template.setHashKeySerializer(stringRedisSerializer);
return template;
}
}
重新打印user
package com.msb.spring.redis.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);
//TestRedis redis = ctx.getBean(TestRedis.class);
//redis.testRedis();
SpringbootredisApplicationTests springbootredisApplicationTests
=ctx.getBean(SpringbootredisApplicationTests.class);
//springbootredisApplicationTests.redisTest07();
springbootredisApplicationTests.redisTest08();
}
//User{name='灰小猿', age=5}
//{"name":"灰小猿","age":5}
}
{“name”:“灰小猿”,“age”:5}
json格式，可以发现明显与默认的存储方法不同，现在我们存储在Redis中的对象，就会自动以JSON的方式进行序列化并存储啦！
RedisTemplate和StringRedisTemplate有以下的区别：
StringRedisTemplate继承自RedisTemplate。
两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。
SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。
RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。
那么应该在什么时候使用RedisTemplate，什么时候使用StringRedisTemplate呢？
当你的redis数据库里面本来存的就是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可。
但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。
除此之外两者在操作上都是一样的，StringRedisTemplate对应了操作五种数据类型的方法，而且操作和stringRedis一样，
stringRedisTemplate.opsForValue(); 对应String类型操作
stringRedisTemplate.opsForHash(); 对应Hash类型操作
stringRedisTemplate.opsForList(); 对应List类型操作
stringRedisTemplate.opsForSet(); 对应Set类型操作
stringRedisTemplate.opsForZSet(); 对应ZSet类型操作
Jedis适合在没有spring系列框架的普通Java工程中使用
RedisTemplate适合在多种数据类型的项目，且希望自动进行数据转换的情况下使用
StringRedisTemplate适合在只有字符串处理的情况下使用
华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。
更多推荐
2
0- 0
已为社区贡献7条内容
所有评论(0)