Spring 整合 Redis 分类：(转发)

     @Override
    public List<model> getStandardDtlList() throws ManagerException{
         modellookupDtl = new model();
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("status", 0);
        try{
            List<TmsStandardDtl> listDtls = tmsStandardDtlService.findByBiz(
                    lookupDtl, params);
            Set<String> keys=redisTemplate.keys(CACHE_KEY+"*");
            List<String> str=new ArrayList();
            for (TmsStandardDtl vo : listDtls) {
                str.add(CACHE_KEY+vo.getLookupcode());
             }
            redisTemplate.delete(str);//删除KEY
         if (CommonUtil.hasValue(listDtls)) {
            for (TmsStandardDtl vo : listDtls) {
                  BoundListOperations<String, List<TmsStandardDtl>>ops=redisTemplate.boundListOps(CACHE_KEY+vo.getLookupcode());
                 List modules=ops.range(0,ops.size());//取得值
                 if (modules.size()!=0) {
                    List rolesList=ops.range(0,ops.size());
                    //List<TmsStandardDtl> tempList = SystemCache.standarDtldMap.get(vo.getLookupcode());
                    rolesList.add(vo);
                     ops.rightPush(rolesList);
                } else {
                    List<TmsStandardDtl> tempList = new LinkedList<TmsStandardDtl>();
                    TmsStandardDtl tmp = new TmsStandardDtl();
                    tmp.setItemname("--请选择--");
                    tmp.setItemvalue("");
                    tempList.add(tmp);
                    tempList.add(vo);
                    ops.rightPush(tempList);
                    //SystemCache.standarDtldMap.put(vo.getLookupcode(), tempList);
                }
            }
          
        }

相关链接：

征服 Redis

征服 Redis + Jedis

征服 Redis + Jedis + Spring （一）—— 配置&常规操作（GET SET DEL）

征服 Redis + Jedis + Spring （二）—— 哈希表操作（HMGET HMSET）

征服 Redis + Jedis + Spring （三）—— 列表操作

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"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/jdbc
        http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
       
        <context:component-scan base-package="com.zlh.dao"/>
       
       
       <!-- 加载数据源配置文件 -->
       <bean
           class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
           <property name="locations">
               <list>
                   <!-- 标准配置 -->
                   <value>classpath:/jdbc.properties</value>
                   <value>classpath:/redis-config.properties</value>
               </list>
           </property>
       </bean>
       
       
       
       <context:property-placeholder location="classpath:redis-config.properties" ignore-unresolvable="true" ignore-resource-not-found="true" />  
    
        <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
           <property name="maxActive" value="${redis.conf.maxActive}" />
           <property name="maxIdle" value="100" />
           <property name="maxWait" value="10000" />
           <property name="testOnBorrow" value="false" />
       </bean>
   
       <bean id="jedisConnectionFactory"
           class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
           p:use-pool="true" p:host-name="192.168.234.130" p:port="6379"
           p:pool-config-ref="jedisPoolConfig" />
   
       <!-- redis template definition -->
       <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
           p:connection-factory-ref="jedisConnectionFactory" />    
           
         
    
       
   </beans>
   
   
2. 
   

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. @Service
    
22. public class UserDao extends AbstractBaseRedisDao<String, User> implements IUserDao {  
23.   
24.     /**  
25.      * 新增 
26.      *<br>------------------------------<br> 
27.      * @param user 
28.      * @return 
29.      */  
30.     public boolean add(final User user) {  
31.         boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
32.             public Boolean doInRedis(RedisConnection connection)  
33.                     throws DataAccessException {  
34.                 RedisSerializer<String> serializer = getRedisSerializer();  
35.                 byte[] key  = serializer.serialize(user.getId());  
36.                 byte[] name = serializer.serialize(user.getName());  
37.                 return connection.setNX(key, name);  
38.             }  
39.         });  
40.         return result;  
41.     }  
42.       
43.     /** 
44.      * 批量新增 使用pipeline方式   
45.      *<br>------------------------------<br> 
46.      *@param list 
47.      *@return 
48.      */  
49.     public boolean add(final List<User> list) {  
50.         Assert.notEmpty(list);  
51.         boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
52.             public Boolean doInRedis(RedisConnection connection)  
53.                     throws DataAccessException {  
54.                 RedisSerializer<String> serializer = getRedisSerializer();  
55.                 for (User user : list) {  
56.                     byte[] key  = serializer.serialize(user.getId());  
57.                     byte[] name = serializer.serialize(user.getName());  
58.                     connection.setNX(key, name);  
59.                 }  
60.                 return true;  
61.             }  
62.         }, false, true);  
63.         return result;  
64.     }  
65.       
66.     /**  
67.      * 删除 
68.      * <br>------------------------------<br> 
69.      * @param key 
70.      */  
71.     public void delete(String key) {  
72.         List<String> list = new ArrayList<String>();  
73.         list.add(key);  
74.         delete(list);  
75.     }  
76.   
77.     /** 
78.      * 删除多个 
79.      * <br>------------------------------<br> 
80.      * @param keys 
81.      */  
82.     public void delete(List<String> keys) {  
83.         redisTemplate.delete(keys);  
84.     }  
85.   
86.     /** 
87.      * 修改  
88.      * <br>------------------------------<br> 
89.      * @param user 
90.      * @return  
91.      */  
92.     public boolean update(final User user) {  
93.         String key = user.getId();  
94.         if (get(key) == null) {  
95.             throw new NullPointerException("数据行不存在, key = " + key);  
96.         }  
97.         boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
98.             public Boolean doInRedis(RedisConnection connection)  
99.                     throws DataAccessException {  
100.                 RedisSerializer<String> serializer = getRedisSerializer();  
101.                 byte[] key  = serializer.serialize(user.getId());  
102.                 byte[] name = serializer.serialize(user.getName());  
103.                 connection.set(key, name);  
104.                 return true;  
105.             }  
106.         });  
107.         return result;  
108.     }  
109.   
110.     /**  
111.      * 通过key获取 
112.      * <br>------------------------------<br> 
113.      * @param keyId 
114.      * @return 
115.      */  
116.     public User get(final String keyId) {  
117.         User result = redisTemplate.execute(new RedisCallback<User>() {  
118.             public User doInRedis(RedisConnection connection)  
119.                     throws DataAccessException {  
120.                 RedisSerializer<String> serializer = getRedisSerializer();  
121.                 byte[] key = serializer.serialize(keyId);  
122.                 byte[] value = connection.get(key);  
123.                 if (value == null) {  
124.                     return null;  
125.                 }  
126.                 String name = serializer.deserialize(value);  
127.                 return new User(keyId, name, null);  
128.             }  
129.         });  
130.         return result;  
131.     }  
132. }  

