redis和spring整合-阿里云开发者社区

pom构建：

[html]view plain copy 
   
 print?
 <modelVersion>4.0.0</modelVersion>   
 <groupId>com.x.redis</groupId>   
 <artifactId>springredis</artifactId>   
 <version>0.0.1-SNAPSHOT</version>   
    
 <dependencies>   
     <dependency>   
         <groupId>org.springframework.data</groupId>   
         <artifactId>spring-data-redis</artifactId>   
         <version>1.0.2.RELEASE</version>   
     </dependency>   
     <dependency>   
         <groupId>org.springframework</groupId>   
         <artifactId>spring-test</artifactId>   
         <version>3.1.2.RELEASE</version>   
         <scope>test</scope>   
     </dependency>   
        
     <dependency>   
         <groupId>redis.clients</groupId>   
         <artifactId>jedis</artifactId>   
         <version>2.1.0</version>   
     </dependency>   
        
      <dependency>   
         <groupId>junit</groupId>   
         <artifactId>junit</artifactId>   
         <version>4.8.2</version>   
         <scope>test</scope>   
     </dependency>   
 </dependencies>   

spring配置文件(applicationContext.xml)：

[html]view plain copy 
   
 print?
 <?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" />   
    
     <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>   
        
     <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"/>   
        
     <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

[html]view plain copy 
   
 print?
 # Redis settings   
 redis.host=localhost   
 redis.port=6379   
 redis.pass=java2000_wl   
    
    
 redis.maxIdle=300   
 redis.maxActive=600   
 redis.maxWait=1000   
 redis.testOnBorrow=true   

java代码：

[java]view plain copy 
   
 print?
 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;   
     }   
 }   

[java]view plain copy 
   
 print?
 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();   
     }   
 }   

[java]view plain copy 
   
 print?
 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);   
 }   

[java]view plain copy 
   
 print?
 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;   
     }   
 }   

[java]view plain copy 
   
 print?
 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;   
     }   
 }   

redis和spring整合

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

redis和spring整合

热门文章

最新文章

相关课程

相关电子书