如今，NoSql数据库的使用已经很广泛了，springboot2.0整合redis是非常容易的，只要简单配置下即可。如下是一个简单的流程。

1、pom.xml加入redis的依赖

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

2、application.yml中加入redis的配置

集群模式

spring:
  #redis集群
  redis:
    database: 0
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
      timeout: 10000
      cluster:
        nodes:
          - 127.0.0.1:6379

单机模式

spring: 
  #redis集群
  redis:
    port: 6379
    host: 192.168.157.6
    password: 123456
    pool: 
      max-active: 8
      max-wait: -1
      max-idle: 8
      min-idle: 0

如果是集权的话，直接在nodes下面添加redis的ip端口即可。
到这，其实已经整理好了，不过我们可以封装一个redis操作的bean，然后那些service要使用的话就直接注入即可。

3、redis操作工具类

package cn.myforever.blog.redis;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
 * 建议全部传string  ，就算是对象也直接朱哪位gson传进来即可
 * @author forever
 *
 */
@Service
public class RedisClusterService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 设置字符串
     * @param key
     * @param str
     */
    public void setString(String key, String str) {
        this.setObject(key, str, null);
    }
    public Boolean setNx(String key, String str) {
        return stringRedisTemplate.opsForValue().setIfAbsent(key, str);
    }
    public Long increment(String key) {
        return stringRedisTemplate.opsForValue().increment(key,1);
    }
    /**
     * 设置字符串
     * @param key key
     * @param str 值
     * @param time 超时时间，默认是秒
     */
    public void setString(String key, String str,Long time) {
        this.setObject(key, str, time);
    }
    public void setList(String key, List<String> list) {
        this.setObject(key, list, null);
    }
    public void setSet(String key, Set<String> set) {
        this.setObject(key, set, null);
    }
    public void setMap(String key, Map<String,Object> map) {
        this.setObject(key, map, null);
    }
    private void setObject(String key, Object value, Long time) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }
        if (value instanceof String) {
            // 存放string类型
            String stringValue = (String) value;
            if (time == null) {
                stringRedisTemplate.opsForValue().set(key, stringValue);
            } else {
                stringRedisTemplate.opsForValue().set(key, stringValue, time, TimeUnit.SECONDS);
            }
            return;
        }
        if (value instanceof List) {
            // 存放list類型
            @SuppressWarnings("unchecked")
            List<String> listValue = (List<String>) value;
            for (String string : listValue) {
                stringRedisTemplate.opsForList().leftPush(key, string);
            }
        }
        if (value instanceof Set) {
            // 存放list類型
            @SuppressWarnings("unchecked")
            Set<String> setValues = (Set<String>) value;
            String[] strs = setValues.toArray(new String[setValues.size()]);
            stringRedisTemplate.opsForSet().add(key, strs);
        }
        if (value instanceof Map) {
            // 存放list類型
            @SuppressWarnings("unchecked")
            Map<String,Object> maps = (Map<String,Object>) value;
            stringRedisTemplate.opsForHash().putAll(key, maps);
        }
    }
    public void delKey(String key) {
        stringRedisTemplate.delete(key);
    }
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
    public List<String> getList(String key,Long start,Long end) {
        return stringRedisTemplate.opsForList().range(key, start, end);
    }
    public String getSet(String key) {
        return stringRedisTemplate.opsForSet().pop(key);
    }
    public Object getMap(String key,String hashKey) {
        return stringRedisTemplate.opsForHash().get(key, hashKey);
    }
}

然后就到处都可以使用啦，举个例子如下：

...
@Service
public class CommonServiceImpl implements  ICommonService{
    @Autowired
    private RedisClusterService redisClusterService;
...

结语

因为通过前面几篇博文的学习，相信大家都比较熟悉springboot2.0啦，这里就不需要说那么详细了，毕竟springboot已经帮我们封装好了的。