springBoot结合redis

pom

    <!--redis -->

        <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.4.7.RELEASE</version>

application.yml

redis:
        database: 0
        host: 39.105.6.180
        password: 'root'
        pool:
            max-active: 8
            max-idle: 8
            max-wait: -1
            min-idle: 0
        port: 6379
        timeout: 0

操作Redis工具类

package connet.unit;

import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
@Service 
public class RedisUtil {

/*  
    public void setString(String key,String value){
        stringRedisTemplate.opsForValue().set(key, value);   
    }
    public String getString(String key){
        return stringRedisTemplate.opsForValue().get(key);      
    }
    */


    @Resource
    StringRedisTemplate stringRedisTemplate;
    @SuppressWarnings("rawtypes")
    @Resource
    RedisTemplate redisTemplate;

    /** 
     * 删除缓存<br> 
     * 根据key精确匹配删除 
     * @param key 
     */  

    @Autowired(required = false)
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setValueSerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        redisTemplate.setHashValueSerializer(stringSerializer);
        this.redisTemplate = redisTemplate;
    }
    @SuppressWarnings("unchecked")  
    public   void del(String... key){  
        if(key!=null && key.length > 0){  
            if(key.length == 1){  
                redisTemplate.delete(key[0]);  
            }else{  
                redisTemplate.delete(CollectionUtils.arrayToList(key));               
            }  
        }  
    }  

    public void setString(String key,String value){
        stringRedisTemplate.opsForValue().set(key, value);   
    }

    /** 
     * 批量删除<br> 
     * （该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删） 
     * @param pattern 
     */   
    public   void batchDel(String... pattern){  
        for (String kp : pattern) {  
            redisTemplate.delete(redisTemplate.keys(kp + "*"));  
        }  
    }  
    public String getString (String key){
        return stringRedisTemplate.opsForValue().get(key);
    }
    /** 
     * 取得缓存（int型） 
     * @param key 
     * @return 
     */  
    public   Integer getInt(String key){  
        String value = stringRedisTemplate.boundValueOps(key).get();      
            return Integer.valueOf(value);  
    }  

    /** 
     * 取得缓存（字符串类型） 
     * @param key 
     * @return 
     */  
    public   String getStr(String key){  
        return stringRedisTemplate.boundValueOps(key).get();  
    }  

    /** 
     * 取得缓存（字符串类型） 
     * @param key 
     * @return 
     */  
    public   String getStr(String key, boolean retain){  
        String value = stringRedisTemplate.boundValueOps(key).get();  
        if(!retain){  
            redisTemplate.delete(key);  
        }  
        return value;  
    }  

    /** 
     * 获取缓存<br> 
     * 注：基本数据类型(Character除外)，请直接使用get(String key, Class<T> clazz)取值 
     * @param key 
     * @return 
     */  
    public   Object getObj(String key){  
        return redisTemplate.boundValueOps(key).get();  
    }  

    /** 
     * 获取缓存<br> 
     * 注：java 8种基本类型的数据请直接使用get(String key, Class<T> clazz)取值 
     * @param key        
     * @param retain    是否保留 
     * @return 
     */  
    public   Object getObj(String key, boolean retain){  
        Object obj = redisTemplate.boundValueOps(key).get();  
        if(!retain){  
            redisTemplate.delete(key);  
        }  
        return obj;  
    }  

    /** 
     * 获取缓存<br> 
     * 注：该方法暂不支持Character数据类型 
     * @param key   key 
     * @param clazz 类型 
     * @return 
     */  
    @SuppressWarnings("unchecked")  
    public   <T> T get(String key, Class<T> clazz) {  
        return (T)redisTemplate.boundValueOps(key).get();  
    }  



    /** 
     * 递减操作 
     * @param key 
     * @param by 
     * @return 
     */  
    public   double decr(String key, double by){  
        return redisTemplate.opsForValue().increment(key, -by);  
    }  

    /** 
     * 递增操作 
     * @param key 
     * @param by 
     * @return 
     */  
    public   double incr(String key, double by){  
        return redisTemplate.opsForValue().increment(key, by);  
    }  






    /** 
     * 将map写入缓存 
     * @param key 
     * @param map 
     * @param time 失效时间(秒) 
     */  
    public   <T> void setMap(String key, Map<String, T> map ){  
        setRedisTemplate(redisTemplate);
        redisTemplate.opsForHash().putAll(key, map);  
    }  

    public   String getMapValue(String key, String hashKey ){  
     return   (String) redisTemplate.opsForHash().get(key, hashKey) ;
    }  
    /** 
     * 将map写入缓存 
     * @param key 
     * @param map 
     * @param time 失效时间(秒) 
     */  



    /** 
     * 向key对应的map中添加缓存对象 
     * @param key 
     * @param map 
     */  
    public   <T> void addMap(String key, Map<String, T> map){  
        redisTemplate.opsForHash().putAll(key, map);  
    }  

    /** 
     * 向key对应的map中添加缓存对象 
     * @param key   cache对象key 
     * @param field map对应的key 
     * @param value     值 
     */  
    public   void addMap(String key, String field, String value){  
        redisTemplate.opsForHash().put(key, field, value);  
    }  

    /** 
     * 向key对应的map中添加缓存对象 
     * @param key   cache对象key 
     * @param field map对应的key 
     * @param obj   对象 
     */  
    public   <T> void addMap(String key, String field, T obj){  
        redisTemplate.opsForHash().put(key, field, obj);  
    }  

    /** 
     * 获取map缓存 
     * @param key 
     * @param clazz 
     * @return 
     */  
    public   <T> Map<String, T> mget(String key, Class<T> clazz){  
        BoundHashOperations<String, String, T> boundHashOperations = redisTemplate.boundHashOps(key);   
        return boundHashOperations.entries();  
    }  



    /** 
     * 获取map缓存中的某个对象 
     * @param key 
     * @param field 
     * @param clazz 
     * @return 
     */  
    @SuppressWarnings("unchecked")  
    public   <T> T getMapField(String key, String field, Class<T> clazz){  
        return (T)redisTemplate.boundHashOps(key).get(field);  
    }  

    /** 
     * 删除map中的某个对象 
     * @author lh 
     * @date 2016年8月10日 
     * @param key   map对应的key 
     * @param field map中该对象的key 
     */  
    public void delMapField(String key, String... field){  
        BoundHashOperations<String, String, ?> boundHashOperations = redisTemplate.boundHashOps(key);   
        boundHashOperations.delete(field);  
    }  



    /** 
     * 添加set 
     * @param key 
     * @param value 
     */  
    public   void sadd(String key, String... value) {  
        redisTemplate.boundSetOps(key).add(value);  
    }  

    /** 
     * 删除set集合中的对象 
     * @param key 
     * @param value 
     */  
    public   void srem(String key, String... value) {  
        redisTemplate.boundSetOps(key).remove(value);  
    }  

    /** 
     * set重命名 
     * @param oldkey 
     * @param newkey 
     */  
    public   void srename(String oldkey, String newkey){  
        redisTemplate.boundSetOps(oldkey).rename(newkey);  
    }  



    /** 
     * 模糊查询keys 
     * @param pattern 
     * @return 
     */  
    public   Set<String> keys(String pattern){  
        return redisTemplate.keys(pattern);   
    }  





}

Maven update后直接注入操作类进行操作

猜你喜欢