Redis工具类、Redis操作模板

最新推荐文章于 2020-10-11 15:47:15 发布
最新推荐文章于 2020-10-11 15:47:15 发布
阅读量159 收藏
点赞数
分类专栏： 综合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SUMMER11210/article/details/106959187
版权

1、RedisConfig

/**
 * @author: XJX
 * @program: myDemo
 **/

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();

        template.setConnectionFactory(factory);

        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);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式

        template.setKeySerializer(stringRedisSerializer);

        // hash的key也采用String的序列化方式

        template.setHashKeySerializer(stringRedisSerializer);

        // value序列化方式采用jackson

        template.setValueSerializer(jackson2JsonRedisSerializer);

        // hash的value序列化方式采用jackson

        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        return template;
    }
}

2、RedisUtil工具类

/**
 * RedisUtil工具类
 */
@Component
public class RedisUtil {

	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
	

	// =============================common============================

	/**
	 * 指定缓存失效时间
	 * 
	 * @param key
	 *            键
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean expire(String key, long time) {
		try {
			if (time > 0) {
				redisTemplate.expire(key, time, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 
	 * 根据key 获取过期时间
	 * 
	 * @param key
	 *            键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}

	/**
	 * 判断key是否存在
	 * 
	 * @param key
	 *            键
	 * @return true 存在 false不存在
	 */
	public boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除缓存
	 * 
	 * @param key
	 *            可以传一个值 或多个
	 */
	@SuppressWarnings("unchecked")
	public void del(String... key) {
		if (key != null && key.length > 0) {
			if (key.length == 1) {
				redisTemplate.delete(key[0]);
			} else {
				redisTemplate.delete(CollectionUtils.arrayToList(key));
			}
		}
	}

	// ============================String=============================

	/**
	 * 普通缓存获取
	 * 
	 * @param key
	 *            键
	 * @return 值
	 */
	public Object get(String key) {
		return key == null ? null : redisTemplate.opsForValue().get(key);
	}

