Springboot redis 整合

年末将至，是时候该把所学的总结下了。最近正好从eclipes转到idea，发现idea对模组的支持很棒。这一片先总结下springboot和redis的整合

首先添加redis服务器

直接用docker 远程拉取即可，这里不再描述

直接撸代码

1.添加依赖

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

2.在配置文件中增加配置的连接信息

## Redis 配置
## Redis数据库索引（默认为0）
spring.redis.database=0
## Redis服务器地址
spring.redis.host=127.0.0.1
## 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

好了，基本的配置就好了

我们可以写个测试类，看看调用情况

package com.hdkj.redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class RedisApplicationTests {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void contextLoads() {
        stringRedisTemplate.opsForValue().set("xmz","23");
        String xmz = stringRedisTemplate.opsForValue().get("xmz");
        System.out.println(xmz);
    }

}

输出结果：23

好了，这就是最简单的配置了。

======================================================================================================

springboot更推荐我们把配置信息写在类里面

我们可以对以上的配置信息改造下

新建一个配置实体类   RedisProperties

package com.hdkj.redis.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;

import java.util.List;

/**
 * @author xuminzhe
 * @version V1.0
 * @Project study
 * @Package com.hdkj.redis.config
 * @Description
 * @Date 2017/12/4
 */
@ConfigurationProperties(prefix = "spring.redis")
//@PropertySource("classpath:application.properties")
public class RedisProperties {
    /**
     * Database index used by the connection factory.
     */
    private int database = 0;

    /**
     * Redis url, which will overrule host, port and password if set.
     */
    private String url;

    /**
     * Redis server host.
     */
    private String host = "localhost";

    /**
     * Login password of the redis server.
     */
    private String password;

    /**
     * Redis server port.
     */
    private int port = 6379;

    /**
     * Enable SSL.
     */
    private boolean ssl;

    /**
     * Connection timeout in milliseconds.
     */
    private int timeout;

    private RedisProperties.Pool pool;

    private RedisProperties.Sentinel sentinel;

    private RedisProperties.Cluster cluster;

    public int getDatabase() {
        return this.database;
    }

    public void setDatabase(int database) {
        this.database = database;
    }

