參考:
https://www.cnblogs.com/ityouknow/p/5748830.html
http://blog.csdn.net/i_vic/article/details/53081241
https://www.cnblogs.com/gdpuzxs/p/7222309.html
http://www.runoob.com/redis/redis-keys.html #redis命令

springboot和redis結合，這裏只是單機版的配置，如果需要配置集群，可以在上面幾個博客中看一下。附錄中是一些redis常用命令，也可以在參考[3]中看。

springboot的應用，包路徑一定要合格(所有的代碼，都在啟動類所在得包的下級目錄中)，避免不必要的麻煩。

開始：

1. pom中添加

　　　　　<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>        

2. 啟動類

添加  @EnableCaching

3. 配置

配置文件：

# Redis數據庫索引（默認為0）
spring.redis.database
 
=0
# Redis服務器地址
spring.redis.host=192.168.72.133
# Redis服務器連接端口
spring.redis.port=6379
# Redis服務器連接密碼（默認為空）
spring.redis.password=
# 連接池最大連接數（使用負值表示沒有限制）
spring.redis.pool.max-active=8
# 連接池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.pool.max-wait=-1
# 連接池中的最大空閑連接
spring.redis.pool.max-idle=8
# 連接池中的最小空閑連接
spring.redis.pool.min
 
-idle=0
# 連接超時時間（毫秒）
spring.redis.timeout=0

配置類：

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport{

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${redis.cacheExpirationTime}")
    private long cacheExpirationTime;
    
    //自定義緩存key生成策略
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator(){
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for(Object obj:params){
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    
    //緩存管理器
    @Bean 
    public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //設置緩存過期時間 
        cacheManager.setDefaultExpiration(10);
        return cacheManager;
    }
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate(factory);
        setSerializer(template);//設置序列化工具
        template.afterPropertiesSet();
        return template;
    }
    
    private void setSerializer(StringRedisTemplate template){
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }
}

其中的使用的是com.fasterxml.jackson。

4. redis操作接口和實現類(使用接口實現類的形式，可以使你在單機和集群形式快速切換，而且在其它地方使用的使用可以自動註入)

interface:

public interface JedisServer {

    public boolean set(String key, String value);  
    
    public String get(String key);  
      
    public boolean expire(String key,long expire);  
      
    public <T> boolean setList(String key ,List<T> list);  
      
    public <T> List<T> getList(String key,Class<T> clz);  
      
    public long lpush(String key,Object obj);  
      
    public long rpush(String key,Object obj);  
      
    public String lpop(String key);  
    
}

implements single:

@Service
public class JedisServerImpl implements JedisServer {

    @Resource  
    private RedisTemplate<String, ?> redisTemplate;  
      
    @Override  
    public boolean set(final String key, final String value) {  
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
            @Override  
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                connection.set(serializer.serialize(key), serializer.serialize(value));  
                return true;  
            }  
        });  
        return result;  
    }  
  
    public String get(final String key){  
        String result = redisTemplate.execute(new RedisCallback<String>() {  
            @Override  
            public String doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                byte[] value =  connection.get(serializer.serialize(key));  
                return serializer.deserialize(value);  
            }  
        });  
        return result;  
    }  
  
    /**
     * 設置緩存剩余時間(s)
     */
    @Override  
    public boolean expire(final String key, long expire) {  
        return redisTemplate.expire(key, expire, TimeUnit.SECONDS);  
    }  
  
    @Override  
    public <T> boolean setList(String key, List<T> list) {  
        String value = JsonUtilFood.object2Json(list);  
        return set(key,value);  
    }  
  
    @Override  
    public <T> List<T> getList(String key,Class<T> clz) {  
        String json = get(key);  
        if(json!=null){  
            @SuppressWarnings("unchecked")
            List<T> list = (List<T>) JsonUtilFood.json2Object(json, clz);
            return list;  
        }  
        return null;  
    }  
  
    @Override  
    public long lpush(final String key, Object obj) {  
        final String value = JsonUtilFood.object2Json(obj);  
        long result = redisTemplate.execute(new RedisCallback<Long>() {  
            @Override  
            public Long doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                long count = connection.lPush(serializer.serialize(key), serializer.serialize(value));  
                return count;  
            }  
        });  
        return result;  
    }  
  
    @Override  
    public long rpush(final String key, Object obj) {  
        final String value = JsonUtilFood.object2Json(obj);  
        long result = redisTemplate.execute(new RedisCallback<Long>() {  
            @Override  
            public Long doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                long count = connection.rPush(serializer.serialize(key), serializer.serialize(value));  
                return count;  
            }  
        });  
        return result;  
    }  
  
    @Override  
    public String lpop(final String key) {  
        String result = redisTemplate.execute(new RedisCallback<String>() {  
            @Override  
            public String doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();  
                byte[] res =  connection.lPop(serializer.serialize(key));  
                return serializer.deserialize(res);  
            }  
        });  
        return result;  
    }  
    
}

記得添加@Service註釋

implements cluster： 沒寫，百度挺多的。

可以在電腦安裝虛擬機，安裝linux，然後安裝redis，在上面參考博客中有，然後關閉防火墻，啟動redis服務端，之後啟動客戶端測試，可以的時候再使用代碼測試。

配置中的緩存存在時間配置暫時測試，不知道為什麽沒用，所以先在代碼中設置了，以後找到了再更新吧。。

