mysql学完命令之后，学过jdbc。
redis也要使用Java连接redis数据库
1.Jedis
2.RedisTemplate[重点]
1、Jedis【了解】
jedis是redis的java版本的客户端实现，jedis中提供了针对redis命令的操作
1.1导入jar文件
Maven方式
<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.3.0</version> </dependency>
测试
入门案例
package com.qf.day63_redis.jedis;
import redis.clients.jedis.Jedis;
/**
* ---厚德载物---
*
* @Author wangbo
* @Date 2024/10/11
* @Desc 人的一生适可而止
*/
public class App {
public static void main(String[] args) {
//1.创建jedis对象
Jedis jedis = new Jedis("127.0.0.1", 6379);
System.out.println(jedis);
//2.设置一个数据
jedis.set("likeNum", "100");
//.3获取数据
String s = jedis.get("likeNum");
System.out.println(s);
}
}
像一个问题？ windows版本的redis 启动时候默认是没有密码的
如何设置密码启动？
1.找到redis.window.conf
找到503行 requirepass root(自己定义的密码)
2.启动 使用命令启动
redis-server redis.windows.conf
package com.qf.day63_redis.jedis;
import redis.clients.jedis.Jedis;
/**
* ---厚德载物---
*
* @Author wangbo
* @Date 2024/10/11
* @Desc 人的一生适可而止
*/
public class App {
public static void main(String[] args) {
//1.创建jedis对象
Jedis jedis = new Jedis("127.0.0.1", 6379);
//1.1设置密码 如果有密码启动的时候 才取设置的！！！
jedis.auth("root");
System.out.println(jedis);
//2.设置一个数据
jedis.set("likeNum", "100");
//.3获取数据
String s = jedis.get("likeNum");
System.out.println(s);
}
}
1.2JedisPool
Jedis对象并不是线程安全的，在多线程下使用同一个Jedis对象会出现并发问题。为了避免每次使用Jedis对象时都需要重新构建，Jedis提供了JedisPool。JedisPool是基于Commons Pool 2实现的一个线程安全的连接池。如果使用jedis连接池，需要commons-pool2的jar包
package com.qf.day63_redis.jedis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* ---厚德载物---
*
* @Author wangbo
* @Date 2024/10/11
* @Desc 人的一生适可而止
*/
public class JedisUtils {
//1.声明连接池的对象
private static JedisPool jedisPool = null;
static {
//2.创建redisPool连接池的配置对象
JedisPoolConfig config = new JedisPoolConfig();
//最多与多少个jedis对象
config.setMaxTotal(50);
//最多有多少空闲的jedis对象
config.setMaxIdle(20);
//最大等待时间
config.setMaxWaitMillis(5000);
//检查连接的有效性
config.setTestOnBorrow(true);
//第二个参数：redis服务器的ip
//第三个参数：端口
//第四个参数：连接服务器的超时时间
//第五个参数：密码
//创建redis连接池对象
jedisPool = new JedisPool(config, "127.0.0.1", 6379, 1000, "root");
}
//封装好一个方法，获取Jedis对象
public static Jedis getJedis() {
Jedis jedis = jedisPool.getResource();
return jedis;
}
//jedis放回池子中
public static void close(Jedis jedis) {
jedis.close();//
}
}
2、在springboot 中集成redis
2.1RedisTemplate
spring-data-redis的jar中，提供在spring应用中通过简单的配置访问redis服务的功能，它对reids底层开发包进行了高度封装。
针对reids的操作，包中提供了RedisTemplate类和StringRedisTemplate类，其中StringRedisTemplate是RedisTemplate的子类，该类只支持key和value为String的操作
2.2主要封装接口
RedisTemplate针对不同数据类型的操作进行封装，将同一类型操作封装为Operation接口
ValueOperations：简单K-V操作，获取方式 redisTemplate.opsForValue();
SetOperations：set类型数据操作，获取方式 redisTemplate.opsForSet();
ZSetOperations：zset类型数据操作，获取方式 redisTemplate.opsForZSet();
HashOperations：针对hash类型的数据操作， 获取方式 redisTemplate.opsForHash();
ListOperations：针对list类型的数据操作，获取方式 redisTemplate.opsForList();
2.3序列化策略
StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。
RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。
GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer实际上是一样的
JacksonJsonRedisSerializer: 序列化object对象为json字符串
JdkSerializationRedisSerializer: 序列化java对象（被序列化的对象必须实现Serializable接口）
StringRedisSerializer: 简单的字符串序列化
GenericToStringSerializer:类似StringRedisSerializer的字符串序列化
GenericJackson2JsonRedisSerializer:类似Jackson2JsonRedisSerializer，但使用时构造函数不用特定的类
【注意】： 存储数据的时候指定 序列化策略
2.4导入jar
<!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- pool 对象池 --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency>
在SpringBoot 1.5.x版本默认的Redis客户端是Jedis实现的，SpringBoot 2.x版本默认客户端是用lettuce实现的
2.5yml中配置
# redis 配置 spring: redis: # 地址 host: 127.0.0.1 # 端口，默认为6379 port: 6379 # 数据库索引 database: 0 # 密码 password: root # 连接超时时间 timeout: 10s lettuce: pool: # 连接池中的最小空闲连接 min-idle: 0 # 连接池中的最大空闲连接 max-idle: 8 # 连接池的最大数据库连接数 max-active: 8 # #连接池最大阻塞等待时间（使用负值表示没有限制） max-wait: -1ms
2.6redis配置类
SpringBoot自动在容器中创建了RedisTemplate对象和StringRedisTemplate对象。但是，RedisTemplate的泛型是<Object,Object>，进行数据处理时比价麻烦，我们需要自定义一个RedisTemplate对象
package com.qf.day63_redis.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import javax.annotation.Resource;
/**
* ---厚德载物---
*
* @Author wangbo
* @Date 2024/10/11
* @Desc 人的一生适可而止
*/
@Configuration
public class RedisConfig {
@Resource
//lettuceConnectionFactory 创建lettuce对象的
private LettuceConnectionFactory lettuceConnectionFactory;
//自定义redisTemplate对象
@Bean
public RedisTemplate<String,Object> redisTemplate() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
//key采用String的序列化方式
redisTemplate.setKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
// hash的key也采用String的序列化方式
redisTemplate.setHashKeySerializer(stringRedisSerializer);
// hash的value序列化方式采用jackson
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setConnectionFactory(lettuceConnectionFactory);
return redisTemplate;
}
}
直接测试
package com.qf.day63_redis;
import com.qf.day63_redis.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
@SpringBootTest
class Day63RedisApplicationTests {
@Resource
private RedisTemplate<String, Object> redisTemplate;
@Test
void contextLoads() {
redisTemplate.opsForValue().set("viewNum", 1000);
Integer num = (Integer)redisTemplate.opsForValue().get("viewNum");
System.out.println(num);
}
@Test
void test1 () {
User user = new User();
user.setName("狗蛋");
user.setAge(21);
redisTemplate.opsForValue().set("user", user);
//{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋","age":21}
}
@Test
void test2 () {
User user = new User();
user.setName("狗蛋");
user.setAge(21);
User user1 = new User();
user1.setName("狗蛋1");
user1.setAge(22);
User user2 = new User();
user2.setName("狗蛋2");
user2.setAge(22);
List<User> list = new ArrayList<>();
list.add(user);
list.add(user1);
list.add(user2);
redisTemplate.opsForValue().set("userList", list);
List<User> list1 = (List<User>)redisTemplate.opsForValue().get("userList");
System.out.println(list1);
//
//["java.util.ArrayList",[{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋","age":21},{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋1","age":22},{"@class":"com.qf.day63_redis.entity.User","name":"狗蛋2","age":22}]]
}
}
发现对redis数据库操作的时候，还得写ops方法 再根set get del 操作
有一个想法，把这些操作封装到 一个类中，直接使用类调用方法即可
RedisUtils工具类
工具类的第一种写法：
package com.qf.day63_redis.utils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* ---厚德载物---
*
* @Author wangbo
* @Date 2024/10/11
* @Desc 人的一生适可而止
*/
@Component//把工具类放到了容器中了
public class RedisUtils {
@Resource
private RedisTemplate<String, Object> redisTemplate;//直接注入
public static void setValue (String key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
}
使用
@Test
void test4 () {
User user1 = new User();
user1.setName("狗蛋1");
user1.setAge(22);
redisUtils.setValue("user1", user1);
}
工具类的第二种写法：
就是方法中加了static修饰符 无法 在RedisUtils中注入redisTemplate的对象的
只能借助于一个叫SpringBeanUtils 自己写的工具类型
package com.qf.day63_redis.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
*---厚德载物---
*@Author wangbo
*@Date 2024/10/11
*@Desc
* 人的一生适可而止
*
*/
@Component
public class SpringBeanUtils implements ApplicationContextAware {
/**
* Spring应用上下文对象
*/
private static ApplicationContext applicationContext = null;
/**
* 注入上下文对象
*
* @param applicationContext
* @throws BeansException
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringBeanUtils.applicationContext = applicationContext;
}
/**
* 根据名称获取bean对象
*
* @param name
* @param <T>
* @return
* @throws BeansException
*/
public static <T> T getBean(String name) {
return (T) applicationContext.getBean(name);
}
/**
* 根据类型获取bean对象
*
* @param clz
* @param <T>
* @return
*/
public static <T> T getBean(Class<T> clz) {
T result = (T) applicationContext.getBean(clz);
return result;
}
}
第二种写法的工具类
package com.qf.day63_redis.utils;
import org.springframework.data.redis.core.RedisTemplate;
/**
* ---厚德载物---
*
* @Author wangbo
* @Date 2024/10/11
* @Desc 人的一生适可而止
*/
public class RedisUtils1 {
//不要使用@Resource注入redisTemplate这个对象了
//但是需要redisTemplate对象 咋办？ 写一个工具类 获取bean对象的工具类
private static RedisTemplate<String , Object> redisTemplate = SpringBeanUtils.getBean("redisTemplate");
public static void setValue (String key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
}
测试
@Test
void test5 () {
User user1 = new User();
user1.setName("xixi");
user1.setAge(25);
RedisUtils1.setValue("user2", user1);
}
项目中杂加redis
1.导包
2.yml文件
2.配置类
3.工具类型
以上全部黏贴复制！！！！