`
jaesonchen
  • 浏览: 310036 次
  • 来自: ...
社区版块
存档分类
最新评论

Spring 整合 Redis

 
阅读更多

pom构建:

 

[html] view plain copy
 
 print?
  1. <modelVersion>4.0.0</modelVersion>  
  2. <groupId>com.x.redis</groupId>  
  3. <artifactId>springredis</artifactId>  
  4. <version>0.0.1-SNAPSHOT</version>  
  5.   
  6. <dependencies>  
  7.     <dependency>  
  8.         <groupId>org.springframework.data</groupId>  
  9.         <artifactId>spring-data-redis</artifactId>  
  10.         <version>1.0.2.RELEASE</version>  
  11.     </dependency>  
  12.     <dependency>  
  13.         <groupId>org.springframework</groupId>  
  14.         <artifactId>spring-test</artifactId>  
  15.         <version>3.1.2.RELEASE</version>  
  16.         <scope>test</scope>  
  17.     </dependency>  
  18.       
  19.     <dependency>  
  20.         <groupId>redis.clients</groupId>  
  21.         <artifactId>jedis</artifactId>  
  22.         <version>2.1.0</version>  
  23.     </dependency>  
  24.       
  25.      <dependency>  
  26.         <groupId>junit</groupId>  
  27.         <artifactId>junit</artifactId>  
  28.         <version>4.8.2</version>  
  29.         <scope>test</scope>  
  30.     </dependency>  
  31. </dependencies>  


spring配置文件(applicationContext.xml):

 

[html] view plain copy
 
 print?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  4.     xmlns:context="http://www.springframework.org/schema/context"  
  5.     xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"  
  6.     xmlns:aop="http://www.springframework.org/schema/aop"  
  7.     xsi:schemaLocation="  
  8.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
  9.             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  
  10.   
  11.     <context:property-placeholder location="classpath:redis.properties" />  
  12.   
  13.     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
  14.         <property name="maxIdle" value="${redis.maxIdle}" />  
  15.         <property name="maxActive" value="${redis.maxActive}" />  
  16.         <property name="maxWait" value="${redis.maxWait}" />  
  17.         <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
  18.     </bean>  
  19.       
  20.     <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
  21.         p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  p:pool-config-ref="poolConfig"/>  
  22.       
  23.     <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  
  24.         <property name="connectionFactory"   ref="connectionFactory" />  
  25.     </bean>         
  26.       
  27.     <bean id="userDao" class="com.x.dao.impl.UserDao" />   
  28. </beans>  

redis.properties

 

 

[html] view plain copy
 
 print?
  1. # Redis settings  
  2. redis.host=localhost  
  3. redis.port=6379  
  4. redis.pass=java2000_wl  
  5.   
  6.   
  7. redis.maxIdle=300  
  8. redis.maxActive=600  
  9. redis.maxWait=1000  
  10. redis.testOnBorrow=true  

 

Java代码:

 

[java] view plain copy
 
 print?
  1. package com.x.entity;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. /**  
  6.  * @author http://blog.csdn.net/java2000_wl  
  7.  * @version <b>1.0</b>  
  8.  */   
  9. public class User implements Serializable {  
  10.       
  11.     private static final long serialVersionUID = -6011241820070393952L;  
  12.   
  13.     private String id;  
  14.       
  15.     private String name;  
  16.       
  17.     private String password;  
  18.   
  19.     /** 
  20.      * <br>------------------------------<br> 
  21.      */  
  22.     public User() {  
  23.           
  24.     }  
  25.       
  26.     /** 
  27.      * <br>------------------------------<br> 
  28.      */  
  29.     public User(String id, String name, String password) {  
  30.         super();  
  31.         this.id = id;  
  32.         this.name = name;  
  33.         this.password = password;  
  34.     }  
  35.   
  36.     /** 
  37.      * 获得id 
  38.      * @return the id 
  39.      */  
  40.     public String getId() {  
  41.         return id;  
  42.     }  
  43.   
  44.     /** 
  45.      * 设置id 
  46.      * @param id the id to set 
  47.      */  
  48.     public void setId(String id) {  
  49.         this.id = id;  
  50.     }  
  51.   
  52.     /** 
  53.      * 获得name 
  54.      * @return the name 
  55.      */  
  56.     public String getName() {  
  57.         return name;  
  58.     }  
  59.   
  60.     /** 
  61.      * 设置name 
  62.      * @param name the name to set 
  63.      */  
  64.     public void setName(String name) {  
  65.         this.name = name;  
  66.     }  
  67.   
  68.     /** 
  69.      * 获得password 
  70.      * @return the password 
  71.      */  
  72.     public String getPassword() {  
  73.         return password;  
  74.     }  
  75.   
  76.     /** 
  77.      * 设置password 
  78.      * @param password the password to set 
  79.      */  
  80.     public void setPassword(String password) {  
  81.         this.password = password;  
  82.     }  
  83. }  
[java] view plain copy
 
 print?
  1. package com.x.dao;  
  2.   
  3. import org.springframework.beans.factory.annotation.Autowired;  
  4. import org.springframework.data.redis.core.RedisTemplate;  
  5. import org.springframework.data.redis.serializer.RedisSerializer;  
  6.   
  7. /**  
  8.  * AbstractBaseRedisDao 
  9.  * @author http://blog.csdn.net/java2000_wl  
  10.  * @version <b>1.0</b>  
  11.  */   
  12. public abstract class AbstractBaseRedisDao<K, V> {  
  13.       
  14.     @Autowired  
  15.     protected RedisTemplate<K, V> redisTemplate;  
  16.   
  17.     /** 
  18.      * 设置redisTemplate 
  19.      * @param redisTemplate the redisTemplate to set 
  20.      */  
  21.     public void setRedisTemplate(RedisTemplate<K, V> redisTemplate) {  
  22.         this.redisTemplate = redisTemplate;  
  23.     }  
  24.       
  25.     /** 
  26.      * 获取 RedisSerializer 
  27.      * <br>------------------------------<br> 
  28.      */  
  29.     protected RedisSerializer<String> getRedisSerializer() {  
  30.         return redisTemplate.getStringSerializer();  
  31.     }  
  32. }  
[java] view plain copy
 
 print?
  1. package com.x.dao;  
  2.   
  3. import java.util.List;  
  4.   
  5. import com.x.entity.User;  
  6.   
  7. /**  
  8.  * @author http://blog.csdn.net/java2000_wl  
  9.  * @version <b>1.0</b>  
  10.  */   
  11. public interface IUserDao {  
  12.       
  13.     /** 
  14.      * 新增 
  15.      * <br>------------------------------<br> 
  16.      * @param user 
  17.      * @return 
  18.      */  
  19.     boolean add(User user);  
  20.       
  21.     /** 
  22.      * 批量新增 使用pipeline方式 
  23.      * <br>------------------------------<br> 
  24.      * @param list 
  25.      * @return 
  26.      */  
  27.     boolean add(List<User> list);  
  28.       
  29.     /** 
  30.      * 删除 
  31.      * <br>------------------------------<br> 
  32.      * @param key 
  33.      */  
  34.     void delete(String key);  
  35.       
  36.     /** 
  37.      * 删除多个 
  38.      * <br>------------------------------<br> 
  39.      * @param keys 
  40.      */  
  41.     void delete(List<String> keys);  
  42.       
  43.     /** 
  44.      * 修改 
  45.      * <br>------------------------------<br> 
  46.      * @param user 
  47.      * @return  
  48.      */  
  49.     boolean update(User user);  
  50.   
  51.     /** 
  52.      * 通过key获取 
  53.      * <br>------------------------------<br> 
  54.      * @param keyId 
  55.      * @return  
  56.      */  
  57.     User get(String keyId);  
  58. }  
[java] view plain copy
 
 print?
  1. package com.x.dao.impl;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. import org.springframework.dao.DataAccessException;  
  7. import org.springframework.data.redis.connection.RedisConnection;  
  8. import org.springframework.data.redis.core.RedisCallback;  
  9. import org.springframework.data.redis.serializer.RedisSerializer;  
  10. import org.springframework.util.Assert;  
  11.   
  12. import com.x.dao.AbstractBaseRedisDao;  
  13. import com.x.dao.IUserDao;  
  14. import com.x.entity.User;  
  15.   
  16. /**  
  17.  * Dao 
  18.  * @author http://blog.csdn.net/java2000_wl  
  19.  * @version <b>1.0</b>  
  20.  */   
  21. public class UserDao extends AbstractBaseRedisDao<String, User> implements IUserDao {  
  22.   
  23.     /**  
  24.      * 新增 
  25.      *<br>------------------------------<br> 
  26.      * @param user 
  27.      * @return 
  28.      */  
  29.     public boolean add(final User user) {  
  30.         boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
  31.             public Boolean doInRedis(RedisConnection connection)  
  32.                     throws DataAccessException {  
  33.                 RedisSerializer<String> serializer = getRedisSerializer();  
  34.                 byte[] key  = serializer.serialize(user.getId());  
  35.                 byte[] name = serializer.serialize(user.getName());  
  36.                 return connection.setNX(key, name);  
  37.             }  
  38.         });  
  39.         return result;  
  40.     }  
  41.       
  42.     /** 
  43.      * 批量新增 使用pipeline方式   
  44.      *<br>------------------------------<br> 
  45.      *@param list 
  46.      *@return 
  47.      */  
  48.     public boolean add(final List<User> list) {  
  49.         Assert.notEmpty(list);  
  50.         boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
  51.             public Boolean doInRedis(RedisConnection connection)  
  52.                     throws DataAccessException {  
  53.                 RedisSerializer<String> serializer = getRedisSerializer();  
  54.                 for (User user : list) {  
  55.                     byte[] key  = serializer.serialize(user.getId());  
  56.                     byte[] name = serializer.serialize(user.getName());  
  57.                     connection.setNX(key, name);  
  58.                 }  
  59.                 return true;  
  60.             }  
  61.         }, falsetrue);  
  62.         return result;  
  63.     }  
  64.       
  65.     /**  
  66.      * 删除 
  67.      * <br>------------------------------<br> 
  68.      * @param key 
  69.      */  
  70.     public void delete(String key) {  
  71.         List<String> list = new ArrayList<String>();  
  72.         list.add(key);  
  73.         delete(list);  
  74.     }  
  75.   
  76.     /** 
  77.      * 删除多个 
  78.      * <br>------------------------------<br> 
  79.      * @param keys 
  80.      */  
  81.     public void delete(List<String> keys) {  
  82.         redisTemplate.delete(keys);  
  83.     }  
  84.   
  85.     /** 
  86.      * 修改  
  87.      * <br>------------------------------<br> 
  88.      * @param user 
  89.      * @return  
  90.      */  
  91.     public boolean update(final User user) {  
  92.         String key = user.getId();  
  93.         if (get(key) == null) {  
  94.             throw new NullPointerException("数据行不存在, key = " + key);  
  95.         }  
  96.         boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
  97.             public Boolean doInRedis(RedisConnection connection)  
  98.                     throws DataAccessException {  
  99.                 RedisSerializer<String> serializer = getRedisSerializer();  
  100.                 byte[] key  = serializer.serialize(user.getId());  
  101.                 byte[] name = serializer.serialize(user.getName());  
  102.                 connection.set(key, name);  
  103.                 return true;  
  104.             }  
  105.         });  
  106.         return result;  
  107.     }  
  108.   
  109.     /**  
  110.      * 通过key获取 
  111.      * <br>------------------------------<br> 
  112.      * @param keyId 
  113.      * @return 
  114.      */  
  115.     public User get(final String keyId) {  
  116.         User result = redisTemplate.execute(new RedisCallback<User>() {  
  117.             public User doInRedis(RedisConnection connection)  
  118.                     throws DataAccessException {  
  119.                 RedisSerializer<String> serializer = getRedisSerializer();  
  120.                 byte[] key = serializer.serialize(keyId);  
  121.                 byte[] value = connection.get(key);  
  122.                 if (value == null) {  
  123.                     return null;  
  124.                 }  
  125.                 String name = serializer.deserialize(value);  
  126.                 return new User(keyId, name, null);  
  127.             }  
  128.         });  
  129.         return result;  
  130.     }  
  131. }  
[java] view plain copy
 
 print?
  1. import java.util.ArrayList;  
  2. import java.util.List;  
  3.   
  4. import junit.framework.Assert;  
  5.   
  6. import org.junit.Test;  
  7. import org.springframework.beans.factory.annotation.Autowired;  
  8. import org.springframework.test.context.ContextConfiguration;  
  9. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
  10.   
  11. import com.x.dao.IUserDao;  
  12. import com.x.entity.User;  
  13.   
  14. /**  
  15.  * 测试 
  16.  * @author http://blog.csdn.net/java2000_wl  
  17.  * @version <b>1.0</b>  
  18.  */    
  19. @ContextConfiguration(locations = {"classpath*:applicationContext.xml"})  
  20. public class RedisTest extends AbstractJUnit4SpringContextTests {  
  21.       
  22.     @Autowired  
  23.     private IUserDao userDao;  
  24.       
  25.     /** 
  26.      * 新增 
  27.      * <br>------------------------------<br> 
  28.      */  
  29.     @Test  
  30.     public void testAddUser() {  
  31.         User user = new User();  
  32.         user.setId("user1");  
  33.         user.setName("java2000_wl");  
  34.         boolean result = userDao.add(user);  
  35.         Assert.assertTrue(result);  
  36.     }  
  37.       
  38.     /** 
  39.      * 批量新增 普通方式 
  40.      * <br>------------------------------<br> 
  41.      */  
  42.     @Test  
  43.     public void testAddUsers1() {  
  44.         List<User> list = new ArrayList<User>();  
  45.         for (int i = 10; i < 50000; i++) {  
  46.             User user = new User();  
  47.             user.setId("user" + i);  
  48.             user.setName("java2000_wl" + i);  
  49.             list.add(user);  
  50.         }  
  51.         long begin = System.currentTimeMillis();  
  52.         for (User user : list) {  
  53.             userDao.add(user);  
  54.         }  
  55.         System.out.println(System.currentTimeMillis() -  begin);  
  56.     }  
  57.       
  58.     /** 
  59.      * 批量新增 pipeline方式 
  60.      * <br>------------------------------<br> 
  61.      */  
  62.     @Test  
  63.     public void testAddUsers2() {  
  64.         List<User> list = new ArrayList<User>();  
  65.         for (int i = 10; i < 1500000; i++) {  
  66.             User user = new User();  
  67.             user.setId("user" + i);  
  68.             user.setName("java2000_wl" + i);  
  69.             list.add(user);  
  70.         }  
  71.         long begin = System.currentTimeMillis();  
  72.         boolean result = userDao.add(list);  
  73.         System.out.println(System.currentTimeMillis() - begin);  
  74.         Assert.assertTrue(result);  
  75.     }  
  76.       
  77.     /** 
  78.      * 修改 
  79.      * <br>------------------------------<br> 
  80.      */  
  81.     @Test  
  82.     public void testUpdate() {  
  83.         User user = new User();  
  84.         user.setId("user1");  
  85.         user.setName("new_password");  
  86.         boolean result = userDao.update(user);  
  87.         Assert.assertTrue(result);  
  88.     }  
  89.       
  90.     /** 
  91.      * 通过key删除单个 
  92.      * <br>------------------------------<br> 
  93.      */  
  94.     @Test  
  95.     public void testDelete() {  
  96.         String key = "user1";  
  97.         userDao.delete(key);  
  98.     }  
  99.       
  100.     /** 
  101.      * 批量删除 
  102.      * <br>------------------------------<br> 
  103.      */  
  104.     @Test  
  105.     public void testDeletes() {  
  106.         List<String> list = new ArrayList<String>();  
  107.         for (int i = 0; i < 10; i++) {  
  108.             list.add("user" + i);  
  109.         }  
  110.         userDao.delete(list);  
  111.     }  
  112.       
  113.     /** 
  114.      * 获取 
  115.      * <br>------------------------------<br> 
  116.      */  
  117.     @Test  
  118.     public void testGetUser() {  
  119.         String id = "user1";  
  120.         User user = userDao.get(id);  
  121.         Assert.assertNotNull(user);  
  122.         Assert.assertEquals(user.getName(), "java2000_wl");  
  123.     }  
  124.   
  125.     /** 
  126.      * 设置userDao 
  127.      * @param userDao the userDao to set 
  128.      */  
  129.     public void setUserDao(IUserDao userDao) {  
  130.         this.userDao = userDao;  
  131.     }  
  132. }  
分享到:
评论

相关推荐

    spring整合redis

    本文将深入探讨如何将Spring与Redis进行整合,为新手提供一个简单易懂的实践指南。 一、Spring与Redis整合的背景及优势 Spring框架提供了丰富的集成支持,使得与其他技术的整合变得非常方便。整合Spring和Redis...

    spring整合redis小demo

    总的来说,Spring整合Redis使得在Java应用中使用Redis变得更加便捷,无论是简单的字符串操作还是复杂的对象存储,都能通过Spring提供的工具轻松实现。通过上述步骤,你可以构建一个基本的Spring-Redis集成系统,...

    spring整合redis项目

    Spring整合Redis项目是一种常见的数据存储和缓存解决方案,特别是在高并发、大数据量的Web应用中。Redis是一款开源的、高性能的键值对数据库,而Spring是Java领域广泛使用的框架,提供了一整套的企业级应用开发工具...

    Spring整合Redis完整实例代码

    Spring整合Redis完整实例代码,下载经简单的修改配置文件,即可运行,代码中有详细的注释,关于代码的详情可参见博文:http://blog.csdn.net/l1028386804/article/details/52108758

    spring整合redis哨兵源码

    总结来说,Spring整合Redis哨兵模式涉及了Spring Boot的配置、哨兵系统的理解、连接工厂的创建、数据序列化、CRUD操作以及异常处理等多个知识点。通过这样的整合,我们可以构建出高可用、容错性强的Redis服务,为...

    spring整合redis3.2/redis2.1 jar包

    Spring 整合 Redis 是在 Java 开发中常用的一种技术,用于提升应用的缓存和数据处理性能。Redis 是一个开源的、基于键值对的数据存储系统,常被用作数据库、缓存和消息中间件。它支持多种数据结构,如字符串、哈希、...

    spring整合redis(spring模板+连接池+json序列化+cluster集群).zip

    以上就是关于Spring整合Redis的详细解析,涵盖了Spring模板、连接池、JSON序列化和Redis集群的配置与使用。在实际项目中,理解并熟练掌握这些知识点,能帮助我们构建出高效、稳定的Redis集成方案。

    Spring mvc整合redis实例(redis连接池)

    本文将详细介绍如何在Spring MVC中整合Redis,并利用连接池来优化性能。 首先,我们需要引入Redis的相关依赖。在Maven项目中,可以在pom.xml文件中添加`spring-data-redis`和`jedis`库,这两个库分别提供了Spring对...

    Spring整合Redis哨兵

    **Spring整合Redis哨兵** 在高可用性系统中,Redis Sentinel是至关重要的组件,它提供了主从监控、故障检测和自动故障转移的功能。Spring作为Java生态中的主流框架,提供了与Redis Sentinel集成的能力,使得我们...

    Spring整合Redis

    本文将深入探讨如何在Spring项目中整合Redis,以及在测试过程中如何使用JUnit进行单元测试。 1. **Spring Data Redis** Spring Data Redis是Spring Framework的一个模块,它提供了对Redis数据库的抽象层,使得...

    Spring整合Redis用作缓存-注解方式

    至此,你已经掌握了Spring整合Redis作为缓存的基本步骤。这种方式能够有效地提高应用程序的性能,减少对数据库的访问,同时利用Redis的高速读写能力。在实际开发中,还可以根据需求调整序列化策略、缓存策略等,以...

    spring整合redis案例(jedis)

    在本案例中,我们将深入探讨如何在Spring框架中整合Redis数据存储系统,使用Jedis作为客户端库。Redis是一个高性能的键值对存储系统,适用于缓存、消息队列等多种应用场景。而Spring是Java领域广泛使用的应用程序...

    期末向Spring整合Redis源码

    期末向Spring整合Redis源码

    spring整合redis(spring模板+连接池+json序列化+cluster集群).rar

    spring整合redis(spring模板+连接池+json序列化+cluster集群)

    spring整合redis(带spring模板和连接池json和jdk序列化,非集群版).rar

    总结来说,Spring整合Redis的目的是优化数据存取,提高应用性能。通过配置RedisTemplate、连接池和序列化策略,我们可以实现高效、灵活的Redis操作。在这个非集群环境中,我们专注于单实例的使用,但在生产环境中,...

    SpringCloud整合Redis

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

    Spring3.0整合redis相关jar

    "Spring3.0整合redis相关jar"这个主题主要涉及的是如何在Spring 3.0版本中集成Redis作为数据存储或缓存解决方案。Spring 3.0虽然相对较老,但在当时是广泛使用的版本,因此了解其与Redis的集成方式对维护旧项目或...

Global site tag (gtag.js) - Google Analytics