1:
所需jar:jedis-2.1.0.jar:https://github.com/xetorthio/jedis https://github.com/xetorthio/jedis/downloads
spring-data-redis-1.1.9.RELEASE.jar:http://projects.spring.io/spring-data-redis/
2:属性文件:
# redis settings redis.pool.maxActive=1024 redis.pool.maxIdle=200 redis.pool.maxWait=1000 redis.pool.testOnBorrow=true redis.pool.testOnReturn=true redis.ip=192.168.6.146 redis.port=6379
3:Spring配置文件:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:cache="http://www.springframework.org/schema/cache" xmlns:c="http://www.springframework.org/schema/c"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd"
default-lazy-init="true">
<description>Redis 缓存配置</description>
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxActive" value="${redis.pool.maxActive}" />
<property name="maxIdle" value="${redis.pool.maxIdle}" />
<property name="maxWait" value="${redis.pool.maxWait}" />
<property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
<!-- <property name="testOnReturn" value="${redis.pool.testOnReturn}" /> -->
</bean>
<bean id="jedisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:use-pool="true">
<property name="hostName" value="${redis.ip}" />
<property name="port" value="${redis.port}" />
<property name="poolConfig" ref="jedisPoolConfig" />
</bean>
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
p:connection-factory-ref="jedisConnectionFactory" />
<bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"
p:connection-factory-ref="jedisConnectionFactory" />
<!-- 启用缓存支持 -->
<!-- turn on declarative caching -->
<cache:annotation-driven />
<!-- declare Redis Cache Manager -->
<bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager"
c:template-ref="redisTemplate" />
</beans>
4:工具类:
import java.util.List;
import org.springframework.data.redis.core.StringRedisTemplate;
import com.capitalbio.soft.core.utils.spring.SpringContextHolder;
public class ListOpsUtils {
public static StringRedisTemplate getStringRedisTemplate(){
return ((StringRedisTemplate)SpringContextHolder.getBean("stringRedisTemplate"));
}
/**
* 压栈
*
* @param key
* @param value
* @return
*/
public static Long push(String key, String value) {
return getStringRedisTemplate().opsForList().leftPush(key, value);
}
/**
* 出栈
*
* @param key
* @return
*/
public static String pop(String key) {
return getStringRedisTemplate().opsForList().leftPop(key);
}
/**
* 入队
*
* @param key
* @param value
* @return
*/
public static Long in(String key, String value) {
return getStringRedisTemplate().opsForList().rightPush(key, value);
}
/**
* 出队
*
* @param key
* @return
*/
public static String out(String key) {
return getStringRedisTemplate().opsForList().leftPop(key);
}
/**
* 栈/队列长
*
* @param key
* @return
*/
public static Long length(String key) {
return getStringRedisTemplate().opsForList().size(key);
}
/**
* 范围检索
*
* @param key
* @param start
* @param end
* @return
*/
public static List<String> range(String key, int start, int end) {
return getStringRedisTemplate().opsForList().range(key, start, end);
}
/**
* 移除
*
* @param key
* @param i
* @param value
*/
public static void remove(String key, long i, String value) {
getStringRedisTemplate().opsForList().remove(key, i, value);
}
/**
* 检索
*
* @param key
* @param index
* @return
*/
public static String index(String key, long index) {
return getStringRedisTemplate().opsForList().index(key, index);
}
/**
* 置值
*
* @param key
* @param index
* @param value
*/
public static void set(String key, long index, String value) {
getStringRedisTemplate().opsForList().set(key, index, value);
}
/**
* 裁剪
*
* @param key
* @param start
* @param end
*/
public static void trim(String key, long start, int end) {
getStringRedisTemplate().opsForList().trim(key, start, end);
}
}
5:单元测试:
import static org.junit.Assert.assertEquals;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.test.context.ContextConfiguration;
import com.capitalbio.soft.core.cache.redis.ListOpsUtils;
import com.capitalbio.soft.test.core.SpringTransactionalTestCase;
@ContextConfiguration(locations = { "/applicationContext.xml", "/applicationContext-redis.xml" })
public class ListOpsTest extends SpringTransactionalTestCase {
private String key = "queue";
@Before public void before() throws Exception {
System.out.println("------------IN---------------");
for (int i = 0; i < 5; i++) {
String uid = "u" + i;
System.out.println(uid);
ListOpsUtils.in(key, uid);
}
}
// 先进先出 - 队列 - FIFO (first in,first out)
@After public void after() {
// ------------OUT---------------
System.out.println("------------OUT---------------");
long length = ListOpsUtils.length(key);
for (long i = 0; i < length; i++) {
String uid = ListOpsUtils.out(key);
System.out.println(uid);
}
}
// 先进后出 - 栈 - LIFO(last in,first out)
@Test public void stack() {
// ------------PUSH---------------
String key = "stack";
int len = 5;
System.out.println("------------PUSH---------------");
for (int i = 0; i < len; i++) {
String uid = "u" + System.currentTimeMillis();
System.out.println(uid);
ListOpsUtils.push(key, uid);
}
long length = ListOpsUtils.length(key);
assertEquals(len, length);
// ------------POP---------------
System.out.println("------------POP---------------");
for (long i = 0; i < length; i++) {
String uid = ListOpsUtils.pop(key);
System.out.println(uid);
}
length = ListOpsUtils.length(key);
assertEquals(0, length);
}
@Test public void index() {
// -------------INDEX-------------
String value = ListOpsUtils.index(key, 3);
assertEquals("u3", value);
}
@Test
public void range() {
// -------------RANGE-------------
List<String> list = ListOpsUtils.range(key, 3, 5);
boolean result1 = list.contains("u3");
assertEquals(true, result1);
boolean result2 = list.contains("u1");
assertEquals(false, result2);
}
@Test
public void trim() {
// ------------TRIM---------------
List<String> list = ListOpsUtils.range(key, 3, 4);
ListOpsUtils.trim(key, 3, 4);
boolean result3 = list.contains("u1");
assertEquals(false, result3);
}
@Test
public void set() {
// ------------SET-----------------
List<String> list = ListOpsUtils.range(key, 3, 5);
ListOpsUtils.set(key, 4, "ux4");
boolean result4 = list.contains("u4");
assertEquals(true, result4);
}
@Test
public void remove() {
// ------------REMOVE-----------------
ListOpsUtils.remove(key, 4, "u4");
String value = ListOpsUtils.index(key, 4);
assertEquals(null, value);
}
}
6:基本用法单元测试:
import java.io.Serializable;
import java.util.List;
import javax.annotation.Resource;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import redis.clients.jedis.Jedis;
import com.capitalbio.soft.test.core.SpringTransactionalTestCase;
@ContextConfiguration(locations = { "/applicationContext.xml", "/applicationContext-redis.xml" })
public class JedisRedisTest extends SpringTransactionalTestCase {
private Logger logger = LoggerFactory.getLogger(getClass());
// @Autowired private ShardedJedisPool jedisPool;
@Resource(name="redisTemplate") private RedisTemplate<Serializable,Serializable> redisTemplate;
// @Resource(name="stringRedisTemplate") private StringRedisTemplate stringRedisTemplate;
@Test
public void testSimple() {
Jedis jedis = new Jedis("10.11.20.140");
String keys = "name";
// 存数据
jedis.set(keys, "snowolf");
// 取数据
String value = jedis.get(keys);
// 删数据
jedis.del(keys);
System.out.println(value);
}
/*
@Test
public void testJedisSpring() {
String key = "redis-jedis-integration";
ShardedJedis jedis = jedisPool.getResource();
String keyRet = jedis.set(key, "yes! it's wonderfull!"); // 将值保存到redis服务器
String valRet = jedis.get(key); // 从redis服务器获取值
jedis.del(key);
// 释放对象池
jedisPool.returnResource(jedis);
logger.debug("{} : {}", keyRet, valRet);
}
*/
@Test public void testJedisRedisTemplateGetSetDel() {
final String key = "test-redis-key";
final String val = "test-redis-val";
final byte[] serialKey = redisTemplate.getStringSerializer().serialize(key);
final byte[] serialVal = redisTemplate.getStringSerializer().serialize(val);
String ret = redisTemplate.execute(new RedisCallback<String>() {
@Override public String doInRedis(RedisConnection connection) throws DataAccessException {
// 普通 getset 操作
connection.set(serialKey, serialVal);
if(connection.exists(serialKey)) {
byte[] byteVal = connection.get(serialKey);
String retVal = redisTemplate.getStringSerializer().deserialize(byteVal);
long delCount = connection.del(serialKey);
return retVal + " ," + Long.toString(delCount) + " " + connection.exists(serialKey);
}
return null;
}
});
logger.debug("{}",ret);
}
@Test
public void testJedisRedisTemplatehMSet() {
final String key = "test-redis-key";
final String val = "test-redis-val";
final byte[] serialKey = redisTemplate.getStringSerializer().serialize(key);
final byte[] serialVal = redisTemplate.getStringSerializer().serialize(val);
final byte[] subSerialKey = redisTemplate.getStringSerializer().serialize("sub" + key);
final byte[] subSerialVal = redisTemplate.getStringSerializer().serialize("sub" + val);
redisTemplate.execute(new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
// HashTable操作
// 设置
BoundHashOperations<Serializable, byte[], byte[]> boundHashOperations = redisTemplate.boundHashOps(serialKey);
boundHashOperations.put(subSerialKey, subSerialVal);
boundHashOperations.put(serialKey, serialVal);
logger.debug("{}",connection.hMGet(serialVal, subSerialKey,serialVal).size());
logger.debug("{}",connection.hMGet(serialVal, subSerialKey,serialVal).get(0));
connection.hMSet(serialKey, boundHashOperations.entries());
// 获取
if(connection.exists(serialKey)) {
List<byte[]> value = connection.hMGet(serialKey, subSerialKey,serialKey);
String subRetVal = redisTemplate.getStringSerializer().deserialize(value.get(0));
String retVal = redisTemplate.getStringSerializer().deserialize(value.get(1));
logger.debug("{} : {}",subRetVal,retVal);
}
// 删除
long delCount = connection.del(serialKey);
logger.debug("del: {} {} {}",delCount,connection.exists(serialKey),connection.hMGet(serialKey, subSerialKey,serialKey).size());
return null;
}
});
}
@Test public void testJedisRedisTemplateListOps() {
redisTemplate.execute(new RedisCallback<Object>() {
@Override public Object doInRedis(RedisConnection connection) throws DataAccessException {
return null;
}
});
}
}
7:监控:Angel
https://github.com/litiebiao2012/redis-monitor
相关推荐
本项目聚焦于Spring Data与Jedis的集成，用于利用Redis作为缓存解决方案。Jedis是Java的一个开源客户端，专门用于连接和操作Redis服务器。 首先，让我们详细了解一下Spring Data。Spring Data是一个模块化的项目，...
Jedis 是 Java 开发者常用的 Redis 客户端库，而 Spring Data Redis 是 Spring 框架的一部分，它提供了与 Redis 集成的高级抽象。在“征服 Redis + Jedis + Spring （三）—— 列表操作”这一主题中，我们将深入探讨...
4. **Jedis和Lettuce客户端**：Spring Data Redis兼容两种主流的Redis Java客户端——Jedis和Lettuce。用户可以根据性能、功能需求以及社区支持情况选择合适的客户端。 5. **Redis Repositories**：Spring Data的...
本压缩包包含的“spring-session+spring+redis”组合，是将Spring Session与Redis集成，利用Redis作为会话存储介质，以实现高可用性和可扩展性。 首先，我们要了解Spring Session的核心概念。它通过替换默认的...
在Spring Boot中，可以通过Spring Data Redis库轻松地集成Redis，提供操作Redis的API，例如字符串、哈希、列表、集合和有序集合的操作。 4. **PageHelper**：PageHelper是Mybatis的一个插件，用于实现分页查询功能...
Spring Data Redis 纯英文文档，介绍spring操作redis的一些用法
标题提到的"redis+spring jedis方式"，意味着我们将讨论如何通过Spring Data Redis结合Jedis来操作Redis。首先，你需要在项目中引入Spring Data Redis库，版本如描述中所示为`spring-data-redis-1.3.4.RELEASE.jar`...
1. **连接池支持**：通过Jedis或Lettuce客户端库，Spring Data Redis提供了连接池管理，确保高效、可靠的Redis连接复用，从而提高应用性能。 2. **数据类型操作**：支持Redis中的基本数据类型，如字符串（String）...
在本篇博客“征服 Redis + Jedis + Spring （二）—— 哈希表操作（HMGET HMSET）”中，我们将深入探讨如何利用Redis、Jedis库以及Spring框架进行哈希表的操作，特别是`HMGET`和`HMSET`这两个重要的命令。...
* Spring Data Redis：用于与 Redis 进行交互 * Jedis：用于连接 Redis * Shiro Spring：用于权限控制 3. Redis 配置 在使用 Redis 之前，需要进行配置，包括： * 主机名或 IP 地址 * 端口号 * 密码 * 数据库 ID ...
例如，通过使用Spring Data Redis，开发者可以轻松地将数据缓存在Redis中，并通过Jedis或Lettuce客户端进行操作。 **整合Spring MVC、Security与Redis** 在实际项目中，Spring MVC、Security和Redis可以协同工作以...
Spring Data Redis提供了一套完整的框架，使得我们可以轻松地在Spring应用中集成Redis，而Jedis则作为基础的Redis客户端，实现了对Redis命令的全面覆盖。通过合理利用这两个库，开发者可以高效地构建基于Redis的高...
### Spring Data Redis中文参考文档知识点总结 #### 一、Spring Data Redis概述 **Spring Data Redis** 是Spring Data项目的一部分，它为开发人员提供了利用Redis这一高性能键值存储数据库的能力。该文档介绍了...
- **Redis配置**：引入Spring Data Redis库，配置RedisTemplate，并根据需要自定义序列化策略。还可以利用Lettuce或Jedis作为客户端库来操作Redis。 - **缓存管理**：在业务逻辑中，使用`@Cacheable`、`@...
通过Spring Data Redis，你可以使用Java或Groovy API来方便地执行Redis命令，并且支持Jedis和Lettuce两个主要的Redis客户端库。 Redis是一个开源的、基于键值对的数据存储系统，它支持多种数据结构，如字符串、哈希...
在给定的文件列表中，`spring-data-redis-1.1.0.RELEASE.jar`是Spring Data Redis的一个版本，而`jedis-2.1.0.jar`则是连接Redis的客户端库。确保添加正确的版本，因为它们可能会随着时间的推移而更新。 配置Spring...
1. **连接 Redis**：Spring Data Redis 提供了多种方式来配置 Redis 连接，如 Jedis、JRedis（已废弃）、SRP（已废弃）和 Lettuce。 - **Jedis Connector**：使用广泛且稳定的 Java 客户端 Jedis 进行连接配置。 -...
- SpringDataRedis支持两种主流的Redis Java客户端：Jedis和Lettuce。Jedis是较早的客户端，轻量级且广泛使用，适合简单快速的集成。Lettuce则提供了更现代的异步和反应式编程模型，适合高并发和复杂的分布式应用...
1. **连接池支持**：Spring Data Redis通过Jedis和Lettuce两种客户端库提供连接池服务，提高了资源利用率和系统性能。Jedis是早期常用的Redis客户端，而Lettuce则提供了更现代的、基于Netty的非阻塞I/O支持，为高...
这个压缩包文件“SpringDataRedis对Redis的数据类型的常用操作API的使用代码举例.zip”显然包含了关于如何利用Spring Data Redis进行Redis数据类型操作的示例代码。下面我们将深入探讨Spring Data Redis对Redis主要...