spring boot下redis的配置使用

￡神魔★判官ぃ 2022-06-06 00:20 227阅读 0赞

这里说说在spring boot 下redis的配置和简单使用，这里前提时你的redis已经安装好

通过maven添加对redis的支持：

<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>2.9.0</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    			<version>3.4</version>
    		</dependency>

在application.properties添加redis配置信息

#redis配置
    #节点，多个节点用,分隔：127.0.0.1:6379,127.0.0.1:6378,127.0.0.1:6377
    #spring.redis.cluster.nodes=172.30.12.14:6379
    spring.redis.cluster.ip=172.30.12.14
    spring.redis.cluster.port=6379
    spring.redis.cluster.password=inhand@redis2017
    #最大连接数, 默认8个,一些低版本的包是maxActive，如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    spring.redis.cluster.maxTotal=100
    #控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
    spring.redis.cluster.maxIdle=20
    #控制一个pool最少有多少个状态为idle(空闲的)的jedis实例。
    spring.redis.cluster.minIdle=2
    #等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    spring.redis.cluster.maxWait=10000
    #在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的
    spring.redis.cluster.testOnBorrow=true
    #jedis调用returnObject方法时，是否进行有效检查
    spring.redis.cluster.testOnReturn=false
    #读取超时
    spring.redis.cluster.timeout=5000
    #连接超时
    spring.redis.cluster.connectionTimeout=5000
    #最大尝试次数
    spring.redis.cluster.maxAttempts=3

然后通过sping boot强大的注解功能，帮我们把配置信息注入到实体类：

import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    
    // 特别注意：@ConfigurationProperties(prefix = "spring.redis.cluster")
    // 中spring.redis.cluster要和application.properties中的前缀对应。
    @Component
    @ConfigurationProperties(prefix = "spring.redis.cluster")
    public class RedisProperties
    {
    
        // 自动注入redis配置
        private String nodes;
    
        private String ip;
    
        private int port;
    
        private String password;
    
        private int maxTotal;
    
        private int maxIdle;
    
        private int minIdle;
    
        private int maxWait;
    
        private boolean testOnBorrow;
    
        private boolean testOnReturn;
    
        private int timeout;
    
        private int connectionTimeout;
    
        private int maxAttempts;
    
        public String getNodes()
        {
            return nodes;
        }
    
        public void setNodes(String nodes)
        {
            this.nodes = nodes;
        }
    
        public String getIp()
        {
    
            return ip;
        }
    
        public void setIp(String ip)
        {
    
            this.ip = ip;
        }
    
        public int getPort()
        {
    
            return port;
        }
    
        public void setPort(int port)
        {
    
            this.port = port;
        }
    
        public String getPassword()
        {
            return password;
        }
    
        public void setPassword(String password)
        {
            this.password = password;
        }
    
        public int getMaxTotal()
        {
            return maxTotal;
        }
    
        public void setMaxTotal(int maxTotal)
        {
            this.maxTotal = maxTotal;
        }
    
        public int getMaxIdle()
        {
            return maxIdle;
        }
    
        public void setMaxIdle(int maxIdle)
        {
            this.maxIdle = maxIdle;
        }
    
        public int getMinIdle()
        {
            return minIdle;
        }
    
        public void setMinIdle(int minIdle)
        {
            this.minIdle = minIdle;
        }
    
        public int getMaxWait()
        {
            return maxWait;
        }
    
        public void setMaxWait(int maxWait)
        {
            this.maxWait = maxWait;
        }
    
        public boolean isTestOnBorrow()
        {
            return testOnBorrow;
        }
    
        public void setTestOnBorrow(boolean testOnBorrow)
        {
            this.testOnBorrow = testOnBorrow;
        }
    
        public boolean isTestOnReturn()
        {
            return testOnReturn;
        }
    
        public void setTestOnReturn(boolean testOnReturn)
        {
            this.testOnReturn = testOnReturn;
        }
    
        public int getTimeout()
        {
            return timeout;
        }
    
        public void setTimeout(int timeout)
        {
            this.timeout = timeout;
        }
    
        public int getConnectionTimeout()
        {
            return connectionTimeout;
        }
    
        public void setConnectionTimeout(int connectionTimeout)
        {
            this.connectionTimeout = connectionTimeout;
        }
    
        public int getMaxAttempts()
        {
            return maxAttempts;
        }
    
        public void setMaxAttempts(int maxAttempts)
        {
            this.maxAttempts = maxAttempts;
        }
    
    }

