spring集成Redis,使用Jedis客户端

一、依赖的jar包

<-- spring !-->

     org.springframework.data
     spring-data-redis
     2.1.5.RELEASE 

<-- spring-boot !-->

     org.springframework.boot
     spring-boot-starter-data-redis
     2.1.1.RELEASE

<-- Jedis ！-->

    redis.clients
    jedis
    3.2.0

二、redis配置文件

​
    
    
        
        
        
        
    
​
    
    
        
        
        
        
    
​
    
    
        
        
            
        
        
            
        
        
            
        
        
            
        
    
​
    
        
            
                
            
        
        
            
        
        
            
                myCache1
                myCache2
            
        
    
​
    
        
        
    
​
    
​

三、redis配置文件

redis.port=1234
redis.password=ZAQxcv
​
#最小空闲连接数
redis.minIdle=5
#最大空闲连接数
redis.maxIdle=20
#最大连接数
redis.maxTotal=500
#最大等待时间(毫秒)
redis.maxWaitMillis=3000

四、Jedis客户端

package com.wutongyu.util.redis;
import com.wutongyu.util.lang.UUIDUtil;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
​
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
​
public class MyCacheManager {
​
    private RedisCacheManager redisCacheManager;
​
    private RedisTemplate redisTemplate;
​
    public MyCacheManager(RedisCacheManager redisCacheManager, RedisTemplate redisTemplate) {
        this.redisCacheManager = redisCacheManager;
        this.redisTemplate = redisTemplate;
    }
​
    /**
     * 获取所有key
     *
     * @return
     */
    public List getAllKeys() {
        Set keys = redisTemplate.keys("*");
        return new ArrayList<>(keys);
    }
​
    /**
     * 放入缓存数据
     *
     * @param key
     * @param value
     */
    public void put(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
​
    /**
     * 放入缓存数据
     *
     * @param key
     * @param value
     * @param timeout 超时时间
     */
    public void put(String key, Object value, long timeout) {
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }
​
    /**
     * 放入Map到缓存
     *
     * @param key
     * @param map
     */
    public void putForHash(String key, Map map) {
        redisTemplate.opsForHash().putAll(key, map);
    }
​
    /**
     * 放入k-v(特定Map)
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void putForHash(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }
​
    /**
     * 放入缓存数据
     *
     * @param key
     * @param value
     * @param timeout
     * @return
     */
    public Boolean putIfAbsent(String key, Object value, long timeout) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.SECONDS);
    }
​
    /**
     * 放入缓存数据
     *
     * @param key
     * @param value
     */
    public Boolean putIfAbsent(String key, Object value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }
​
    /**
     * 获取锁
     *
     * @param key
     * @param timeout
     * @return
     */
    public Boolean tryLock(String key, long timeout) {
        return redisTemplate.opsForValue().setIfAbsent(key, UUIDUtil.getUUID(), timeout, TimeUnit.SECONDS);
    }
​
    /**
     * 获取缓存数据
     *
     * @param key
     * @return
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
​
    /**
     * 删除缓存数据
     *
     * @param key
     */
    public void remove(String key) {
        redisTemplate.delete(key);
    }
​
    /**
     * 从阻塞队列获取值
     *
     * @param key     阻塞队列的key
     * @param timeout 超时时间(秒)
     * @return 超时时间内队列有值，返回有效值，没有值一直阻塞，超时后返回null
     */
    public Object bLPop(String key, int timeout) {
        RedisConnection connection = null;
        try {
            connection = redisTemplate.getConnectionFactory().getConnection();
            List bytes = connection.bLPop(timeout, key.getBytes());
            if (bytes != null) {
                return new JdkSerializationRedisSerializer().deserialize(bytes.get(1));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return null;
    }
​
}
​