	/**
	 * 普通缓存放入
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @return true成功 false失败
	 */
	public boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 普通缓存放入并设置时间
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public boolean set(String key, Object value, long time) {
		try {
			if (time > 0) {
				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
			} else {
				set(key, value);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 递增
	 * 
	 * @param key
	 *            键
	 * @param delta
	 *            要增加几(大于0)
	 * @return
	 */
	public long incr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递增因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, delta);
	}

	/**
	 * 递减
	 * 
	 * @param key
	 *            键
	 * @param delta
	 *            要减少几(小于0)
	 * @return
	 */
	public long decr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, -delta);
	}

	// ================================Map=================================
	/**
	 * HashGet
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 不能为null
	 * @return 值
	 */
	public Object hget(String key, String item) {
		return redisTemplate.opsForHash().get(key, item);
	}

	/**
	 * 获取hashKey对应的所有键值
	 * 
	 * @param key
	 *            键
	 * @return 对应的多个键值
	 */

	public Map<Object, Object> hmget(String key) {
		return redisTemplate.opsForHash().entries(key);
	}

	/**
	 * HashSet
	 * 
	 * @param key
	 *            键
	 * @param map
	 *            对应多个键值
	 * @return true 成功 false 失败
	 */
	public boolean hmset(String key, Map<String, Object> map) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * HashSet 并设置时间
	 * 
	 * @param key
	 *            键
	 * @param map
	 *            对应多个键值
	 * @param time
	 *            时间(秒)
	 * @return true成功 false失败
	 */
	public boolean hmset(String key, Map<String, Object> map, long time) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param value
	 *            值
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value, long time) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {

			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除hash表中的值
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 可以使多个 不能为null
	 */
	public void hdel(String key, Object... item) {
		redisTemplate.opsForHash().delete(key, item);
	}

	/**
	 * 判断hash表中是否有该项的值
	 * 
	 * @param key
	 *            键 不能为null
	 * @param item
	 *            项 不能为null
	 * @return true 存在 false不存在
	 */

	public boolean hHasKey(String key, String item) {
		return redisTemplate.opsForHash().hasKey(key, item);
	}

	/**
	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param by
	 *            要增加几(大于0)
	 * @return
	 */
	public double hincr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, by);
	}

	/**
	 * hash递减
	 * 
	 * @param key
	 *            键
	 * @param item
	 *            项
	 * @param by
	 *            要减少记(小于0)
	 * @return
	 */
	public double hdecr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, -by);
	}

	// ============================set=============================

	/**
	 * 根据key获取Set中的所有值
	 * 
	 * @param key
	 *            键
	 * @return
	 */
	public Set<Object> sGet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 根据value从一个set中查询,是否存在
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @return true 存在 false不存在
	 */
	public boolean sHasKey(String key, Object value) {
		try {
			return redisTemplate.opsForSet().isMember(key, value);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将数据放入set缓存
	 * 
	 * @param key
	 *            键
	 * @param values
	 *            值 可以是多个
	 * @return 成功个数
	 */
	public long sSet(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 将set数据放入缓存
	 * 
	 * @param key
	 *            键
	 * @param time
	 *            时间(秒)
	 * @param values
	 *            值 可以是多个
	 * @return 成功个数
	 */
	public long sSetAndTime(String key, long time, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().add(key, values);
			if (time > 0)
				expire(key, time);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取set缓存的长度
	 * 
	 * @param key
	 *            键
	 * 
	 * @return
	 * 
	 */

	public long sGetSetSize(String key) {

		try {

			return redisTemplate.opsForSet().size(key);

		} catch (Exception e) {

			e.printStackTrace();

			return 0;

		}

	}

	/**
	 * 
	 * 移除值为value的
	 * 
	 * @param key
	 *            键
	 * 
	 * @param values
	 *            值 可以是多个
	 * 
	 * @return 移除的个数
	 * 
	 */
	public long setRemove(String key, Object... values) {

		try {

			Long count = redisTemplate.opsForSet().remove(key, values);

			return count;

		} catch (Exception e) {

			e.printStackTrace();

			return 0;

		}

	}

	// ===============================list=================================

	/**
	 * 
	 * 获取list缓存的内容
	 * 
	 * @param key
	 *            键
	 * 
	 * @param start
	 *            开始
	 * 
	 * @param end
	 *            结束 0 到 -1代表所有值
	 * 
	 * @return
	 * 
	 */
	public List<Object> lGet(String key, long start, long end) {

		try {

			return redisTemplate.opsForList().range(key, start, end);

		} catch (Exception e) {

			e.printStackTrace();

			return null;

		}

	}

	/**
	 * 
	 * 获取list缓存的长度
	 * 
	 * @param key
	 *            键
	 * 
	 * @return
	 * 
	 */

	public long lGetListSize(String key) {

		try {

			return redisTemplate.opsForList().size(key);

		} catch (Exception e) {

			e.printStackTrace();

			return 0;

		}

	}

	/**
	 * 
	 * 通过索引 获取list中的值
	 * 
	 * @param key
	 *            键
	 * 
	 * @param index
	 *            索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * 
	 * @return
	 * 
	 */

	public Object lGetIndex(String key, long index) {

		try {

			return redisTemplate.opsForList().index(key, index);

		} catch (Exception e) {

			e.printStackTrace();

			return null;

		}

	}

	/**
	 * 
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * 
	 * @param value
	 *            值
	 * 
	 * @param time
	 *            时间(秒)
	 * 
	 * @return
	 * 
	 */

	public boolean lSet(String key, Object value) {

		try {

			redisTemplate.opsForList().rightPush(key, value);

			return true;

		} catch (Exception e) {

			e.printStackTrace();

			return false;

		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value, long time) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			if (time > 0)
				expire(key, time);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key
	 *            键
	 * @param value
	 *            值
	 * @param time
	 *            时间(秒)
	 * @return
	 */

	public boolean lSet(String key, List<Object> value, long time) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			if (time > 0)
				expire(key, time);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据索引修改list中的某条数据
	 * 
	 * @param key
	 *            键
	 * @param index
	 *            索引
	 * @param value
	 *            值
	 * @return
	 */
	public boolean lUpdateIndex(String key, long index, Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 移除N个值为value
	 * 
	 * @param key
	 *            键
	 * @param count
	 *            移除多少个
	 * @param value
	 *            值
	 * @return 移除的个数
	 */

	public long lRemove(String key, long count, Object value) {

		try {

			Long remove = redisTemplate.opsForList().remove(key, count, value);

			return remove;

		} catch (Exception e) {

			e.printStackTrace();

			return 0;
		}

	}

	/**
	 * 实现队列存储数据(生产者)
	 * @Title: produce
	 * @param key
	 * @param value
	 * @return
	 */
	public void producer(String key, Object value){
		redisTemplate.opsForList().leftPush(key, value);
//		return lSet(key, value, RedisKeyUtil.getTimeOut());
	}
	
	/**
	 * 实现队列处理数据(消费者)
	 * @Title: process
	 * @param key
	 * @return
	 */
	public Object processer(String key){
		return redisTemplate.opsForList().rightPop(key);
//		Object obj = lGetIndex(key, 0);
//		lRemove(key, 1, obj);
//		return obj;
	}
	
	
}
RadiantGlow
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis 工具类 RedisTemplate
qq_32265719的博客
05-09 298
@Component public class RedisUtil { @Autowired private RedisTemplate redisTemplate; // =============================common============================ /** * 指定缓存失效时间 * @pa...
Redis工具类RedisPoolUntil
池边的树的博客
06-23 332
Redis工具类RedisPoolUntil redis.properties #redis服务器ip redis.ip=127.0.0.1 #redis服务器端口号 redis.port=6379 #redis密码 redis.passWord= #与服务器建立连接的超时时间 redis.timeout=3000 #jedis的最大活跃连接数 pool.maxTotal=10 #jedis最大空闲连接数 pool.maxIdle=3 #jedis池没有连接对象返回时，等待可用连接的最大时间，单位毫秒，默认
RedisTest
Leon_Jinhai_Sun的博客
09-10 368
@Test public void test44() { Map<String, Object> map = new HashMap<String, Object>(); // map.put("powerConsumption", 80); // map.put("reportStatus", 2); // ...
redis入门到精通系列（十）：springboot集成redis及redis工具类的编写
Java鱼仔的博客
08-30 658
别只知道redis，不知道用啊
SpringBoot RedisUtil
qq_18453581的博客
09-30 807
1.引入redis依赖 2.redis Bean import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConne...
Redis使用RedisTemplate模板类的常用操作
程序大视界
10-11 2024
一、前言 Redis是一个NoSQL（非关系型数据库）数据库之一，key-value存储系统或者说是一个缓存键值对数据库，具有如下特性： 基于内存运行，性能高效 支持分布式，理论上可以无限扩展 key-value存储系统 开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API 主要应用场景包括：缓存系统、计数器、消息队列系统、排行榜、社交网络和实时系统、分布式锁和发布/订阅消息等。而在程序中，对Redis的常用操作有
SpringBoot整合redis
w7635122886的博客
06-21 298
在配置文件application.properties中添加redis集群配置 redis集群配置 spring.redis.cluster.nodes=127.0.0.1:7000,127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005 Redis服务器连接密码（默认为空） spring.redis.password= 连接池最大连接数（使用负值表示没有限制） spring.redis.pool.max-act
redis utils 工具类
07-08
RedisUtils工具类应包含一系列用于执行基本Redis操作的方法，如`set(String key, String value)`、`get(String key)`、`exists(String key)`、`del(String key)`等。这些方法封装了Jedis实例的操作，使得在业务代码...
Redis工具类
09-27
在Java开发中，为了方便地操作Redis，通常会封装一个Redis工具类，提高代码的复用性和易用性。本篇文章将深入探讨标题为"Redis工具类"的知识点，包括`valueOperations`和`RedisTemplate`的使用，以及它们在`Redis...
redis工具类以及redis 连接池配置
07-01
工具类中包括存放hash表键值对，键值对以map的方式储存，删除键值对，永久存放键值对，设置过期时间，需要的直接去gitHab上看https://github.com/1610220353/advancedGiants/tree/master/src/main
Redis操作工具类.zip
11-02
在Java开发中，为了方便地与Redis进行交互，通常会封装一个工具类（RedisUtil），以便于代码的复用和简化操作。这个压缩包包含了一个名为`RedisUtil`的Java工具类和一个`README.md`的介绍文档，下面将详细讲解这两个...
spring-redis工具类
04-22
Spring整合Redis工具类，导入redis依赖，并使用工具类，不必使用RedisTemplate调用redis，并且采用java更常用的方式调用方法。
java去掉String字符串开头或结尾的0
SUMMER11210的博客
07-30 9347
去字符串开头的0 方法一： String str = "000000123456"; String newStr = str.replaceAll("^0*",""); 方法二： String str = "0000000123456"; String newStr = str.replaceAll("^(0+)", ""); 去字符串结尾的0 方法一： String str = "1234567000000"; String newStr = str.replaceAll("0+$", ""); 方
GIT项目上传和下载相关问题
SUMMER11210的博客
11-25 1214
GIT项目上传和下载相关问题 一、新建GIT分支： 二、IDEA开发工具使用 git 创建项目、拉取分支、合并分支 https://blog.csdn.net/qq_39470733/article/details/80366435 三、IDEA常见GIT命令 Git常用操作命令： 1) 远程仓库相关命令 检出仓库：$ git clone git:``//github.com/jquer...
一键式服务器环境安装
SUMMER11210的博客
01-13 1008
脚本 #!/bin/bash #Author: wanggw #Script for Hp install! function stdoutlog() { echo "$1" 1>&2 echo "$1" } exec 1>install.log stdoutlog " _ _ _ " stdoutlog "| |__ ...
win10 docker 19.03.8 配置镜像加速源
SUMMER11210的博客
07-17 758
windows10 docker 19.03.8 中镜像代理配置的界面变了 Settings–>Docker Engine 下的 “registry-mirrors”: [“自己的加速器地址”],
Windows无法安装到这个磁盘 选中的磁盘具有MBR分区表解决方法
SUMMER11210的博客
07-25 758
https://www.cnblogs.com/showonce/p/8905072.html添加链接描述
Springboot将自定义jar包引入pom
SUMMER11210的博客
07-13 538
Springboot将自定义jar包引入pom <dependency> <groupId>blesdk</groupId> <artifactId>blesdk</artifactId> <version>1.0</version> <scope>system</scope> <systemPath>${proj
在liunx环境下 mysql 新增报错
SUMMER11210的博客
01-15 431
**在liunx环境下 mysql 新增报错 ** <insert id="insertStation" parameterType="pd"> <selectKey keyProperty="stationId" resultType="Integer" order="BEFORE"> SELECT nextval('station_info...
springboot redis工具类
最新发布
07-11
Spring Boot 还提供了一些方便的工具类，比如 `StringRedisTemplate`，它是一个字符串类型的 Redis 模板，特别适合于键值对的操作。 使用时，一般会按照以下步骤： 1. 配置 Redis 数据源：添加依赖并配置 Redis ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值