簡介

在網際網路的應用中，redis被廣泛地使用。而在spring boot中使用redis，是非常簡單的。

spring boot 中的redis

要在spring boot中使用redis，在pom中加入spring-boot-starter-redis依賴。maven會新增spring-data-redis包，其中包含了jedis，jredis，lettuce，srp幾種實現。spring boot預設選擇jedis實現使用。

jedis配置

預設使用localhost的redis配置，如果你沒有修改任何配置，在本機上測試，不需要做任何配置。但在生成環境，必須配置真實的環境。

spring:
    # REDIS (RedisProperties)
    redis:
        # Redis資料庫索引（預設為0）    
        database:0
        # Redis伺服器地址
        host:localhost
        # Redis伺服器連線埠
        port:6379
        # Redis伺服器連線密碼（預設為空）
        password:
        # 連線池最大連線數（使用負值表示沒有限制）
        pool.max-active:8
        # 連線池最大阻塞等待時間（使用負值表示沒有限制）
 

        pool.max-wait:-1
        # 連線池中的最大空閒連線
        pool.max-idle:8
        # 連線池中的最小空閒連線
        pool.min-idle:0
        # 連線超時時間（毫秒)
        timeout:0

使用StringRedisTemplate來處理String

在spring-data-redis中提供了StringRedisTemplate，可以直接用來處理String資料了。

// 可以直接使用，spring會繫結 
@Autowired
private StringRedisTemplate template;

@RequestMapping("/foo"
 
)
@ResponseBody
public String foo() {
        ValueOperations<String, String> ops = template.opsForValue();
        String key = "spring.boot.redis.test";
        if (!this.template.hasKey(key)) {
            String str = "not found the key, now set it";
            log.info(str);
            ops.set(key, str);
            return str;
        } else {

            String str = "Found key " + key + ", value=" + ops.get(key);
            log.info(str);
            return str;
        }

    }   

可以看一下spring中的實現類：

/*
 * Copyright 2011-2013 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.data.redis.core;

import org.springframework.data.redis.connection.DefaultStringRedisConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.StringRedisConnection;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * String-focused extension of RedisTemplate. Since most operations against Redis are String based, this class provides
 * a dedicated class that minimizes configuration of its more generic {@link RedisTemplate template} especially in terms
 * of serializers.
 * <p/>
 * Note that this template exposes the {@link RedisConnection} used by the {@link RedisCallback} as a
 * {@link StringRedisConnection}.
 * 
 * @author Costin Leau
 */
public class StringRedisTemplate extends RedisTemplate<String, String> {

    /**
     * Constructs a new <code>StringRedisTemplate</code> instance. {@link #setConnectionFactory(RedisConnectionFactory)}
     * and {@link #afterPropertiesSet()} still need to be called.
     */
    public StringRedisTemplate() {
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        setKeySerializer(stringSerializer);
        setValueSerializer(stringSerializer);
        setHashKeySerializer(stringSerializer);
        setHashValueSerializer(stringSerializer);
    }

    /**
     * Constructs a new <code>StringRedisTemplate</code> instance ready to be used.
     * 
     * @param connectionFactory connection factory for creating new connections
     */
    public StringRedisTemplate(RedisConnectionFactory connectionFactory) {
        this();
        setConnectionFactory(connectionFactory);
        afterPropertiesSet();
    }

    protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        return new DefaultStringRedisConnection(connection);
    }
}

在實現中，RedisTemplate和其子類中包含了幾種不同的Serializer，分別對應Key，Value，Hash……，而最簡單的String型別，在stringSerializer變數上例項化為StringRedisSerializer。

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {

    private boolean enableTransactionSupport = false;
    private boolean exposeConnection = false;
    private boolean initialized = false;
    private boolean enableDefaultSerializer = true;
    private RedisSerializer<?> defaultSerializer;
    private ClassLoader classLoader;

    private RedisSerializer keySerializer = null;
    private RedisSerializer valueSerializer = null;
    private RedisSerializer hashKeySerializer = null;
    private RedisSerializer hashValueSerializer = null;
    private RedisSerializer<String> stringSerializer = new StringRedisSerializer();

 ...

 /**
   * Constructs a new <code>RedisTemplate</code> instance.
   */
    public RedisTemplate() {}

    public void afterPropertiesSet() {

        super.afterPropertiesSet();

        boolean defaultUsed = false;

        if (defaultSerializer == null) {

            defaultSerializer = new JdkSerializationRedisSerializer(
                    classLoader != null ? classLoader : this.getClass().getClassLoader());
        }

        if (enableDefaultSerializer) {

            if (keySerializer == null) {
                keySerializer = defaultSerializer;
                defaultUsed = true;
            }
            if (valueSerializer == null) {
                valueSerializer = defaultSerializer;
                defaultUsed = true;
            }
            if (hashKeySerializer == null) {
                hashKeySerializer = defaultSerializer;
                defaultUsed = true;
            }
            if (hashValueSerializer == null) {
                hashValueSerializer = defaultSerializer;
                defaultUsed = true;
            }
        }

        if (enableDefaultSerializer && defaultUsed) {
            Assert.notNull(defaultSerializer, "default serializer null and not all serializers initialized");
        }

        if (scriptExecutor == null) {
            this.scriptExecutor = new DefaultScriptExecutor<K>(this);
        }

        initialized = true;
    }

} 

可以看到spring boot應用在啟動時，如果沒有檢查到對應的物件配置，則最後例項化defaultSerializer物件為JdkSerializationRedisSerializer了。

可以看一下執行時的物件

使用RedisTemplate

在程式中使用 RedisTemplate，如上所說，需要配置對應的serializer，否則對對應的資料處理時，要麼serializer物件為null，要麼使用的預設的則使用JdkSerializationRedisSerializer。

要配置我們的redisTemplate物件，可以在配置類中定義一個redisTemplate 的bean。

@Bean  
    public RedisTemplate<String, ? extends Object> redisTemplate(  
            RedisConnectionFactory factory) {  
        StringRedisTemplate template = new StringRedisTemplate(factory);  
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(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);  
        template.afterPropertiesSet();  
        return template;  
    } 

在配置類中，定義了Jackson2JsonRedisSerializer，來作為ValueSerializer物件，對Model物件進行序列化和反序列化。

然後在程式處理的地方，可以使用這個bean物件了。

@Autowired
private RedisTemplate redisTemplate;


@RequestMapping("/user/{id}")
@ResponseBody
public String getUser(@PathVariable("id") long id) {
    log.info("---- getUser");
    //
    User user = new User(id, "[email protected]", "aa", "aa123456", "aa", "123");
    ValueOperations<String, User> operations = redisTemplate.opsForValue();
    operations.set("com.dcloud.user", user);
    // 有超時時間的redis set..
    operations.set("com.dcloud.user.ex", user, 10, TimeUnit.SECONDS);

    //
    boolean exists = redisTemplate.hasKey("com.dcloud.user");
    if (exists) {
        log.info("exists is true");
    } else {
        log.info("exists is false");
    }

    return "finished";
}


@RequestMapping(value = "/query")
@ResponseBody
public String query() {
    log.info("query from redis");
    ValueOperations<String, User> operations = redisTemplate.opsForValue();
    // 
    User ret = operations.get("com.dcloud.user");
    if (null == ret) {
        log.info("not exist user");
        return "finished query, and not exists";
    }

    log.info(ret.toString());

    return "finished query";
}

現在可以看一下執行時的redisTemplate物件