默认有三种方式连接redis.
第一种:jedis---传统的项目--ssm
第二种:lettuce:---->刚出现没有多久就被springboot整合进来。
第三种:springboot连接redis
1.1 jedis操作redis服务器
(1)引入jedis依赖
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.3.1</version>
</dependency>
(2)编写相关的代码
1.对String数据类型进行操作
@Test
public void test01() {
//底层使用Jedis(String host, int port)
Jedis jedis = new Jedis("192.168.179.208", 6379);
//该类包含了很多对redis的操作方法 而这些方法和我们原来使用的命令一样
Set<String> keys = jedis.keys("*");
System.out.println(keys);
//对string数据类型操作
String set = jedis.set("k0", "giao华");
System.out.println("set===" + set);
String k0 = jedis.get("k0");
System.out.println("get===" + k0);
//设置失效时间
jedis.setex("k66", 60, "hello giao华");
//删除
jedis.del("k0");
System.out.println("删除--" +k0);
//查看剩余时间
long k66 = jedis.ttl("k66");
System.out.println("剩余时间"+k66);
//测试是否存在
boolean k3 = jedis.exists("k3");
System.out.println(k3);
//不存在,直接存入
long setnx = jedis.setnx("k3", "99");
System.out.println("k3"+setnx);
//指定数值增加数值
long k31 = jedis.incrBy("k3", 1);
String k32 = jedis.get("k3");
System.out.println(k32);
//指定数值减少数值
long k30 = jedis.decrBy("k3", 1);
String k39 = jedis.get("k3");
System.out.println(k39);
jedis.close();
}
2.对hash数据类型进行操作
@Test
public void test02(){
Jedis jedis = new Jedis("192.168.179.208",6379);
//对hash数据类型操作
HashMap<String,String> map = new HashMap<>();
map.put("name","坤坤");
map.put("age","90");
map.put("set","男");
jedis.hset("k22",map);
Map<String, String> k22 = jedis.hgetAll("k22");
System.out.println(k22);
//list队列
jedis.lpush("k33","鸡哥","坤坤","giao华","giao林");
//0开始 -1结束查全部
List<String> list = jedis.lrange("k33", 0, -1);
System.out.println(list);
//获取表中字段的数量
long k33 = jedis.hlen("k33");
System.out.println(k33);
//获取所有给定字段的值
List<String> hmget = jedis.hmget("k33", "name", "age");
System.out.println(hmget);
jedis.close();
}
3.操作list
@Test
public void test04(){
Jedis jedis = new Jedis("192.168.179.208",6379);
//操作list
//添加数据
long lpush = jedis.lpush("k99", "c", "t", "r", "l");
//获取数据
List<String> k99 = jedis.lrange("k99", 0, -1);
System.out.println(k99);
//获取列表长度
long k991 = jedis.llen("k99");
System.out.println(k991);
//获取最后一个元素并移除
String k992 = jedis.rpop("k99");
List<String> k993 = jedis.lrange("k99", 0, -1);
System.out.println(k993);
//通过索引获取列表中的元素
String k994 = jedis.lindex("k99", 3);
System.out.println(k994);
jedis.close();
}
4.操作set集合
@Test
public void test05(){
Jedis jedis = new Jedis("192.168.179.208",6379);
//对 set 集合进行操作
//添加数据
long sadd = jedis.sadd("k88", "a", "b", "c", "d", "e", "f");
long sbdd = jedis.sadd("k77", "e", "f", "c", "d", "a", "f");
System.out.println(sadd);
//取数据
Set<String> k88 = jedis.smembers("k88");
System.out.println(k88);
//取出交集
Set<String> sinter = jedis.sinter("k88", "k77");
System.out.println(sinter);
//返回给定所有集合的差集
Set<String> sdiff = jedis.sdiff("k77", "k88");
System.out.println(sdiff);
jedis.close();
}
5.sortset集合
@Test
public void test06() {
Jedis jedis = new Jedis("192.168.179.208", 6379);
//对 sortset集合进行操作
//添加数据
HashMap<String, Double> hashMap = new HashMap<>();
hashMap.put("kk",11.0);
hashMap.put("jj",22.0);
hashMap.put("jg",33.0);
hashMap.put("kg",66.0);
hashMap.put("ao",80.0);
long k66 = jedis.zadd("k66", hashMap);
System.out.println(k66);
//返回区间之内的
List<String> k661 = jedis.zrange("k66", 0, -1);
System.out.println(k661);
//返回有序集合中指定的成员的排名,有序集合成员分数值递减
Long zrevrank = jedis.zrevrank("k66", "jj");
System.out.println(zrevrank);
//获取有序集合的成员数
long k662 = jedis.zcard("k66");
System.out.println(k662);
//返回有序集中指定区间内的成员,通过索引,分数从高到底
List<String> k663 = jedis.zrevrange("k66", 0, -1);
System.out.println(k663);
jedis.close();
}
每次使用jedis对象时 都需要自己创建,当使用完后,需要关闭该对象。===>jedis中也存在连接池.
1.2 jedis连接池的使用
@Test
public void testpool(){
//连接池的配置信息
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(10);//最多的连接个数
config.setMaxIdle(10);//最多空闲的连接个数
config.setMinIdle(2);//最小的空闲个数
config.setTestOnBorrow(true);//在获取连接对象时是否验证该连接对象的连通性
//创建连接池对象
JedisPool jedisPool = new JedisPool(config,"192.168.179.208",6379);
Jedis jedis = jedisPool.getResource();
//清空当前库
jedis.flushDB();
String set = jedis.set("k3", "v3");
String k3 = jedis.get("k3");
System.out.println(k3);
jedis.close();//归还连接池
}
1.3 测试jedis使用和不使用连接池的效率
@Test
public void test03(){
//连接池的配置信息
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(10);//最多的连接个数
config.setMaxIdle(10);//最多空闲的连接个数
config.setMinIdle(2);//最小的空闲个数
config.setTestOnBorrow(true);//在获取连接对象时是否验证该连接对象的连通性
//创建连接池对象
JedisPool jedisPool = new JedisPool(config,"192.168.179.208",6379);
long start = System.currentTimeMillis();
for (int i=0; i<2000;i++){
Jedis jedis = jedisPool.getResource();
String ping = jedis.ping();
jedis.close();
}
long end = System.currentTimeMillis();
System.out.println("耗时"+(end-start));
}
1.4 springboot整合redis
springboot在整合redis时提高两个模板类,StringRedisTemplate和RedisTemplate.以后对redis的操作都在该模板类中。StringRedisTemplate是RedisTemplate的子类。
<!--redis相关的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
修改配置文件
#redis的配置信息
spring.redis.host=192.168.179.208
spring.redis.port=6379
#最多获取数
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
测试:
@SpringBootTest
class SpringbootRedisApplicationTests {
//因为springboot整合redis时StringRedisTemplate创建并交于spring容器管理
@Autowired
private StringRedisTemplate redisTemplate;
@Test
void contextLoads() {
//操作String
Set<String> keys = redisTemplate.keys("*");//获取所有的key
System.out.println("keys=="+keys);
Boolean k3 = redisTemplate.hasKey("k3");//判断是否存在指定的key
System.out.println("判断是否存k3"+k3);
Boolean key = redisTemplate.delete("k3");//删除指定的key
System.out.println("是否删除指定key成功"+key);
//操作字符串StringRedisTemplate会把对每一种数据的操作单独封装成一个类
ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();//专门操作字符串
opsForValue.set("k1","坤坤");
String k1 = opsForValue.get("k1");
System.out.println("k1===="+k1);
Boolean k2 = opsForValue.setIfAbsent("k2", "giao华");
System.out.println("判断k2是否存入成功"+k2);
//incr decr
Long k31 = opsForValue.increment("k3", 18);
System.out.println("k3===="+k31);
//删除
//可以hash操作
HashOperations<String, Object, Object> opsForHash = redisTemplate.opsForHash();
opsForHash.put("k33","name","坤坤");
opsForHash.put("k33","age","18");
opsForHash.put("k33","sex","男");
Map<String,String> hashMap = new HashMap<>();
hashMap.put("name","giaohua");
hashMap.put("age","23");
hashMap.put("sex","男");
opsForHash.putAll("k23",hashMap);
Map<Object, Object> k11 = opsForHash.entries("k33");
System.out.println(k11);
Set<Object> k12 = opsForHash.keys("k33");
System.out.println(k12);
System.out.println(opsForHash.values("k33"));
}
}
1.5 RedisTemplate
它是StringRedisTemplate的父类,它类可以存储任意数据类型,但是任意类型必须序列化,默认采用的是jdk的序列化方式。jdk序列化方式阅读能力差,而且占用空间大. 我们在使用是一般需要人为指定序列化方式。
@SpringBootTest
class SpringbootRedisApplicationTests2 {
//因为springboot整合redis时StringRedisTemplate创建并交于spring容器管理
@Autowired
private RedisTemplate redisTemplate;
//org.springframework.core.serializer.support.SerializationFailedException
//因为user对象在jvm内存中,--放入redis服务器--持久化到磁盘上。---要该对象的类必须序列化
//key和value都是乱码---因为他们默认采用的序列化方式jdk的序列华方式。但是阅读不方便。我们一般不采用jdk的序列化方式
@Test
void test() {
//redisTemplate.setKeySerializer(new StringRedisSerializer());
//redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
ValueOperations valueOperations = redisTemplate.opsForValue();
valueOperations.set("user",new User(1,"坤坤",18));
Object user = valueOperations.get("user");
System.out.println(user);
}
}
如果每次使用都人为指定序列化方式,统一设置redisTemplate的序列化 (常用,很重要)
@Configuration
public class RedisConfig {
//比如验证码
@Bean //该方法的返回对象交于spring容器管理
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
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);
template.setConnectionFactory(factory);
//key序列化方式
template.setKeySerializer(redisSerializer);
//value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);
//field序列化 key field value
template.setHashKeySerializer(redisSerializer);
return template;
}
}
1.6springboot连接集群
开启集群
配置文件
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
# 设置redis重定向的次数---根据主节点的个数
spring.redis.cluster.max-redirects=3
spring.redis.cluster.nodes=192.168.179.208:7001,192.168.179.208:7002,192.168.179.208:7003,192.168.179.208:7004,192.168.179.208:7005,192.168.179.208:7006
测试
@SpringBootTest
class SpringbootRedisApplicationTests3 {
@Autowired
private RedisTemplate redisTemplate;
@Test
public void test(){
ValueOperations valueOperations = redisTemplate.opsForValue();
valueOperations.set("k1","giaohua");
System.out.println(valueOperations.get("k1"));
}
}
2. redis的应用场景
2.1 redis可以作为缓存
(2)缓存的作用:
减少访问数据库的频率。--提高系统的性能。
(3)什么样的数据适合放入缓存
查询频率高的
修改频率低的
数据安全性要求低的。
(4)如何使用缓存
xml配置
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.12.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.wzt</groupId>
<artifactId>springboot-redis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-redis</name>
<description>springboot-redis</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--redis相关的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>
配置文件
server.port=8888
spring.datasource.url=jdbc:mysql:///student
spring.datasource.password=abc123
spring.datasource.username=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
#redis?????
spring.redis.host=192.168.179.208
spring.redis.port=6379
#?????
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
serverimpl
/**
* @program: springboot-redis2
* @author: 涛
* @create: 2023-04-25 10:48
**/
@Service
public class StudentServerImpl implements StudentServer {
@Resource
private StudentMapper studentMapper;
@Resource
private RedisTemplate<String,Object> redisTemplate;
@Override
public Student getById(Integer sid){
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
//1.查询缓存
Object o = valueOperations.get("student::" + sid);
if (o!=null){//缓存命中
return (Student) o;
}
Student student = studentMapper.selectById(sid);
//2.查到应该放入到缓存
if (student!=null){
valueOperations.set("student::"+sid,student);
}
return student;
}