    public String getUrl() {
        return this.url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getHost() {
        return this.host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getPassword() {
        return this.password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getPort() {
        return this.port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public boolean isSsl() {
        return this.ssl;
    }

    public void setSsl(boolean ssl) {
        this.ssl = ssl;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public int getTimeout() {
        return this.timeout;
    }

    public RedisProperties.Sentinel getSentinel() {
        return this.sentinel;
    }

    public void setSentinel(RedisProperties.Sentinel sentinel) {
        this.sentinel = sentinel;
    }

    public RedisProperties.Pool getPool() {
        return this.pool;
    }

    public void setPool(RedisProperties.Pool pool) {
        this.pool = pool;
    }

    public RedisProperties.Cluster getCluster() {
        return this.cluster;
    }

    public void setCluster(RedisProperties.Cluster cluster) {
        this.cluster = cluster;
    }

    /**
     * Pool properties.
     */
    public static class Pool {

        /**
         * Max number of "idle" connections in the pool. Use a negative value to indicate
         * an unlimited number of idle connections.
         */
        private int maxIdle = 8;

        /**
         * Target for the minimum number of idle connections to maintain in the pool. This
         * setting only has an effect if it is positive.
         */
        private int minIdle = 0;

        /**
         * Max number of connections that can be allocated by the pool at a given time.
         * Use a negative value for no limit.
         */
        private int maxActive = 8;

        /**
         * Maximum amount of time (in milliseconds) a connection allocation should block
         * before throwing an exception when the pool is exhausted. Use a negative value
         * to block indefinitely.
         */
        private int maxWait = -1;

        public int getMaxIdle() {
            return this.maxIdle;
        }

        public void setMaxIdle(int maxIdle) {
            this.maxIdle = maxIdle;
        }

        public int getMinIdle() {
            return this.minIdle;
        }

        public void setMinIdle(int minIdle) {
            this.minIdle = minIdle;
        }

        public int getMaxActive() {
            return this.maxActive;
        }

        public void setMaxActive(int maxActive) {
            this.maxActive = maxActive;
        }

        public int getMaxWait() {
            return this.maxWait;
        }

        public void setMaxWait(int maxWait) {
            this.maxWait = maxWait;
        }

    }

    /**
     * Cluster properties.
     */
    public static class Cluster {

        /**
         * Comma-separated list of "host:port" pairs to bootstrap from. This represents an
         * "initial" list of cluster nodes and is required to have at least one entry.
         */
        private List<String> nodes;

        /**
         * Maximum number of redirects to follow when executing commands across the
         * cluster.
         */
        private Integer maxRedirects;

        public List<String> getNodes() {
            return this.nodes;
        }

        public void setNodes(List<String> nodes) {
            this.nodes = nodes;
        }

        public Integer getMaxRedirects() {
            return this.maxRedirects;
        }

        public void setMaxRedirects(Integer maxRedirects) {
            this.maxRedirects = maxRedirects;
        }

    }

    /**
     * Redis sentinel properties.
     */
    public static class Sentinel {

        /**
         * Name of Redis server.
         */
        private String master;

        /**
         * Comma-separated list of host:port pairs.
         */
        private String nodes;

        public String getMaster() {
            return this.master;
        }

        public void setMaster(String master) {
            this.master = master;
        }

        public String getNodes() {
            return this.nodes;
        }

        public void setNodes(String nodes) {
            this.nodes = nodes;
        }

    }

}

如果熟悉mybatis配置的朋友一定对这种方式不会陌生，接下来我们在新建一个配置类

package com.hdkj.redis.config;

import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedisPool;

import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;

/**
 * @author xuminzhe
 * @version V1.0
 * @Project study
 * @Package com.hdkj.redis.config
 * @Description
 * @Date 2017/12/4
 */
@Configuration
@EnableCaching
@Import(value = RedisAutoConfiguration.class)
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfiguration extends CachingConfigurerSupport {
    @Inject
    private RedisProperties properties;

    @Bean
    public RedisConnectionFactory jedisConnectionFactory() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(properties.getPool().getMaxActive());
        poolConfig.setMaxIdle(properties.getPool().getMaxIdle());
        poolConfig.setMaxWaitMillis(properties.getPool().getMaxWait());
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnCreate(true);
        poolConfig.setTestWhileIdle(true);
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(poolConfig);
        jedisConnectionFactory.setHostName(properties.getHost());
        if (null != properties.getPassword()) {
            jedisConnectionFactory.setPassword(properties.getPassword());
        }
        jedisConnectionFactory.setDatabase(properties.getDatabase());
        jedisConnectionFactory.setPort(properties.getPort());

        //其他配置，可再次扩展
        return jedisConnectionFactory;
    }

    @Bean(name = "redisTemplate")
    public RedisTemplate redisTemplate() {
        RedisTemplate redisTemplate = new RedisTemplate();

        redisTemplate.setConnectionFactory(jedisConnectionFactory());

//        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setValueSerializer(new StringRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.afterPropertiesSet();
        redisTemplate.setEnableTransactionSupport(true);

        return redisTemplate;
    }

    /**
     * 分布式环境下多台redis的配置
     * @return
     */
    @Bean
    public ShardedJedisPool shardedJedisPool(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(properties.getPool().getMaxActive());
        jedisPoolConfig.setMaxIdle(properties.getPool().getMaxIdle());
        jedisPoolConfig.setMaxWaitMillis(properties.getPool().getMaxWait());
        List<JedisShardInfo> jedisShardInfoList = new ArrayList<>();
        JedisShardInfo jedisShardInfo = new JedisShardInfo(properties.getHost(), properties.getPort());
        jedisShardInfo.setPassword(properties.getPassword());
        jedisShardInfoList.add(jedisShardInfo);
        return new ShardedJedisPool(jedisPoolConfig, jedisShardInfoList);
    }


}

基本的配置就完成了，这里我们再配置一个工具类用于常规的redis map的操作

package com.hdkj.redis.utils;

import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author xuminzhe
 * @version V1.0
 * @Project study
 * @Package com.hdkj.redis.utils
 * @Description redis工具类
 * @Date 2017/12/4
 */
@Component("mapRedisTemplate")
public class MapRedisTemplate {

    @Resource(name = "redisTemplate")
    private RedisTemplate<String,Object> redisTemplate;

    public Boolean hasKey(String key, Object hashKey) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        return ops.hasKey(key, hashKey);
    }

    public Boolean delete(String key) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        Long l = ops.delete(key);
        return l == 1 ? Boolean.TRUE : Boolean.FALSE;
    }

    public Boolean delete(String key, Object hashKey) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        Long l = ops.delete(key, hashKey);
        return l > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    public Object get(String key, Object hashKey) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        return ops.get(key, hashKey);
    }

    public Map<Object, Object> entries(String key) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        return ops.entries(key);
    }

    public Set<Object> keys(String key) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        return ops.keys(key);
    }

    public List<Object> values(String key) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        return ops.values(key);
    }

    public Long size(String key) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        return ops.size(key);
    }

    public void put(String key, Object hashKey, Object value) {

        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        ops.put(key, hashKey, value);
    }

    public void put(String key, Object hashKey, Object value,Long expireIn) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        ops.put(key, hashKey, value);
        redisTemplate.expire(key, expireIn, TimeUnit.MILLISECONDS);
    }

    public void putIfAbsent(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> ops = redisTemplate.opsForHash();
        ops.putIfAbsent(key, hashKey, value);
    }

}

好了，这就是一个简单的redis项目的配置。

======================================================================================================================================

有个问题还没解决：其他模块在调用redis模块,读取的是自己本身模块路劲下的配置文件信息，所以在调用的时候老是会失败，我暂时的处理方式是把配置信息写到  其他模块中。但是这种方式太不优雅了，有哪位朋友遇到相同情况的可以交流下。

======================================================================================================================================

项目在做自增的时候报  nested exception is redis.clients.jedis.exceptions.JedisDataException: ERR value is not an integer or out of range

发现redis  默认的序列化是JdkSerializationRedisSerializer，其将初始值变成了序列化字符串存入了Redis，而Redis执行INCRBY命令时是无法识别序列化字符串为整数的。从而导致以上错误

所以我们要修改为项目中序列化的方式