[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.  
    
    private ApplicationContext app;
    
    @Autowired
    private IUserDao userDao;
    
    
    /** 
         * 设置userDao 
         * @param userDao the userDao to set 
         */  
        public void setUserDao(IUserDao userDao) {  
            this.userDao = userDao;  
        }  
        
    @Before
    public void before() throws Exception {
    app = new ClassPathXmlApplicationContext("redis.xml");
    userDao = (IUserDao) app.getBean("userDaoImpl");
    }
23. 
    
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. }  

1. import org.junit.After;  
2. import org.junit.Before;  
3. import org.junit.Test;  
4. import redis.clients.jedis.Jedis;  
5. import redis.clients.jedis.JedisPool;  
6. import redis.clients.jedis.JedisPoolConfig;  
7.   
8. import javax.sound.midi.Soundbank;  
9. import java.util.*;  
10.   
11. /** 
12.  * @author: flychao88 
13.  * Time: 2012.5.7 16:23:15 
14.  */  
15. public class RedisTest {  
16.     JedisPool pool;  
17.     Jedis jedis;  
18.     @Before  
19.     public void setUp() {  
20.         pool = new JedisPool(new JedisPoolConfig(), "172.16.100.184");  
21.   
22.         jedis = pool.getResource();  
23.         jedis.auth("password");  
24.     }  
25.   
26.     /** 
27.      * Redis存储初级的字符串 
28.      * CRUD 
29.      */  
30.     @Test  
31.     public void testBasicString(){  
32.         //-----添加数据----------  
33.         jedis.set("name","minxr");//向key-->name中放入了value-->minxr  
34.         System.out.println(jedis.get("name"));//执行结果：minxr  
35.   
36.         //-----修改数据-----------  
37.         //1、在原来基础上修改  
38.         jedis.append("name","jarorwar");   //很直观，类似map 将jarorwar append到已经有的value之后  
39.         System.out.println(jedis.get("name"));//执行结果:minxrjarorwar  
40.   
41.         //2、直接覆盖原来的数据  
42.         jedis.set("name","闵晓荣");  
43.         System.out.println(jedis.get("name"));//执行结果：闵晓荣  
44.   
45.         //删除key对应的记录  
46.         jedis.del("name");  
47.         System.out.println(jedis.get("name"));//执行结果：null  
48.   
49.         /** 
50.          * mset相当于 
51.          * jedis.set("name","minxr"); 
52.          * jedis.set("jarorwar","闵晓荣"); 
53.          */  
54.         jedis.mset("name","minxr","jarorwar","闵晓荣");  
55.         System.out.println(jedis.mget("name","jarorwar"));  
56.   
57.     }  
58.   
59.     /** 
60.      * jedis操作Map 
61.      */  
62.     @Test  
63.     public void testMap(){  
64.         Map<String,String> user=new HashMap<String,String>();  
65.         user.put("name","minxr");  
66.         user.put("pwd","password");  
67.         jedis.hmset("user",user);  
68.         //取出user中的name，执行结果:[minxr]-->注意结果是一个泛型的List  
69.         //第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数  
70.         List<String> rsmap = jedis.hmget("user", "name");  
71.         System.out.println(rsmap);  
72.   
73.         //删除map中的某个键值  
74. //        jedis.hdel("user","pwd");  
75.         System.out.println(jedis.hmget("user", "pwd")); //因为删除了，所以返回的是null  
76.         System.out.println(jedis.hlen("user")); //返回key为user的键中存放的值的个数1  
77.         System.out.println(jedis.exists("user"));//是否存在key为user的记录 返回true  
78.         System.out.println(jedis.hkeys("user"));//返回map对象中的所有key  [pwd, name]  
79.         System.out.println(jedis.hvals("user"));//返回map对象中的所有value  [minxr, password]  
80.   
81.         Iterator<String> iter=jedis.hkeys("user").iterator();  
82.         while (iter.hasNext()){  
83.             String key = iter.next();  
84.             System.out.println(key+":"+jedis.hmget("user",key));  
85.         }  
86.   
87.     }  
88.   
89.     /** 
90.      * jedis操作List 
91.      */  
92.     @Test  
93.     public void testList(){  
94.         //开始前，先移除所有的内容  
95.         jedis.del("java framework");  
96.         System.out.println(jedis.lrange("java framework",0,-1));  
97.        //先向key java framework中存放三条数据  
98.        jedis.lpush("java framework","spring");  
99.        jedis.lpush("java framework","struts");  
100.        jedis.lpush("java framework","hibernate");  
101.        //再取出所有数据jedis.lrange是按范围取出，  
102.        // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有  
103.        System.out.println(jedis.lrange("java framework",0,-1));  
104.     }  
105.   
106.     /** 
107.      * jedis操作Set 
108.      */  
109.     @Test  
110.     public void testSet(){  
111.         //添加  
112.         jedis.sadd("sname","minxr");  
113.         jedis.sadd("sname","jarorwar");  
114.         jedis.sadd("sname","闵晓荣");  
115.         jedis.sadd("sanme","noname");  
116.         //移除noname  
117.         jedis.srem("sname","noname");  
118.         System.out.println(jedis.smembers("sname"));//获取所有加入的value  
119.         System.out.println(jedis.sismember("sname", "minxr"));//判断 minxr 是否是sname集合的元素  
120.         System.out.println(jedis.srandmember("sname"));  
121.         System.out.println(jedis.scard("sname"));//返回集合的元素个数  
122.     }  
123.   
124.     @Test  
125.     public void test() throws InterruptedException {  
126.         //keys中传入的可以用通配符  
127.         System.out.println(jedis.keys("*")); //返回当前库中所有的key  [sose, sanme, name, jarorwar, foo, sname, java framework, user, braand]  
128.         System.out.println(jedis.keys("*name"));//返回的sname   [sname, name]  
129.         System.out.println(jedis.del("sanmdde"));//删除key为sanmdde的对象  删除成功返回1 删除失败（或者不存在）返回 0  
130.         System.out.println(jedis.ttl("sname"));//返回给定key的有效时间，如果是-1则表示永远有效  
131.         jedis.setex("timekey", 10, "min");//通过此方法，可以指定key的存活（有效时间） 时间为秒  
132.         Thread.sleep(5000);//睡眠5秒后，剩余时间将为<=5  
133.         System.out.println(jedis.ttl("timekey"));   //输出结果为5  
134.         jedis.setex("timekey", 1, "min");        //设为1后，下面再看剩余时间就是1了  
135.         System.out.println(jedis.ttl("timekey"));  //输出结果为1  
136.         System.out.println(jedis.exists("key"));//检查key是否存在  
137.         System.out.println(jedis.rename("timekey","time"));  
138.         System.out.println(jedis.get("timekey"));//因为移除，返回为null  
139.         System.out.println(jedis.get("time")); //因为将timekey 重命名为time 所以可以取得值 min  
140.   
141.         //jedis 排序  
142.         //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）  
143.         jedis.del("a");//先清除数据，再加入数据进行测试  
144.         jedis.rpush("a", "1");  
145.         jedis.lpush("a","6");  
146.         jedis.lpush("a","3");  
147.         jedis.lpush("a","9");  
148.         System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]  
149.         System.out.println(jedis.sort("a")); //[1, 3, 6, 9]  //输入排序后结果  
150.         System.out.println(jedis.lrange("a",0,-1));  
151.   
152.     }