基本信息
spring 封装了 RedisTemplate 对象来进行对redis的各种操作，它支持所有的 redis 原生的 api。
操作系统:windows10
IDE:IDEA2019
project:spring-boot
Maven依赖
<!--RedisTemplate 依赖-->
<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>
<!--spring-boot-web启动器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--JSON 数据转换支持-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
yml配置文件
# 配置服务应用端口
server:
port: 8080
spring:
jmx:
enabled: false
redis:
## Redis数据库索引（默认为0）
database: 0
## Redis服务器地址
host: 127.0.0.1
## Redis服务器连接端口
port: 6379
## Redis服务器连接密码（默认为空）
password:
database-osp: 0
host-osp: 127.0.0.1
port-osp: 6379
password-osp:
lettuce:
pool:
## 连接池最大连接数（使用负值表示没有限制）
max-active: 60
## 连接池最大阻塞等待时间（使用负值表示没有限制）
max-wait: -1ms
## 连接池中的最大空闲连接
max-idle: 20
## 连接池中的最小空闲连接
min-idle: 8
## 连接超时时间（毫秒）
timeout: 300000ms
rest:
# restTemplate 超时配置
connect-timeout: 60000
read-timeout: 60000
pool-connect-timeout: 60000
redisConfig配置类
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
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.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
//设置序列化
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer<Object> jacksonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
//指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonRedisSerializer.setObjectMapper(om);
//配置redisTemplate
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 配置连接工厂
template.setConnectionFactory(factory);
//String类的序列化方式
RedisSerializer stringSerializer = new StringRedisSerializer();
template.setKeySerializer(stringSerializer);//key序列化
template.setValueSerializer(jacksonRedisSerializer);//value序列化
template.setHashKeySerializer(stringSerializer);//Hash key序列化
template.setHashValueSerializer(jacksonRedisSerializer);//Hash value序列化
template.afterPropertiesSet();
return template;
}
@Bean
@ConditionalOnMissingBean(StringRedisTemplate.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(factory);
return template;
}
}
Redis操作string
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* explain: RedisTemplate操作string
* public interface ValueOperations<K,V>
* Redis operations for simple (or in Redis terminology 'string') values.
* ValueOperations可以对String数据结构进行操作
*/
@RestController
@RequestMapping(value = "redisTemplate", produces = "application/json;charset=UTF-8")
public class RedisOperateString {
@Autowired
RedisTemplate<String, Object> redisTemplate;
/**
* RedisTemplate操作string
*/
@GetMapping("/operateString")
private String operateString() {
ValueOperations<String, Object> opsForValue = redisTemplate.opsForValue();
//清空redis
deleteAllKey();
//void set(K key, V value);
opsForValue.set("key1", "cat");
System.out.println(opsForValue.get("key1"));
//void set(K key, V value, long timeout, TimeUnit unit);
//由于设置的是10秒失效，十秒之内查询有结果，十秒之后返回为null
opsForValue.set("key2", "tom", 10, TimeUnit.SECONDS);
Object key2 = opsForValue.get("key2");
System.out.println(key2);
// multiSet void multiSet(Map<? extends K, ? extends V> m);为多个键分别设置它们的值
Map<String, String> maps = new HashMap<>();
maps.put("multiKey1", "multi11");
maps.put("multiKey2", "multi22");
maps.put("multiKey3", "multi33");
opsForValue.multiSet(maps);
Set<String> keyList = maps.keySet();
// List<String> keyList = new ArrayList<>(maps.keySet());
List<Object> list = opsForValue.multiGet(keyList);
System.out.println(list);
// getAndSet V getAndSet(K key, V value); 设置键的字符串值并返回其旧值
opsForValue.set("multiKey4", "multi44");
System.out.println(opsForValue.getAndSet("multiKey4", "multi"));
// multiSetIfAbsent Boolean multiSetIfAbsent(Map<? extends K, ? extends V> m);
// 为多个键分别设置它们的值，如果存在则返回false，不存在返回true
Boolean aBoolean = opsForValue.multiSetIfAbsent(maps);
System.out.println(aBoolean);
// multiGet List<V> multiGet(Collection<K> keys);为多个键分别取出它们的值
ArrayList<String> keyLists = new ArrayList<>();
keyLists.add("key1");
keyLists.add("key2");
keyLists.add("multiKey1");
keyLists.add("multiKey2");
keyLists.add("multiKey3");
keyLists.add("multiKey4");
List<Object> objects = opsForValue.multiGet(keyLists);
System.out.println(objects);
// increment Long increment(K key, long delta);支持整数
Long longKey = opsForValue.increment("longKey", 99);
System.out.println(longKey);
System.out.println(opsForValue.get("longKey"));
// increment Double increment(K key, double delta);也支持浮点数
Double doubleKey = opsForValue.increment("doubleKey", 99.99);
System.out.println(doubleKey);
System.out.println(opsForValue.get("doubleKey"));
// append Integer append(K key, String value);
// 如果key已经存在并且是一个字符串，则该命令将该值追加到字符串的末尾。
// 如果键不存在，则它被创建并设置为空字符串，因此APPEND在这种特殊情况下将类似于SET。
// append()这里redisConfig使用jacksonRedisSerializer序列化方式时会出现序列化失败的情况,导致无法获取value
opsForValue.append("appendKye", "hello");
opsForValue.append("appendKye", "world ");
Object appendKye = opsForValue.get("appendKye");
System.out.println(appendKye);
// get String get(K key, long start, long end);截取key所对应的value字符串
opsForValue.set("key4", "HelloWorld");
System.out.println(opsForValue.get("key4", 0, 4));
System.out.println(opsForValue.get("key4", 0, -1));
System.out.println(opsForValue.get("key4", 0, -6));
// size Long size(K key); 返回key所对应的value值得长度
Long key4 = opsForValue.size("key4");
System.out.println(key4);
return "method completed ok";
}
/**
* 删除redis中所有的key
*/
private void deleteAllKey() {
//获取所有key
Set<String> keys = redisTemplate.keys("*");
System.out.println(keys);
Long delete = redisTemplate.delete(keys);
System.out.println(delete);
}
}
Redis操作list
/**
* explain:public interface ListOperations<K,V>
* Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）
* ListOperations专门操作list列表
*/
@RestController
@RequestMapping(value = "redisList", produces = "application/json;charset=UTF-8")
public class RedisOperateList {
@Autowired
RedisTemplate<String, Object> redisTemplate;
/**
* RedisTemplate操作list
*/
@GetMapping("/operateList")
private String operateList() {
ListOperations<String, Object> opsForList = redisTemplate.opsForList();
deleteAllKey();
// Long leftPush(K key, V value);
// 将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从左边插入）
opsForList.leftPush("product:list", "iphone xs max");
opsForList.leftPush("product:list", "thinkpad x1 carbon");
// List<V> range(K key, long start, long end);
// 返回存储在键中的列表的指定元素。偏移开始和停止是基于零的索引，其中0是列表的第一个元素（列表的头部），1是下一个元素
List<Object> opsList = opsForList.range("product:list", 0, -1);
System.out.println(opsList);
// Long leftPushAll(K key, V... values);批量把一个数组插入到列表中
Object[] stringArr = new String[]{"1", "2", "3"};
opsForList.leftPushAll("product:list", stringArr);
System.out.println(opsForList.range("product:list", 0, -1));
// Long size(K key);
// 返回存储在键中的列表的长度。如果键不存在，则将其解释为空列表，并返回0。当key存储的值不是列表时返回错误。
Long size = opsForList.size("product:list");
System.out.println(size);
//Long leftPushAll(K key, Collection<V> values);批量把一个集合插入到列表中
ArrayList<Object> list = new ArrayList<>();
list.add("4");
list.add("5");
list.add("6");
opsForList.leftPushAll("product:list1", list);
System.out.println(opsForList.range("product:list1", 0, -1));
//Long leftPushIfPresent(K key, V value);只有存在key对应的列表才能将这个value值插入到key所对应的列表中
opsForList.leftPushIfPresent("product:list1", "7");
System.out.println(opsForList.range("product:list1", 0, -1));
// Long leftPush(K key, V pivot, V value);把value值放到key对应列表中pivot值的左面，(如果pivot值存在的话)
opsForList.leftPush("product:list1", "4", "8");
System.out.println(opsForList.range("product:list1", 0, -1));
// Long rightPush(K key, V value);
// 将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从右边插入）
opsForList.rightPush("product:list1", "java");
// Long rightPushAll(K key, V... values);
opsForList.rightPushAll("product:list1", stringArr);
opsForList.rightPushAll("product:list1", list);
System.out.println(opsForList.range("product:list1", 0, -1));
// Long rightPushIfPresent(K key, V value);
// 只有存在key对应的列表才能将这个value值插入到key所对应的列表中
opsForList.rightPushIfPresent("product:list1", "7");
System.out.println(opsForList.range("product:list1", 0, -1));
// Long rightPush(K key, V pivot, V value);
// 把value值放到key对应列表中pivot值的右面，如果pivot值存在的话
opsForList.rightPush("product:list1", "8");
System.out.println(opsForList.range("product:list1", 0, -1));
// void set(K key, long index, V value);在列表中index的位置设置value值
opsForList.set("product:list1", 5, "java1");
System.out.println(opsForList.range("product:list1", 0, 7));
// Long remove(K key, long count, Object value);
// 从存储在键中的列表中删除等于值的元素的第一个计数事件。
// 计数参数以下列方式影响操作：
// count> 0：删除等于从头到尾移动的值的元素。
// count <0：删除等于从尾到头移动的值的元素。
// count = 0：删除等于value的所有元素。
opsForList.remove("product:list1", 0, "java1");
System.out.println(opsForList.range("product:list1", 0, -1));
// V index(K key, long index);根据下表获取列表中的值，下标是从0开始的
Object index = opsForList.index("product:list1", 0);
System.out.println(index);
// V leftPop(K key);弹出最左边的元素，弹出之后该值在列表中将不复存在
Object leftPop = opsForList.leftPop("product:list1");
System.out.println(leftPop);
// V leftPop(K key, long timeout, TimeUnit unit);
// 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
opsForList.leftPop("product:list1", 10, TimeUnit.SECONDS);
// V rightPop(K key);弹出最右边的元素，弹出之后该值在列表中将不复存在
System.out.println(opsForList.rightPop("product:list1"));
// V rightPopAndLeftPush(K sourceKey, K destinationKey);
// 用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。
opsForList.rightPopAndLeftPush("product:list1", "product:list2");
// V rightPopAndLeftPush(K sourceKey, K destinationKey, long timeout, TimeUnit unit);
// 用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
// 使用：用法与rightPopAndLeftPush(K sourceKey, K destinationKey)一样
return "method completed ok";
}
/**
* 删除redis中所有的key
*/
private void deleteAllKey() {
//获取所有key
Set<String> keys = redisTemplate.keys("*");
System.out.println(keys);
Long delete = redisTemplate.delete(keys);
System.out.println(delete);
}
}
