spring整合Redis
关键
1. 了解重要的jar包
spring-data-redis jedis
2. 了解注入的bean有什么作用
Java和Redis的连接池配置 redis.clients.jedis.JedisPoolConfig 通过spring的factory和jedis连接池信息，创建连接 org.springframework.data.redis.connection.jedis.JedisConnectionFactory 对Redis进行增删改查的包装类 org.springframework.data.redis.core.StringRedisTemplate
代码
必须在pom中加入jar包
<dependencies>
<!-- spring对Redis操作的封装和建立连接，操作 key - value 数据更简单 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.0.2.RELEASE</version>
</dependency>
<!-- 用于java和Redis建立连接池 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.1.0</version>
</dependency>
</dependencies>
将需要装配的bean，配置到applicationContext.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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
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">
<!-- 加载配置文件 -->
<context:property-placeholder location="classpath:redis.properties" />
<!-- jedis连接池配置，如Redis的连接池配置 -->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="maxActive" value="${redis.maxActive}" />
<property name="maxWait" value="${redis.maxWait}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
</bean>
<!-- 通过factory和连接池配置，建立与Redis的连接 -->
<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/>
<!-- 用户对Redis进行增删改查的包装类 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
<property name="connectionFactory" ref="connectionFactory" />
</bean>
<bean id="userDao" class="com.x.dao.impl.UserDao" />
</beans>
redis.properties
# Redis settings redis.host=localhost redis.port=6379 redis.pass=java2000_wl redis.maxIdle=300 redis.maxActive=600 redis.maxWait=1000 redis.testOnBorrow=true
javabean
package com.x.entity;
import java.io.Serializable;
/**
* @author http://blog.csdn.net/java2000_wl
* @version <b>1.0</b>
*/
public class User implements Serializable {
private static final long serialVersionUID = -6011241820070393952L;
private String id;
private String name;
private String password;
/**
* <br>------------------------------<br>
*/
public User() {
}
/**
* <br>------------------------------<br>
*/
public User(String id, String name, String password) {
super();
this.id = id;
this.name = name;
this.password = password;
}
/**
* 获得id
* @return the id
*/
public String getId() {
return id;
}
/**
* 设置id
* @param id the id to set
*/
public void setId(String id) {
this.id = id;
}
/**
* 获得name
* @return the name
*/
public String getName() {
return name;
}
/**
* 设置name
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* 获得password
* @return the password
*/
public String getPassword() {
return password;
}
/**
* 设置password
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}
}
Dao抽象类
package com.x.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
/**
* AbstractBaseRedisDao
* @author http://blog.csdn.net/java2000_wl
* @version <b>1.0</b>
*/
public abstract class AbstractBaseRedisDao<K, V> {
@Autowired
protected RedisTemplate<K, V> redisTemplate;
/**
* 设置redisTemplate
* @param redisTemplate the redisTemplate to set
*/
public void setRedisTemplate(RedisTemplate<K, V> redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* 获取 RedisSerializer
* <br>------------------------------<br>
*/
protected RedisSerializer<String> getRedisSerializer() {
return redisTemplate.getStringSerializer();
}
}
Dao接口
package com.x.dao;
import java.util.List;
import com.x.entity.User;
/**
* @author http://blog.csdn.net/java2000_wl
* @version <b>1.0</b>
*/
public interface IUserDao {
/**
* 新增
* <br>------------------------------<br>
* @param user
* @return
*/
boolean add(User user);
/**
* 批量新增 使用pipeline方式
* <br>------------------------------<br>
* @param list
* @return
*/
boolean add(List<User> list);
/**
* 删除
* <br>------------------------------<br>
* @param key
*/
void delete(String key);
/**
* 删除多个
* <br>------------------------------<br>
* @param keys
*/
void delete(List<String> keys);
/**
* 修改
* <br>------------------------------<br>
* @param user
* @return
*/
boolean update(User user);
/**
* 通过key获取
* <br>------------------------------<br>
* @param keyId
* @return
*/
User get(String keyId);
}
Dao实现类
package com.x.dao.impl;
import java.util.ArrayList;
import java.util.List;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.util.Assert;
import com.x.dao.AbstractBaseRedisDao;
import com.x.dao.IUserDao;
import com.x.entity.User;
/**
* Dao
* @author http://blog.csdn.net/java2000_wl
* @version <b>1.0</b>
*/
public class UserDao extends AbstractBaseRedisDao<String, User> implements IUserDao {
/**
* 新增
*<br>------------------------------<br>
* @param user
* @return
*/
public boolean add(final User user) {
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer<String> serializer = getRedisSerializer();
byte[] key = serializer.serialize(user.getId());
byte[] name = serializer.serialize(user.getName());
return connection.setNX(key, name);
}
});
return result;
}
/**
* 批量新增 使用pipeline方式
*<br>------------------------------<br>
*@param list
*@return
*/
public boolean add(final List<User> list) {
Assert.notEmpty(list);
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer<String> serializer = getRedisSerializer();
for (User user : list) {
byte[] key = serializer.serialize(user.getId());
byte[] name = serializer.serialize(user.getName());
connection.setNX(key, name);
}
return true;
}
}, false, true);
return result;
}
/**
* 删除
* <br>------------------------------<br>
* @param key
*/
public void delete(String key) {
List<String> list = new ArrayList<String>();
list.add(key);
delete(list);
}
/**
* 删除多个
* <br>------------------------------<br>
* @param keys
*/
public void delete(List<String> keys) {
redisTemplate.delete(keys);
}
/**
* 修改
* <br>------------------------------<br>
* @param user
* @return
*/
public boolean update(final User user) {
String key = user.getId();
if (get(key) == null) {
throw new NullPointerException("数据行不存在, key = " + key);
}
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer<String> serializer = getRedisSerializer();
byte[] key = serializer.serialize(user.getId());
byte[] name = serializer.serialize(user.getName());
connection.set(key, name);
return true;
}
});
return result;
}
/**
* 通过key获取
* <br>------------------------------<br>
* @param keyId
* @return
*/
public User get(final String keyId) {
User result = redisTemplate.execute(new RedisCallback<User>() {
public User doInRedis(RedisConnection connection)
throws DataAccessException {
RedisSerializer<String> serializer = getRedisSerializer();
byte[] key = serializer.serialize(keyId);
byte[] value = connection.get(key);
if (value == null) {
return null;
}
String name = serializer.deserialize(value);
return new User(keyId, name, null);
}
});
return result;
}
}
测试类
import java.util.ArrayList;
import java.util.List;
import junit.framework.Assert;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import com.x.dao.IUserDao;
import com.x.entity.User;
/**
* 测试
* @author http://blog.csdn.net/java2000_wl
* @version <b>1.0</b>
*/
@ContextConfiguration(locations = {"classpath*:applicationContext.xml"})
public class RedisTest extends AbstractJUnit4SpringContextTests {
@Autowired
private IUserDao userDao;
/**
* 新增
* <br>------------------------------<br>
*/
@Test
public void testAddUser() {
User user = new User();
user.setId("user1");
user.setName("java2000_wl");
boolean result = userDao.add(user);
Assert.assertTrue(result);
}
/**
* 批量新增 普通方式
* <br>------------------------------<br>
*/
@Test
public void testAddUsers1() {
List<User> list = new ArrayList<User>();
for (int i = 10; i < 50000; i++) {
User user = new User();
user.setId("user" + i);
user.setName("java2000_wl" + i);
list.add(user);
}
long begin = System.currentTimeMillis();
for (User user : list) {
userDao.add(user);
}
System.out.println(System.currentTimeMillis() - begin);
}
/**
* 批量新增 pipeline方式
* <br>------------------------------<br>
*/
@Test
public void testAddUsers2() {
List<User> list = new ArrayList<User>();
for (int i = 10; i < 1500000; i++) {
User user = new User();
user.setId("user" + i);
user.setName("java2000_wl" + i);
list.add(user);
}
long begin = System.currentTimeMillis();
boolean result = userDao.add(list);
System.out.println(System.currentTimeMillis() - begin);
Assert.assertTrue(result);
}
/**
* 修改
* <br>------------------------------<br>
*/
@Test
public void testUpdate() {
User user = new User();
user.setId("user1");
user.setName("new_password");
boolean result = userDao.update(user);
Assert.assertTrue(result);
}
/**
* 通过key删除单个
* <br>------------------------------<br>
*/
@Test
public void testDelete() {
String key = "user1";
userDao.delete(key);
}
/**
* 批量删除
* <br>------------------------------<br>
*/
@Test
public void testDeletes() {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10; i++) {
list.add("user" + i);
}
userDao.delete(list);
}
/**
* 获取
* <br>------------------------------<br>
*/
@Test
public void testGetUser() {
String id = "user1";
User user = userDao.get(id);
Assert.assertNotNull(user);
Assert.assertEquals(user.getName(), "java2000_wl");
}
/**
* 设置userDao
* @param userDao the userDao to set
*/
public void setUserDao(IUserDao userDao) {
this.userDao = userDao;
}
}
参考：
http://blog.csdn.net/java2000_wl/article/details/8543203/
相关推荐
spring和redis集成有很多方式，看到网上很多都是使用redistemplate自己去做redis 的一些操作，但是对于我们开发来说，肯定是使用越方便越好，于是乎就有了spring的对redis或者memcahe这些换成框架的封装，只需要引入...
Spring框架提供了丰富的集成支持，使得与其他技术的整合变得非常方便。整合Spring和Redis可以带来以下好处： 1. 提高性能：Redis作为内存数据库，读写速度极快，适合处理大量并发请求。 2. 支持多种数据结构：Redis...
通过Spring Data Redis，开发者可以轻松地集成Redis，实现数据的持久化、缓存等功能。它支持Jedis和Lettuce两种Redis客户端库，提供了Template和Reactive API供开发者选择。 二、Spring Boot与Redis集成 在Spring ...
**Spring集成Redis集群详解** 在现代的Web应用程序开发中，数据缓存扮演着至关重要的角色，而Redis作为一款高性能的键值数据存储系统，被广泛应用于缓存、消息队列等多个场景。当业务规模扩大，单机Redis可能无法...
总的来说，Spring整合Redis使得在Java应用中使用Redis变得更加便捷，无论是简单的字符串操作还是复杂的对象存储，都能通过Spring提供的工具轻松实现。通过上述步骤，你可以构建一个基本的Spring-Redis集成系统，...
本文将深入探讨如何在Spring项目中集成Redis的单节点、集群和哨兵模式。 首先，让我们来看**单节点配置**。在Spring中集成Redis单节点，我们需要在Spring的配置文件中定义RedisConnectionFactory。这通常通过...
接下来，我们将深入探讨如何在Spring项目中集成Redis。 首先，我们要准备集成Redis所需的依赖。在描述中提到了`spring-data-redis.jar`和`jedis.jar`，这两个是关键组件。`spring-data-redis`是Spring Data项目的一...
当我们谈论“Spring集成Redis集群”时，这意味着我们要在Spring应用中配置和使用多个Redis实例，形成一个高可用、高并发的数据库解决方案。 首先，让我们深入理解Spring对Redis支持的基本概念。Spring Data Redis...
让我们深入探讨Spring集成Redis的相关知识点。 1. **Spring Data Redis简介** Spring Data Redis项目是为了简化Redis在Java应用中的使用而设计的。它提供了高度抽象的API，可以方便地操作Redis数据结构，如字符串...
除了单元测试，还可以编写集成测试，模拟实际环境中的操作，确保Spring与Redis的整合在真实场景下也能正常工作。可以使用`@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)`启动一个...
Spring整合Redis完整实例代码，下载经简单的修改配置文件，即可运行，代码中有详细的注释，关于代码的详情可参见博文：http://blog.csdn.net/l1028386804/article/details/52108758
"spring集成redis需要的jar包.rar"这个压缩包包含的两个关键文件，`jedis-3.1.0.jar`和`spring-data-redis-2.1.9.RELEASE.jar`，就是这样的关键库。 首先，`jedis-3.1.0.jar`是Jedis客户端，它是Java语言连接Redis...
本文将详细介绍如何在Spring MVC中整合Redis，并利用连接池来优化性能。 首先，我们需要引入Redis的相关依赖。在Maven项目中，可以在pom.xml文件中添加`spring-data-redis`和`jedis`库，这两个库分别提供了Spring对...
至此，你已经掌握了Spring整合Redis作为缓存的基本步骤。这种方式能够有效地提高应用程序的性能，减少对数据库的访问，同时利用Redis的高速读写能力。在实际开发中，还可以根据需求调整序列化策略、缓存策略等，以...
"Spring3.0整合redis相关jar"这个主题主要涉及的是如何在Spring 3.0版本中集成Redis作为数据存储或缓存解决方案。Spring 3.0虽然相对较老，但在当时是广泛使用的版本，因此了解其与Redis的集成方式对维护旧项目或...
SpringCloud整合Redis缓存；版本：SpringCloud ：Dalston.SR4；SpringBoot：1.5.14.RELEASE；Redis:3.2.0;Maven :3.5.3.代码下载下来即可用
Spring + redis集群的集成 spring-data-redis-1.8.1.RELEASE.jar jedis-2.9.0.jar spring-data-commons-1.8.1.RELEASE.jar commons-pool2-2.4.2.jar
总结来说，Spring整合Redis哨兵模式涉及了Spring Boot的配置、哨兵系统的理解、连接工厂的创建、数据序列化、CRUD操作以及异常处理等多个知识点。通过这样的整合，我们可以构建出高可用、容错性强的Redis服务，为...
在Java Spring框架中集成Redis作为缓存或消息队列是一个常见的需求。Redis是一个高性能的键值存储系统，常用于数据库、缓存和消息代理。在Java应用中使用Spring框架进行集成，可以极大地提升应用程序的数据处理效率...