`
tzylwl
  • 浏览: 92089 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

redis 与 Spring 集成

阅读更多
ApplicationContent-reids.xml配置:
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

<context:property-placeholder location="classpath:redis.properties" />
<context:component-scan base-package="com.sc.ew.redis" />

<bean id="shardedJedisPools" class="redis.clients.jedis.ShardedJedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1">
<list>
<!-- <bean name="slaver" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="${redis.slaver.host}" />
<constructor-arg index="1" value="${redis.slaver.port}" type="int" />
</bean> -->
<bean name="master" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="192.168.1.250" />
<constructor-arg index="1" value="6379" type="int" />
<constructor-arg index="2" value="10000" type="int" />
</bean>
</list>
</constructor-arg>
</bean>

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="5000" />
<property name="maxIdle" value="1000" />
<property name="minIdle" value="50" />
<property name="numTestsPerEvictionRun" value="1024" />
<property name="timeBetweenEvictionRunsMillis" value="30000" />
<property name="minEvictableIdleTimeMillis" value="-1" />
<property name="softMinEvictableIdleTimeMillis" value="10000" />
<property name="maxWaitMillis" value="10000" />
<property name="testOnBorrow" value="true" />
<property name="testWhileIdle" value="true" />
<property name="testOnReturn" value="false" />
<property name="jmxEnabled" value="true" />
<property name="jmxNamePrefix" value="youyuan" />
<property name="blockWhenExhausted" value="false" />
</bean>
</beans>




package com.sc.ew.redis.dao.source;

import redis.clients.jedis.ShardedJedis;

public interface RedisDataSource {
/**
* 取得redis的客户端,可以执行命令了。
* @return
*/
public abstract ShardedJedis getRedisClient();

public void returnResource(ShardedJedis shardedJedis);// 将资源返还给pool

public void returnResource(ShardedJedis shardedJedis, boolean broken);// 出现异常后,将资源返还给pool (其实不需要第二个方法)
}





package com.sc.ew.redis.dao.source.impl;

import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import com.sc.ew.redis.dao.source.RedisDataSource;

@Repository
public class RedisDataSourceImpl implements RedisDataSource {

private static final Logger logger = Logger
.getLogger(RedisDataSourceImpl.class);

@Resource
private ShardedJedisPool shardedJedisPool;

public ShardedJedis getRedisClient() {
try {
ShardedJedis shardJedis = shardedJedisPool.getResource();
return shardJedis;
} catch (Exception e) {
logger.error("getRedisClent error", e);
}
return null;
}

public void returnResource(ShardedJedis shardedJedis) {
shardedJedisPool.returnResource(shardedJedis);
}

public void returnResource(ShardedJedis shardedJedis, boolean broken) {
if (broken) {
shardedJedisPool.returnBrokenResource(shardedJedis);
} else {
shardedJedisPool.returnResource(shardedJedis);
}
}
}




package com.sc.ew.redis.template;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.sc.ew.redis.dao.source.RedisDataSource;
import com.sc.ew.redis.util.SerializationUtils;
import redis.clients.jedis.ShardedJedis;

@Repository
public class RedisHashTemplate {

private static final Logger logger = Logger
.getLogger(RedisHashTemplate.class);

@Autowired
private RedisDataSource redisDataSource;

public void disconnect() {
ShardedJedis shardedJedis = redisDataSource.getRedisClient();
shardedJedis.disconnect();
}

/**
* 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在,一个新的哈希表被创建并进行 HSET 操作。 如果域
* field 已经存在于哈希表中,旧值将被覆盖。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hset(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hset(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在,一个新的哈希表被创建并进行 HSET 操作。 如果域
* field 已经存在于哈希表中,旧值将被覆盖。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hsetObject(String key, String field, Object object) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hset(key.getBytes(), field.getBytes(),
SerializationUtils.serialize(object));
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中给定域 field 的值。
*
* @param key
* @param field
* @return
*/
public String hget(String key, String field) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hget(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中给定域 field 的值。
*
* @param key
* @param field
* @return
*/
public Object hgetObject(String key, String field) {
Object result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = SerializationUtils.deserialize(shardedJedis.hget(
key.getBytes(), field.getBytes()));
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 将哈希表 key 中的域 field 的值设置为 value ,当且仅当域 field 不存在。 若域 field 已经存在,该操作无效。 如果
* key 不存在,一个新哈希表被创建并执行 HSETNX 命令。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hsetnx(String key, String field, String value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hsetnx(key, field, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmset(String key, Map<String, String> hash) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hmset(key, hash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmsetObject(String key, Map<String, Object> hashs) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> byteHash = new HashMap<byte[], byte[]>();
for (Map.Entry<String, Object> setMap : hashs.entrySet()) {
String keyMap = setMap.getKey();
Object valMap = setMap.getValue();
byteHash.put(keyMap.getBytes(),
SerializationUtils.serialize(valMap));
}

result = shardedJedis.hmset(key.getBytes(), byteHash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。
*
* @param key
* @param hash
* @return
*/
public String hmsetMapObject(String key, Map<String, Map<String, Object>> hashs) {
String result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> byteHash = new HashMap<byte[], byte[]>();
for (Map.Entry<String, Map<String, Object>> setMap : hashs.entrySet()) {
String keyMap = setMap.getKey();
Object valMap = setMap.getValue();
byteHash.put(keyMap.getBytes(),
SerializationUtils.serialize(valMap));
}

result = shardedJedis.hmset(key.getBytes(), byteHash);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中,一个或多个给定域的值。 如果给定的域不存在于哈希表,那么返回一个 nil 值。
*
* @param key
* @param fields
* @return
*/
public List<String> hmget(String key, String... fields) {
List<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hmget(key, fields);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中,一个或多个给定域的值。 如果给定的域不存在于哈希表,那么返回一个 nil 值。
*
* @param key
* @param fields
* @return
*/
public List<Object> hmgetObject(String key, String... fields) {
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
byte[][] bytes = new byte[fields.length][];
for (int i = 0; i < fields.length; i++) {
bytes[i] = fields[i].getBytes();
}
List<byte[]> resultList = shardedJedis.hmget(key.getBytes(), bytes);
List<Object> resultObject = new ArrayList<Object>();
for (byte[] byteList : resultList) {
resultObject.add(SerializationUtils.deserialize(byteList));
}
return resultObject;
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return null;
}

/**
* 为哈希表 key 中的域 field 的值加上增量 increment 。 增量也可以为负数,相当于对给定域进行减法操作。
*
* @param key
* @param field
* @param value
* @return
*/
public Long hincrBy(String key, String field, long value) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hincrBy(key, field, value);

} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 查看哈希表 key 中,给定域 field 是否存在。
*
* @param key
* @param field
* @return
*/
public Boolean hexists(String key, String field) {
Boolean result = false;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hexists(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。
*
* @param key
* @param field
* @return
*/
public Long hdelAll(String key) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Set<String> keys = hkeys(key);
if(keys.size() > 0){
String[] arr = new String[keys.size()];
keys.toArray(arr);
result = hdel(key, arr);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。
*
* @param key
* @param field
* @return
*/
public Long hdel(String key, String... field) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hdel(key, field);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中域的数量。
*
* @param key
* @return
*/
public Long hlen(String key) {
Long result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hlen(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中的所有域。
*
* @param key
* @return
*/
public Set<String> hkeys(String key) {
Set<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hkeys(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中所有域的值。
*
* @param key
* @return
*/
public List<String> hvals(String key) {
List<String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hvals(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中,所有的域和值。 在返回值里,紧跟每个域名(field
* name)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。
*
* @param key
* @return
*/
public Map<String, String> hgetAll(String key) {
Map<String, String> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
result = shardedJedis.hgetAll(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}

/**
* 返回哈希表 key 中,所有的域和值。 在返回值里,紧跟每个域名(field
* name)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。
*
* @param key
* @return
*/
public Map<String, Object> hgetAllObject(String key) {
Map<String, Object> result = null;
ShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = redisDataSource.getRedisClient();
Map<byte[], byte[]> resultByteMap = shardedJedis.hgetAll(key
.getBytes());
result = new HashMap<String, Object>();
for (Map.Entry<byte[], byte[]> entrySet : resultByteMap.entrySet()) {
byte[] keyMap = entrySet.getKey();
byte[] valMap = entrySet.getValue();
result.put(new String(keyMap),
SerializationUtils.deserialize(valMap));
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
}finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
return result;
}
}
分享到:
评论

相关推荐

    Redis与Spring集成

    将Redis与Spring集成,可以充分利用Redis的强大功能,同时利用Spring的便捷性。 集成Redis与Spring主要通过Spring Data Redis模块实现。Spring Data Redis提供了对Redis的高级抽象,包括模板类、Repository支持以及...

    redis+spring jedis方式

    【Redis与Spring集成】 Redis,一个高性能的键值对存储系统,常被用作数据库、缓存和消息中间件。其高效性能得益于内存存储和基于键值的数据结构。Spring Data Redis是Spring框架的一个模块,目的是简化Redis在Java...

    Redis集成Spring的Java代码

    这样,我们便完成了Redis与Spring的集成,能够方便地使用Java代码对Redis进行各种操作。记住,合理利用Redis的特性(如批量操作、订阅发布等)可以显著提高应用的性能和响应速度。在实际项目中,根据业务需求进行...

    SpringCloud整合Redis

    SpringCloud整合Redis缓存;版本:SpringCloud :Dalston.SR4;SpringBoot:1.5.14.RELEASE;Redis:3.2.0;Maven :3.5.3.代码下载下来即可用

    spring集成redis,spring mvc实现session共享以及redis排行榜.zip

    spring集成redis,spring mvc实现session共享以及redis排行榜春季会议Redis这一系列项目,将会有多个spring相关的简单的例子,包括session-with-redis、spring整合redis等1、在springmvc项目session存储到redis中...

    Spring3.0整合redis相关jar

    Spring 3.0虽然相对较老,但在当时是广泛使用的版本,因此了解其与Redis的集成方式对维护旧项目或理解历史背景很有帮助。 首先,我们需要引入Redis的相关jar包。在"redis必须jar"中,通常包括以下组件: 1. `jedis....

    redis集成spring jar包以及配置文件

    spring-data-redis-1.6.2.RELEASE.jar spring与redis集成包 commons-pool2-2.4.2.jar 与redis连接池 spring-data-commons-2.0.0.RC2.jar spring数据包 redis-context.xml redis和spring配置,需要引用到自己项目的...

    redis和spring整合

    将Redis与Spring整合,可以充分利用Redis的高速存储优势,提升应用程序的性能。本文将深入探讨如何进行Redis与Spring的整合,并详细解析整合过程中的关键步骤。 首先,我们要理解Spring对数据源的支持。Spring提供...

    redis与spring整合

    我们将深入探讨如何在Spring框架中集成Redis,并通过注解方式实现数据的存取。 首先,Redis作为缓存系统,可以大大提高应用程序的响应速度,减少对数据库的直接访问,从而降低系统负载。在Spring中整合Redis,我们...

    redis与springcache集成

    总的来说,集成Redis与Spring Cache可以简化缓存的管理和使用,通过合理配置和使用,能够有效地提升系统的响应速度和效率。在实际开发中,应根据业务需求调整缓存策略,例如设置合适的缓存过期时间,以及处理缓存和...

    在Spring体系中使用redis.spring集成redis缓存

    Spring框架提供了多种方式来集成Redis,其中最常用的是通过`Spring-data-redis`模块。这个模块提供了对Redis操作的高级抽象,使得在Spring应用中使用Redis变得简单。 **一、集成步骤** 1. **依赖添加**:首先,在...

    redis-spring-boot-starter.rar

    `redis-spring-boot-starter`是Spring Boot生态中的一个启动器(Starter),它简化了Redis与Spring Boot集成的过程,使得开发者无需手动配置复杂的Redis连接参数,就能快速地在应用中启用Redis服务。这个启动器通常...

    spring集成redis源码

    spring和redis集成有很多方式,看到网上很多都是使用redistemplate自己去做redis 的一些操作,但是对于我们开发来说,肯定是使用越方便越好,于是乎就有了spring的对redis或者memcahe这些换成框架的封装,只需要引入...

    spring+springmvc+mybatis+redis框架

    将Redis与Spring集成,可以轻松地在应用中实现缓存功能,提高系统的响应速度和数据一致性。 在这个"spring+springmvc+mybatis+redis框架"的示例中,开发者可能已经创建了一个完整的Web应用,其中: 1. Spring作为...

    Spring集成redis集群

    **Spring集成Redis集群详解** 在现代的Web应用程序开发中,数据缓存扮演着至关重要的角色,而Redis作为一款高性能的键值数据存储系统,被广泛应用于缓存、消息队列等多个场景。当业务规模扩大,单机Redis可能无法...

    redis与spring的整合

    本文将详细介绍如何在Spring应用中集成Redis,以及如何操作String、list、set、map四种基本数据类型。 一、整合步骤 1. **环境配置**:首先确保本地安装了Redis服务器,并且能够在应用中访问。同时,添加Redis的...

    springBoot集成redis

    在IT行业中,Spring Boot是一个非常流行的微服务框架,它简化了Spring应用的初始搭建...通过这样的集成,我们可以利用Spring Boot的便利性,结合Redis的高速缓存能力与MyBatis的数据库操作,构建出高效稳定的Web应用。

    Spring-session2整合spring5+redis

    标题中的“Spring-session2整合spring5+redis”指的是在Spring框架的第五个主要版本(Spring 5)中,集成Spring Session 2与Redis数据库来管理Web应用的会话(Session)。Spring Session是一个开源项目,旨在提供一...

    shiro-redis集成的spring的web项目

    在这个项目中,Spring负责整体架构的管理,包括依赖注入、AOP(面向切面编程)以及与Shiro和Redis的集成。 **Shiro与Spring的集成** 将Shiro与Spring结合,可以利用Spring的IOC容器管理Shiro的组件,如Realm(领域...

    redis集成spring实现aop.zip

    当我们谈论"redis集成spring实现aop"时,我们指的是如何将Redis缓存系统与Spring框架结合,并利用Spring的面向切面编程(AOP)功能来优化应用程序的性能。 首先,让我们深入了解Redis。Redis是一种内存数据结构存储...

Global site tag (gtag.js) - Google Analytics