再貼一份調用的代碼：

    @Resource
    private JedisServer jedisServer;
    
    @Override
    public String noodlesList() {
        //其中的key暫時先寫的是固定的，之後可以根據表名+主鍵保存，防止重復，記得再次查詢的時候，重新設置超時時間，修改和刪除的時候刪除/更新redis中的緩存
        try{
            String string = jedisServer.get("foodcom");
            if(null != string) {
                return string;
            }else{
                jedisServer.expire("foodcom", 10);
            }
        }catch(Exception e) {
            log.info("查詢緩存異常(key=foodcom).");
        }
        
        FoodInfo food = foodInfoMapper.selectByPrimaryKey(1);
        jedisServer.set("foodcom", JsonUtilFood.object2Json(food));
        jedisServer.expire("foodcom", 10);
        return JsonUtilFood.object2Json(food);
    }

希望可以幫到你，如果是業余測試，獲取有問題我可以幫到你，如果是企業大應用，我也。。不會，以後或許就會了，哈哈哈

附：

redis常用：

防火墻，需要用root用戶。

從配置菜單關閉防火墻是不起作用的，索性在安裝的時候就不要裝防火墻
查看防火墻狀態：
/etc/init.d/iptables status
暫時關閉防火墻：
/etc/init.d/iptables stop
禁止防火墻在系統啟動時啟動
/sbin/chkconfig --level 2345 iptables off
重啟iptables:
/etc/init.d/iptables restart
題外話：
BT或者騾子速度慢用不著關防火墻，只要把相應端口開放就可以了
在文件
/etc/sysconfig/iptables
在系統原始配置的:RH-Firewall-1-INPUT規則鏈增加類似這樣的行：
-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 39764 -j ACCEPT
-A RH-Firewall-1-INPUT -m state --state NEW -m udp -p udp --dport 39764 -j ACCEPT
如果發現原有-j REJECT一類的語句，上面兩句要放在它的前面

重啟後生效 
開啟： chkconfig iptables on 
關閉： chkconfig iptables off 或者 /sbin/chkconfig --level 2345 iptables off

2) 即時生效，重啟後失效
service 方式
開啟： service iptables start 
關閉： service iptables stop
iptables方式
查看防火墻狀態：
/etc/init.d/iptables status
暫時關閉防火墻：
/etc/init.d/iptables stop
重啟iptables:
/etc/init.d/iptables restart

1.    SET key value  設置指定 key 的值
2    GET key  獲取指定 key 的值。
3    GETRANGE key start end  返回 key 中字符串值的子字符
4    GETSET key value  將給定 key 的值設為 value ，並返回 key 的舊值(old value)。
5    GETBIT key offset  對 key 所儲存的字符串值，獲取指定偏移量上的位(bit)。
6    MGET key1 [key2..]  獲取所有(一個或多個)給定 key 的值。
7    SETBIT key offset value  對 key 所儲存的字符串值，設置或清除指定偏移量上的位(bit)。
8    SETEX key seconds value  將值 value 關聯到 key ，並將 key 的過期時間設為 seconds (以秒為單位)。
9    SETNX key value  只有在 key 不存在時設置 key 的值。
10    SETRANGE key offset value  用 value 參數覆寫給定 key 所儲存的字符串值，從偏移量 offset 開始。
11    STRLEN key  返回 key 所儲存的字符串值的長度。
12    MSET key value [key value ...]  同時設置一個或多個 key-value 對。
13    MSETNX key value [key value ...]  同時設置一個或多個 key-value 對，當且僅當所有給定 key 都不存在。
14    PSETEX key milliseconds value  這個命令和 SETEX 命令相似，但它以毫秒為單位設置 key 的生存時間，而不是像 SETEX 命令那樣，以秒為單位。
15    INCR key  將 key 中儲存的數字值增一。
16    INCRBY key increment  將 key 所儲存的值加上給定的增量值（increment） 。
17    INCRBYFLOAT key increment  將 key 所儲存的值加上給定的浮點增量值（increment） 。
18    DECR key  將 key 中儲存的數字值減一。
19    DECRBY key decrement  key 所儲存的值減去給定的減量值（decrement） 。
20    APPEND key value  如果 key 已經存在並且是一個字符串， APPEND 命令將 value 追加到 key 原來的值的末尾。 

1.    DEL key  該命令用於在 key 存在時刪除 key。
2    DUMP key  序列化給定 key ，並返回被序列化的值。
3    EXISTS key  檢查給定 key 是否存在。
4    EXPIRE key seconds  為給定 key 設置過期時間。
5    EXPIREAT key timestamp  EXPIREAT 的作用和 EXPIRE 類似，都用於為 key 設置過期時間。 不同在於 EXPIREAT 命令接受的時間參數是 UNIX 時間戳(unix timestamp)。
6    PEXPIRE key milliseconds  設置 key 的過期時間以毫秒計。
7    PEXPIREAT key milliseconds-timestamp  設置 key 過期時間的時間戳(unix timestamp) 以毫秒計
8    KEYS pattern  查找所有符合給定模式( pattern)的 key 。
9    MOVE key db  將當前數據庫的 key 移動到給定的數據庫 db 當中。
10    PERSIST key  移除 key 的過期時間，key 將持久保持。
11    PTTL key  以毫秒為單位返回 key 的剩余的過期時間。
12    TTL key  以秒為單位，返回給定 key 的剩余生存時間(TTL, time to live)。
13    RANDOMKEY  從當前數據庫中隨機返回一個 key 。
14    RENAME key newkey  修改 key 的名稱
15    RENAMENX key newkey  僅當 newkey 不存在時，將 key 改名為 newkey 。
16    TYPE key  返回 key 所儲存的值的類型。

springboot redis簡單結合