redis增删查改数据Util
(1)需要导入的包
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.5.0.RELEASE</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.0</version>
</dependency>
(2)redis配置文件
如果是springboot项目，可自己根据实际情况修改成类配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="150"></property>
<property name="maxIdle" value="30"></property>
<property name="minIdle" value="10"></property>
<property name="maxWaitMillis" value="15000"></property>
<property name="minEvictableIdleTimeMillis" value="300000"></property>
<property name="numTestsPerEvictionRun" value="3"></property>
<property name="timeBetweenEvictionRunsMillis" value="60000"></property>
<property name="testOnBorrow" value="true"></property>
<property name="testOnReturn" value="true"></property>
<property name="testWhileIdle" value="true"></property>
</bean>
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
<property name="hostName" value="127.0.0.1" />
<property name="port" value="6379" />
<property name="timeout" value="15000" />
<property name="database" value="0" />
<property name="password" value="" />
<property name="usePool" value="true" />
<property name="poolConfig" ref="jedisPoolConfig" />
</bean>
<!-- redis template definition p表示对该bean里面的属性进行注入，格式为p:属性名=注入的对象 效果与在bean里面使用<property>标签一样 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
p:connection-factory-ref="jedisConnectionFactory">
<!-- 序列化方式 建议key/hashKey采用StringRedisSerializer。 -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
</property>
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
</property>
</bean>
</beans>
(3)RedisUtil类
import java.io.Serializable;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;
@Service
public class RedisUtil
{
@Autowired
@Qualifier("redisTemplate")
public RedisTemplate<String, Object> redisTemplate;
@Autowired
@Qualifier("redisTemplate")
protected RedisTemplate<Serializable, Serializable> redisTemplateSerializable;
/**
* 缓存基本的对象，Integer、String、实体类等
* @param key 缓存的键值
* @param value 缓存的值
* @return 缓存的对象
*/
public void setCacheObject(String key, Object value)
{
redisTemplate.opsForValue().set(key,value);
}
public void removeCacheObject(String key){
redisTemplate.delete(key);
}
/**
* 获得缓存的基本对象。
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public Object getCacheObject(String key/*,ValueOperations<String,T> operation*/)
{
return redisTemplate.opsForValue().get(key);
}
/**
* 缓存List数据
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public Object setCacheList(String key, List<Object> dataList)
{
ListOperations<String, Object> listOperation = redisTemplate.opsForList();
if(null != dataList)
{
int size = dataList.size();
for(int i = 0; i < size ; i ++)
{
listOperation.rightPush(key,dataList.get(i));
}
}
// redisTemplate.delete(key);
// listOperation.rightPushAll(key, dataList);
return listOperation;
}
/**
* 获得缓存的list对象
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public List<Object> getCacheList(String key) {// List<Object> dataList = new ArrayList<Object>();
ListOperations<String, Object> listOperation = redisTemplate.opsForList();
List<Object> dataList = listOperation.range(key, 0, -1);
/*Long size = listOperation.size(key);
for(int i = 0 ; i < size ; i ++) {
dataList.add(listOperation.leftPop(key));
}*/
return dataList;
}
/**
* 根据多个key获取多个值
* @param keySet
* @return
*/
public List<Object> getCacheValueByKeySet(Set<String> keySet) {
ValueOperations<String, Object> valueOperation = redisTemplate.opsForValue();
List<Object> dataObject = valueOperation.multiGet(keySet);
return dataObject;
}
public List<Object> pipelineGetCacheValueByKeySet(final Set<String> keySet){
//pipeline
RedisCallback<List<Object>> pipelineCallback = new RedisCallback<List<Object>>() {
@Override
public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
connection.openPipeline();
for (String key : keySet) {
connection.incr(key.getBytes());
}
return connection.closePipeline();
}
};
List<Object> results = (List<Object>)redisTemplate.execute(pipelineCallback);
return results;
}
/**
* 获得缓存的list对象
* @Title: range
* @Description: TODO(这里用一句话描述这个方法的作用)
* @param @param key
* @param @param start
* @param @param end
* @param @return
* @return List<T> 返回类型
* @throws
*/
public List<Object> range(String key, long start, long end)
{
ListOperations<String, Object> listOperation = redisTemplate.opsForList();
return listOperation.range(key, start, end);
}
/**
* list集合长度
* @param key
* @return
*/
public Long listSize(String key) {
return redisTemplate.opsForList().size(key);
}
/**
* 覆盖操作,将覆盖List中指定位置的值
* @param key
* @param index 位置
* @param obj 值
* @return 状态码
* */
public void listSet(String key, int index, Object obj) {
redisTemplate.opsForList().set(key, index, obj);
}
/**
* 向List尾部追加记录
*
* @param key
* @param obj
* @return 记录总数
* */
public long leftPush(String key, Object obj) {
return redisTemplate.opsForList().leftPush(key, obj);
}
/**
* 向List头部追加记录
*
* @param key
* @param obj
* @return 记录总数
* */
public long rightPush(String key, Object obj) {
return redisTemplate.opsForList().rightPush(key, obj);
}
/**
* 算是删除吧，只保留start与end之间的记录
*
* @param key
* @param start 记录的开始位置(0表示第一条记录)
* @param end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推）
* @return 执行状态码
* */
public void trim(String key, int start, int end) {
redisTemplate.opsForList().trim(key, start, end);
}
/**
* 删除List中c条记录，被删除的记录值为value
*
* @param key
* @param i 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录
* @param obj 要匹配的值
* @return 删除后的List中的记录数
* */
public long remove(String key, long i, Object obj) {
return redisTemplate.opsForList().remove(key, i, obj);
}
/**
* 缓存Set
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public BoundSetOperations<String, Object> setCacheSet(String key,Set<Object> dataSet)
{
BoundSetOperations<String, Object> setOperation = redisTemplate.boundSetOps(key);
/*T[] t = (T[]) dataSet.toArray();
setOperation.add(t);*/
Iterator<Object> it = dataSet.iterator();
while(it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
* @param key
* @return
*/
public Set<Object> getCacheSet(String key/*,BoundSetOperations<String,T> operation*/)
{
Set<Object> dataSet = new HashSet<Object>();
BoundSetOperations<String,Object> operation = redisTemplate.boundSetOps(key);
Long size = operation.size();
for(int i = 0 ; i < size ; i++)
{
dataSet.add(operation.pop());
}
return dataSet;
}
/**
* 缓存Map
* @param key
* @param dataMap
* @return
*/
public int setCacheMap(String key,Map<Object, Object> dataMap)
{
if(null != dataMap)
{
HashOperations<String, Object, Object> hashOperations = redisTemplate.opsForHash();
hashOperations.putAll(key,dataMap);
// for (Map.Entry<Object, Object> entry : dataMap.entrySet()) {
// /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); */
// if(hashOperations != null){
// hashOperations.put(key,entry.getKey(),entry.getValue());
// } else{
// return 0;
// }
// }
} else{
return 0;
}
return dataMap.size();
}
/**
* 删除缓存Map
* @param key
* @param dataMap
* @return
*/
public void removeCacheMap(String key, Map<Object, Object> dataMap) {
if (null != dataMap) {
HashOperations<String, Object, Object> hashOperations = redisTemplate.opsForHash();
for (Map.Entry<Object, Object> entry : dataMap.entrySet()) {
hashOperations.delete(key, entry.getKey(), entry.getValue());
}
}
}
/**
* 获得缓存的Map
* @param key
* @return
*/
public Map<Object, Object> getCacheMap(String key/*,HashOperations<String,String,T> hashOperation*/)
{
Map<Object, Object> map = redisTemplate.opsForHash().entries(key);
/*Map<String, T> map = hashOperation.entries(key);*/
return map;
}
/**
* 缓存Map
* @param key
* @param dataMap
* @return
*/
public void setCacheIntegerMap(String key,Map<Integer, Object> dataMap)
{
HashOperations<String, Object, Object> hashOperations = redisTemplate.opsForHash();
if(null != dataMap)
{
for (Map.Entry<Integer, Object> entry : dataMap.entrySet()) {
/*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); */
hashOperations.put(key,entry.getKey(),entry.getValue());
}
}
}
/**
* 获得缓存的Map
* @param key
* @return
*/
public Map<Object, Object> getCacheIntegerMap(String key/*,HashOperations<String,String,T> hashOperation*/)
{
Map<Object, Object> map = redisTemplate.opsForHash().entries(key);
/*Map<String, T> map = hashOperation.entries(key);*/
return map;
}
/**
* 从hash中删除指定的存储
*
* @return 状态码，1成功，0失败
* */
public void deleteMap(String key) {
redisTemplate.setEnableTransactionSupport(true);
redisTemplate.opsForHash().delete(key);
}
/**
* 设置过期时间
* @param key
* @param time
* @param unit
* @return
*/
public boolean expire(String key, long time, TimeUnit unit) {
return redisTemplate.expire(key, time, unit);
}
/**
* 获取过期时间
* @param key
* @param unint
* @return
*/
public Long getExpire(String key,TimeUnit unint) {
return redisTemplate.getExpire(key, unint);
}
/**
* increment
* @param key
* @param step
* @return
*/
public long increment(String key, long step) {
return redisTemplate.opsForValue().increment(key, step);
}
/**
* 判断是否存在key
* @param key
* @return
*/
public boolean hasKey(String key){
return redisTemplate.hasKey(key);
}
/**
*
* @param map
*/
public void batchSetObject(final Map<String, Object> map){
redisTemplate.executePipelined(new RedisCallback() {
@Override
public Object doInRedis(RedisConnection connection)
throws DataAccessException {
for(String key : map.keySet()){
byte[] rawKey = serialize(key, redisTemplate.getKeySerializer());
byte[] rawValue = serialize(map.get(key), redisTemplate.getValueSerializer());
connection.set(rawKey, rawValue);
}
return null;
}
});
}
/**
* 删除redis的所有数据
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public String flushDB() {
return redisTemplateSerializable.execute(new RedisCallback() {
public String doInRedis(RedisConnection connection) throws DataAccessException {
connection.flushDb();
return "ok";
}
});
}
/**
* 删除redis的一条数据
*/
public long del(final byte[] key) {
return (long) redisTemplateSerializable.execute(new RedisCallback<Object>() {
public Long doInRedis(RedisConnection connection) {
return connection.del(key);
}
});
}
@SuppressWarnings({"unchecked", "rawtypes"})
public byte[] get(final byte[] key) {
return (byte[]) redisTemplateSerializable.execute(new RedisCallback() {
public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
return connection.get(key);
}
});
}
/**
* @param key
* @param value
* @param liveTime
*/
public void set(final byte[] key, final byte[] value, final long liveTime) {
redisTemplateSerializable.execute(new RedisCallback<Object>() {
public Long doInRedis(RedisConnection connection) throws DataAccessException {
connection.set(key, value);
if (liveTime > 0) {
connection.expire(key, liveTime);
}
return 1L;
}
});
}
/**
* 发布信息
* @param channel
* @param value
*/
public void convertAndSend(String channel, String value){
redisTemplate.convertAndSend(channel,value);
}
@SuppressWarnings("unchecked")
private byte[] serialize(Object value, RedisSerializer serializer) {
if (serializer == null && value instanceof byte[]) {
return (byte[]) value;
}
return serializer.serialize(value);
}
}
redis增删查改数据Util的更多相关文章
- MERGE批量增删查改数据
MERGE优点: 在批量处理数据的时候,我可以用到merge一次完成数据处理. 示例代码一: MERGE INTO student AS t using ( AS age) s ON t.Age=s. ...
- 利用dbutils工具实现数据的增删查改操作(dbutis入门)
一.前期准备 1.安装数据库(如:mysql5.5) 2.安装Eclipse(如:3.4) 3.下载数据库驱动包 4.下载dbutis工具包 5.在Eclipse创建名为 dbutils 的工程并在工 ...
- java：Hibernate框架1（环境搭建，Hibernate.cfg.xml中属性含义，Hibernate常用API对象，HibernteUitl，对象生命周期图，数据对象的三种状态，增删查改）
1.环境搭建: 三个准备+7个步骤 准备1:新建项目并添加hibernate依赖的jar文件 准备2:在classpath下(src目录下)新建hibernate的配置文件:hibernate.cf ...
- SQL Server 表的管理_关于数据增删查改的操作的详解（案例代码）
SQL Server 表的管理_关于数据增删查改的操作的详解(案例代码)-DML 1.SQL INSERT INTO 语句(在表中插入) INSERT INTO 语句用于向表中插入新记录. SQL I ...
- 学习记录——使用PHP实现数据增删查改等基本功能（前后端分离）
萌新初次学习服务器端语言,分享学习经验 实现功能:1.显示数据表 2.对数据进行分页 3.对数据进行增删查改 由于本萌新采用前后端完全分离方案,所以数据传输用的ajax,为了提高代码的复用 ...
- 2015.8.2 jdbc实现商品类的增删查改
在惠普济宁基地进行了两周sql和java的学习,学到很多东西 刚才实现了用jdbc访问数据库对数据库进行操作,是用eclipse写的,过几天移植到NetBeans上,个人还是比较习惯看图形化界面 前几 ...
- SSH框架的多表查询和增删查改 （方法一）中
原创作品,允许转载,转载时请务必标明作者信息和声明本文章==>http://www.cnblogs.com/zhu520/p/7774144.html 这边文章是接的刚刚前一遍的基础上敲的 ...
- JDBC+Servlet+jsp(增删查改)
先在mysql新增数据库和表先,把下面的几句代码复制去到mysql运行就可以创建成功了! 创建数据库 create database jdbc01 character set utf8 collat ...
- SSH框架的多表查询（方法二）增删查改
必须声明本文章==>http://www.cnblogs.com/zhu520/p/7773133.html 一:在前一个方法(http://www.cnblogs.com/zhu520/p ...
随机推荐
- Java 面试知识点解析(三)——JVM篇
前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...
- 【转】JavaScript 错误处理与调试——“错误处理”的注意要点
try-catch语句 该语句最适合处理那些我们无法控制的错误,在明明白白地知道自己的代码会发生错误时,再使用该语句就不太合适了. ECMA-262第3版引入了try-catch语句,基本的语法如下所 ...
- RBAC权限模型——项目实战(转)
一.前言 权限一句话来理解就是对资源的控制,对web应用来说就是对url的控制,关于权限可以毫不客气的说几乎每个系统都会包含,只不过不同系统关于权限的应用复杂程序不一样而已,现在我们在用的权限模型基本 ...
- Render
render 渲染元素 元素是React应用程序的最小构建块 "根"DOM节点,它内部的所有内容都将由React DOM进行管理 仅使用React构建的App程序通常具有单个Dom ...
- Elasticsearch结构化搜索_在案例中实战使用term filter来搜索数据
1.根据用户ID.是否隐藏.帖子ID.发帖日期来搜索帖子 (1)插入一些测试帖子数据 POST /forum/article/_bulk { "index": { "_i ...
- rsyslog & syslog详解
前言: rsyslog 是一个 syslogd 的多线程增强版.syslog是Linux系统默认的日志守护进程.默认的syslog配置文件是/etc/syslog.conf文件.程序,守护进程和内核提 ...
- Python之深浅拷贝
拷贝就是拷贝,何来深浅之说? Python中,对象的赋值,拷贝(深/浅拷贝)之间是有差异的,如果使用的时候不注意,就可能产生意外的结果 其实这个是由于共享内存导致的结果 浅拷贝 l1 = [1,2,3 ...
- 远程代码仓库URL地址变更后本地仓库的配置方法
作者:荒原之梦 原文链接:http://zhaokaifeng.com/?p=556 今天修改了一个远程仓库的项目名称,导致Git仓库的地址发生了变化,Push代码时显示"Git仓库找不到& ...
- Spring的两种任务调度Scheduled和Async
Spring提供了两种后台任务的方法,分别是: 调度任务,@Schedule 异步任务,@Async 当然,使用这两个是有条件的,需要在spring应用的上下文中声明<task:annotati ...
- javascript this 的工作原理
JavaScript 有一套完全不同于其它语言的对 this 的处理机制. 在五种不同的情况下 ,this 指向的各不相同. 1.全局范围内 当在全部范围内使用 this,它将会指向全局对象. 2.函 ...