Springboot基础之RedisUtils工具类

Springboot基础之RedisUtils工具类

SpringBoot整合Redis

引入Redis依赖

org.springframework.boot

spring-boot-starter-data-redis

设置Redis的Template

RedisConfig.java

package cn.wideth.config;

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.RedisSerializer;

/**

* 编写配置类，构造RedisTemplate

* 这个springboot已经帮我们配了，

* 但是默认object，我想改成string

*/

@Configuration

public class RedisConfig {

@Bean

public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

RedisTemplate template = new RedisTemplate<>();

template.setConnectionFactory(factory);

// 设置key的序列化方式

template.setKeySerializer(RedisSerializer.string());

// 设置value的序列化方式

template.setValueSerializer(RedisSerializer.json());

// 设置hash的key的序列化方式

template.setHashKeySerializer(RedisSerializer.string());

// 设置hash的value的序列化方式

template.setHashValueSerializer(RedisSerializer.json());

template.afterPropertiesSet();

return template;

}

}

设置Redis连接信息

redis操作5种常见的数据类型

Redis工具类

redisTemplate API

1.opsForValue -> String

2.opsForSet -> Set

3.opsForHash -> hash

4.opsForZset -> SortSet

5.owZFHOLdeAKpsForList -> list队列

代码

package cn.wideth.util.other;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.*;

import java.util.List;

import java.util.Set;

import java.util.concurrent.TimeUnit;

public class RedisUtils {

@Autowired

private RedisTemplate redisTemplate;

private static double size = Math.pow(2, 32);

/**

* 写入缓存

* @param key

* @param offset 位 8Bit=1Byte

* @return

*/

public boolean setBit(String key, long offset, boolean isShow) {

boolean result = false;

try {

ValueOperations operations = redisTemplate.opsForValue();

operations.setBit(key, offset, isShow);

result = true;

} catch (Exception e) {

e.printStackTrace();

}

return result;

}

/**

* 写入缓存

*

* @param key

* @param offset

* @return

*/

public boolean getBit(String key, long offset) {

boolean result = false;

try {

ValueOperations operations = redisTemplate.opsForValue();

result = operations.getBit(key, offset);

} catch (Exception e) {

e.printStackTrace();

}

return result;

}

/**

* 写入缓存

*

* @param key

* @param value

* @return

*/

public boolean set(final String key, Object value) {

boolean result = false;

try {

ValueOperations operations = redisTemplate.opsForValue();

operations.set(key, value);

result = true;

} catch (Exception e) {

e.printStackTrace();

}

return result;

}

/**

* 写入缓存设置时效时间

* @param key

* @param value

* @return

*/

public boolean set(final String key, Object value, Long expireTime) {

boolean result = false;

try {

ValueOperations operations = redisTemplate.opshttp://ForValue();

operations.set(key, value);

redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);

result = true;

} catch (Exception e) {

e.printStackTrace();

}

return result;

}

/**

* 批量删除对应的value

*

* @param keys

*/

public void remove(final String... keys) {

for (String key : keys) {

remove(key);

}

}

/**

* 删除对应的value

*

* @param key

*/

public void remove(final String key) {

if (exists(key)) {

redisTemplate.delete(key);

}

}

/**

* 判断缓存中是否有对应的value

*

* @param key

* @return

*/

public boolean exists(final String key) {

return redisTemplate.hasKey(key);

}

/**

* 读取缓存

*

* @param key

* @return

*/

public Object get(final String key) {

Object result = null;

ValueOperations operations = redisTemplate.opsForValue();

result = operations.get(key);

return result;

}

/**

* 哈希 添加

*

* @param key

* @param hashKey

* @param value

*/

public void hmSet(String key, Object hashKey, Object value) {

HashOperations hash = redisTemplate.opsForHash();

hash.put(key, hashKey, value);

}

/**

* 哈希获取数据

*

* @param key

* @param hashKey

* @return

*/

public Object hmGet(String key, Object hashKey) {

HashOperations hash = redisTemplate.opsForHash();

return hash.get(key, hashKey);

}

/**

* 列表添加

*

* @param k

* @param v

*/

public void lPush(String k, Object v) {

ListOperations list = redisTemplate.opsForList();

list.rightPush(k, v);

}

/**

* 列表获取

*

* @param k

* @param l

* @param l1

* @return

*/

public List

ListOperations list = redisTemplate.opsForList();

return list.range(k, l, l1);

}

/**

* 集合添加

*

* @param key

* @param value

*/

public void add(String key, Object value) {

SetOperations set = redisTemplate.opsForSet();

set.add(key, value);

}

/**

* 集合获取

* @param key

* @return

*/

public Set

SetOperations set = redisTemplate.opsForSet();

return set.members(key);

}

/**

* 有序集合添加

* @param key

* @param value

* @param scoure

*/

public void zAdd(String key, Object value, double scoure) {

ZSetOperations zset = redisTemplate.opsForZSet();

zset.add(key, value, scoure);

}

/**

* 有序集合获取

* @param key

* @param scoure

* @param scoure1

* @return

*/

public Set

ZSetOperations zset = redisTemplate.opsForZSet();

redisTemplate.opsForValue();

return zset.rangeByScore(key, scoure, scoure1);

}

//第一次加载的时候将数据加载到redis中

public 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 boolean getDataToRedis(String name) {

double index = Math.abs(name.hashCode() % size);

long indexLong = new Double(index).longValue();

return getBit("availableUsers", indexLong);

}

/**

* 有wZFHOLdeAK序集合获取排名

* @param key 集合名称

* @param value 值

*/

public Long zRank(String key, Object value) {

ZSetOperations zset = redisTemplate.opsForZSet();

return zset.rank(key,value);

}

/**

* 有序集合获取排名

* @param key

*/

public Set> zRankWithScore(String key, long start,long end) {

ZSetOperations zset = redisTemplate.opsForZSet();

Set> ret = zset.rangeWithScores(key,start,end);

return ret;

}

/**

* 有序集合添加

* @param key

* @param value

*/

public Double zSetScore(String key, Object value) {

ZSetOperations zset = redisTemplate.opsForZSet();

return zset.score(key,value);

}

/**

* 有序集合添加分数

* @param key

* @param value

* @param scoure

*/

public void incrementScore(String key, Object value, double scoure) {

ZSetOperations zset = redisTemplate.opsForZSet();

zset.incrementScore(key, value, scoure);

}

/**

* 有序集合获取排名

* @param key

*/

public Set> reverseZRankWithScore(String key, long start,long end) {

ZSetOperations zset = redisTemplate.opsForZSet();

Set> ret = zset.reverseRangeByScoreWithScores(key,start,end);

return ret;

}

/**

* 有序集合获取排名

* @param key

*/

public Set> reverseZRankWithRank(String key, long start, long end) {

ZSetOperations zset = redisTemplate.opsForZSet();

Set> ret = zset.reverseRangeWithScores(key, start, end);

return ret;

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。