然后在初始化连接：

import java.util.HashMap;
    import java.util.Map;
    import java.util.Properties;
    
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.core.env.Environment;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    
    import redis.clients.jedis.JedisPool;
    
    
    
    @Configuration
    public class ApplicationConfig extends WebMvcConfigurerAdapter
    {
    
    
        // ---------------配置redis-----------------------
    
        /**
         * 1、JedisCluster管理集群与ShardedJedisPool分片连接池实现分布式的区别
         * ShardedJedisPool是redis没有集群功能之前客户端实现的一个数据分布式方案
         * ，redis3.0提供集群之后，客户端则采用JedisCluster实现连接redis集群环境。
         * ShardedJedisPool使用的是JedisShardInfo的instance的顺序或者name来做的一致性哈希 ，JedisCluster使用的是CRC16算法来做的哈希槽。
         * redis cluster配置集群与使用Jedis的ShardedJedis做Redis集群的区别 2、集群环境，各个服务之间的数据是隔离的
         * 无论是ShardedJedisPool的一致性哈希算法还是JedisCluster的CRC16哈希槽算法，都是把所有的服务叠加然后进行均匀的分割，
         * 分割出来的每一个段或槽都是不重复的，所以导致存储的数据彼此之间也是处于隔离状态的。
         * 3、jedis客户端操作redis主要三种模式：单台模式、分片模式（ShardedJedis）、集群模式（BinaryJedisCluster）， 分片模式是一种轻量级集群
         **/
    
    	 //注入配置属性的类
        @Autowired
        private RedisProperties redisProperties;
    
        /**
         * 注意： 这里返回的JedisCluster是单例的，并且可以直接注入到其他类中去使用 使用：
         * 
         * @Autowired private JedisCluster jc;
         */
    	 
    	 /**
         * redis集群模式
         * 
         * @return
         */
        // @Bean
        // public JedisCluster getJedisCluster() {
        //
        // String[] serverArray = redisProperties.getNodes().split(",");//
        // 获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
        // Set<HostAndPort> nodes = new HashSet<>();
        //
        // for (String ipPort : serverArray) {
        // String[] ipPortPair = ipPort.split(":");
        // nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer
        // .valueOf(ipPortPair[1].trim())));
        // }
        //
        // //集群配置
        // JedisCluster jc = new JedisCluster(nodes,
        // redisProperties.getConnectionTimeout(),
        // redisProperties.getTimeout(), redisProperties.getMaxAttempts(),
        // redisProperties.getPassword(), genericObjectPoolConfig());
        //
        // return jc;
        //
        // }
    
        /**
         * redis单机模式
         * 
         * @return
         */
        @Bean
        public JedisPool getJedisPool()
        {
    
            JedisPool jedisPool = new JedisPool(genericObjectPoolConfig(), redisProperties.getIp(),
                redisProperties.getPort(), redisProperties.getTimeout(), redisProperties.getPassword());
    
            return jedisPool;
        }
    
        /**
         * 初始化连接池
         * 
         * @return
         */
        private GenericObjectPoolConfig genericObjectPoolConfig()
        {
    
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
    
            poolConfig.setMaxTotal(redisProperties.getMaxTotal());
            poolConfig.setMaxIdle(redisProperties.getMaxIdle());
            poolConfig.setMinIdle(redisProperties.getMinIdle());
            poolConfig.setMaxWaitMillis(redisProperties.getMaxWait());
            poolConfig.setTestOnBorrow(redisProperties.isTestOnBorrow());
            poolConfig.setTestOnReturn(redisProperties.isTestOnReturn());
    
            return poolConfig;
        }
    
    }

到这基本可以使用了。

示例：

@Autowired
        private JedisPool jedisPool;
    
     public String get(String key)
        {
            Jedis jedis = null;
            String ret = null;
            try
            {
                jedis = jedisPool.getResource();
                ret = jedis.get(key);
            }
            catch (Exception e)
            {
                log.error(this, e);
            }
            finally
            {
                jedis.close();
            }
            return ret;
        }