1.pom文件引入依赖
<!--redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.5.5</version>
</dependency>
2.application.properties配置文件添加相关的redis配置信息
# redis配置
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=123456
3.java中添加相关的redis配置类
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;
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
}
}
4.使用RedisTemplate创建redis的java工具类
package hecr.test.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtil {
private static double size = Math.pow(2, 32);
private static RedisTemplate template;
@Autowired
private RedisTemplate redisTemplate;
/**
* 实现将redis工具类变成静态工具类
*/
@PostConstruct
public void init() {
template = this.redisTemplate;
}
/**
* 写入缓存
* offset 位 8Bit=1Byte
*/
public static boolean setBit(String key, long offset, boolean isShow) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = template.opsForValue();
operations.setBit(key, offset, isShow);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 写入缓存
*/
public static boolean getBit(String key, long offset) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = template.opsForValue();
result = operations.getBit(key, offset);
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 写入缓存
*/
public static boolean set(final String key, Object value) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = template.opsForValue();
operations.set(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 写入缓存设置时效时间
*/
public static boolean set(final String key, Object value, Long expireTime) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = template.opsForValue();
operations.set(key, value);
template.expire(key, expireTime, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 批量删除对应的value
*/
public static void remove(final String... keys) {
for (String key : keys) {
remove(key);
}
}
/**
* 删除对应的value
*/
public static void remove(final String key) {
if (exists(key)) {
template.delete(key);
}
}
/**
* 判断缓存中是否有对应的value
*/
public static boolean exists(final String key) {
return template.hasKey(key);
}
/**
* 读取缓存
*/
public static Object get(final String key) {
Object result = null;
ValueOperations<Serializable, Object> operations = template.opsForValue();
result = operations.get(key);
return result;
}
/**
* 哈希 添加
*/
public static void hmSet(String key, Object hashKey, Object value) {
HashOperations<String, Object, Object> hash = template.opsForHash();
hash.put(key, hashKey, value);
}
/**
* 哈希获取数据
*/
public static Object hmGet(String key, Object hashKey) {
HashOperations<String, Object, Object> hash = template.opsForHash();
return hash.get(key, hashKey);
}
/**
* 列表添加
*/
public static void lPush(String k, Object v) {
ListOperations<String, Object> list = template.opsForList();
list.rightPush(k, v);
}
/**
* 列表获取
*/
public static List<Object> lRange(String k, long l, long l1) {
ListOperations<String, Object> list = template.opsForList();
return list.range(k, l, l1);
}
/**
* 集合添加
*/
public static void add(String key, Object value) {
SetOperations<String, Object> set = template.opsForSet();
set.add(key, value);
}
/**
* 集合获取
*/
public static Set<Object> setMembers(String key) {
SetOperations<String, Object> set = template.opsForSet();
return set.members(key);
}
/**
* 有序集合添加
*/
public static void zAdd(String key, Object value, double scoure) {
ZSetOperations<String, Object> zset = template.opsForZSet();
zset.add(key, value, scoure);
}
/**
* 有序集合获取
*/
public static Set<Object> rangeByScore(String key, double scoure, double scoure1) {
ZSetOperations<String, Object> zset = template.opsForZSet();
template.opsForValue();
return zset.rangeByScore(key, scoure, scoure1);
}
/**
* 第一次加载的时候将数据加载到redis中
*/
public static void saveDataToRedis(String name) {
double index = Math.abs(name.hashCode() % size);
long indexLong = new Double(index).longValue();
boolean availableUsers = setBit("availableUsers", indexLong, true);
}
/**
* 第一次加载的时候将数据加载到redis中
*/
public static boolean getDataToRedis(String name) {
double index = Math.abs(name.hashCode() % size);
long indexLong = new Double(index).longValue();
return getBit("availableUsers", indexLong);
}
/**
* 有序集合获取排名
*/
public static Long zRank(String key, Object value) {
ZSetOperations<String, Object> zset = template.opsForZSet();
return zset.rank(key, value);
}
/**
* 有序集合获取排名
*/
public static Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start, long end) {
ZSetOperations<String, Object> zset = template.opsForZSet();
Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key, start, end);
return ret;
}
/**
* 有序集合添加
*/
public static Double zSetScore(String key, Object value) {
ZSetOperations<String, Object> zset = template.opsForZSet();
return zset.score(key, value);
}
/**
* 有序集合添加分数
*/
public static void incrementScore(String key, Object value, double scoure) {
ZSetOperations<String, Object> zset = template.opsForZSet();
zset.incrementScore(key, value, scoure);
}
/**
* 有序集合获取排名
*/
public static Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) {
ZSetOperations<String, Object> zset = template.opsForZSet();
Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key, start, end);
return ret;
}
/**
* 有序集合获取排名
*/
public static Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
ZSetOperations<String, Object> zset = template.opsForZSet();
Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
return ret;
}
}
5.测试
/**
* 设置并获取redis String类型的值
* 使用redis工具类
*/
@GetMapping("setAndGetValueByUseUtil/{key}/{value}")
public String setAndGetValueByUseUtil(@PathVariable("key") String key, @PathVariable("value") String value) {
RedisUtil.set(key, value);
return (String) RedisUtil.get(key);
}
测试结果:成功访问redis
上图出现16进制显示的原因是因为没有序列化,解决方案,序列化即可
在redis的配置bean上添加序列化方法即可
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(factory);
// 使用Jackson2JsonRedisSerialize替换默认序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
// 设置key和value的序列化规则
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
序列化后结果,能正常显示值
6.文章参考链接
a. https://blog.csdn.net/qq_42479528/article/details/121697812