Redis 安装与SpringBoot整合

ゝ一世哀愁。 2022-01-21 08:23 297阅读 0赞

# 1.前言 #

Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。我们都知道，在日常的应用中，数据库瓶颈是最容易出现的。数据量太大和频繁的查询，由于磁盘IO性能的局限性，导致项目的性能越来越低。这时候，基于内存的缓存框架，就能解决我们很多问题。例如Memcache，Redis等。将一些频繁使用的数据放入缓存读取，大大降低了数据库的负担。提升了系统的性能。

有于Memcached，对于缓存对象大小有要求，单个对象不得大于1MB，且不支持复杂的数据类型，譬如SET等。因此现在Redis用的越来越多。

# 2.**Redis 的单机版** #

*  **安装步骤：**

第一步：安装gcc编译环境

yum install gcc-c++

第二步：把redis的源码上传到linux服务器。

第三步：解压缩。

tar -zxvf redis-3.0.0.tar.gz

第四步：make

第五步：make install PREFIX=/usr/local/redis

*  **启动redis**

两种启动方式，前端启动、后台启动。

前端启动：./redis-server

后台启动：

1.  复制redis.conf到redis的安装目录
2.  修改redis.conf。修改daemonize yes
3.  \[root@bogon redis\]\# ./redis-server redis.conf

*  **客户端**

redis-cli -p 端口 -h ip地址 <-c>连接集群时使用此参数

默认端口：6379

Ip：localhost（127.0.0.1）

RedisDesktopManager：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70][]

只能在单机版环境使用。不支持redis集群。

# **3.Redis集群** #

*  **redis-cluster架构图**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1][]

架构细节:

(1)所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.

(2)节点的fail是通过集群中超过半数的节点检测失效时才生效.

(3)客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可

(4)redis-cluster把所有的物理节点映射到\[0-16383\]slot上,cluster 负责维护node<->slot<->value

Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value 时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点

*  **集群搭建**

集群中应该至少有三个节点，每个节点有一备份节点。需要6台服务器。

搭建伪分布式，需要6个redis实例。

搭建集群的步骤：

第一步：创建6个redis实例指定端口从7001到7006

第二步：修改redis.conf 打开Cluster-enable yes前面的注释。

第三步：需要一个ruby脚本。在redis源码文件夹下的src目录下。redis-trib.rb

第四步：把redis-trib.rb文件复制到到redis-cluster目录下。

第五步：执行ruby脚本之前，需要安装ruby环境。

1、yum install ruby

2、yum install rubygems

3、安装redis-trib.rb运行依赖的ruby的包。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 2][]

\[root@bogon ~\]\# gem install redis-3.0.0.gem

第六步：启动所有的redis实例。

第七步：使用redis-trib.rb创建集群。

<table style="width:426.1pt;"> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;width:426.1pt;"> <p style="margin-left:0pt;">./redis-trib.rb create --replicas 1 192.168.25.153:7001 192.168.25.153:7002 192.168.25.153:7003 192.168.25.153:7004 192.168.25.153:7005 &nbsp;192.168.25.153:7006</p> </td> 
  </tr> 
 </tbody> 
</table>

使用客户端连接集群： redis01/redis-cli -p 7001 **-c**

# 4.传统spring配置 #

redis.properties

redis.host=192.168.1.30
    redis.port=6379
    
    redis.password=123456x
    redis.timeout=60000
    
    redis.maxIdle=10
    redis.maxTotal=100
    redis.maxWaitMillis=60000
    redis.testOnBorrow=true
    redis.testOnReturn=true
    redis.testWhileIdle=true

applicationContext-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:p="http://www.springframework.org/schema/p"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
               http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-4.0.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
               http://www.springframework.org/schema/tx 
               http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
    
    	<context:property-placeholder location="classpath*:redis.properties"
    		ignore-unresolvable="true" />
    
    	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    		<property name="maxIdle" value="${redis.maxIdle}" />
    		<property name="maxTotal" value="${redis.maxTotal}" />
    		<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
    		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
    		<property name="testOnReturn" value="${redis.testOnReturn}" />
    		<property name="testWhileIdle" value="${redis.testWhileIdle}" />
    	</bean>
    
    	<bean id="jeidsConnectionFactory"
    		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    		
    		<property name="hostName" value="${redis.host}"></property>
    		<property name="port" value="${redis.port}"></property>
    		<property name="password" value="${redis.password}"></property>
    		<property name="timeout" value="${redis.timeout}"></property>
    		<property name="poolConfig" ref="jedisPoolConfig"></property>
    	</bean>
    
    	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
    		p:connection-factory-ref="jeidsConnectionFactory" />
    		
    	<bean id="redisCacheHandler" class="com.palmboo.cache.redis.RedisCacheHandler"/>
    
    </beans>

pom.xml

<dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.7.1</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>1.6.2.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>2.1.0</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.1.0</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-annotations</artifactId>
                <version>2.1.0</version>
            </dependency>

RedisTest.java

package cn.qlq.Test;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    import javax.annotation.Resource;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import cn.qlq.util.RedisUtil;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext-*.xml")
    @SuppressWarnings("all")
    public class RedisTest {
        @Autowired
        private RedisUtil redisUtil;
        @Resource(name="redisTemplate")
        private RedisTemplate redisTemplate;
    
        @Test
        public void testSpringRedis() {
            // stringRedisTemplate的操作
            // String读写
            redisTemplate.delete("myStr");
            redisTemplate.opsForValue().set("myStr", "skyLine");
            System.out.println(redisTemplate.opsForValue().get("myStr"));
            System.out.println("---------------");
    
            // List读写
            redisTemplate.delete("myList");
            redisTemplate.opsForList().rightPush("myList", "T");
            redisTemplate.opsForList().rightPush("myList", "L");
            redisTemplate.opsForList().leftPush("myList", "A");
            List<String> listCache = redisTemplate.opsForList().range("myList", 0, -1);
            for (String s : listCache) {
                System.out.println(s);
            }
            System.out.println("---------------");
    
            // Set读写
            redisTemplate.delete("mySet");
            redisTemplate.opsForSet().add("mySet", "A");
            redisTemplate.opsForSet().add("mySet", "B");
            redisTemplate.opsForSet().add("mySet", "C");
            Set<String> setCache = redisTemplate.opsForSet().members("mySet");
            for (String s : setCache) {
                System.out.println(s);
            }
            System.out.println("---------------");
    
            // Hash读写
            redisTemplate.delete("myHash");
            redisTemplate.opsForHash().put("myHash", "BJ", "北京");
            redisTemplate.opsForHash().put("myHash", "SH", "上海");
            redisTemplate.opsForHash().put("myHash", "HN", "河南");
            Map<String, String> hashCache = redisTemplate.opsForHash().entries("myHash");
            for (Map.Entry entry : hashCache.entrySet()) {
                System.out.println(entry.getKey() + " - " + entry.getValue());
            }
            System.out.println("---------------");
        }
        
    }

# 5.SpringBoot配置连接Redis #

在配置文件application.properties中添加redis的连接配置信息

# Redis数据库索引（默认为0）  
    spring.redis.database=0  
    # Redis服务器地址  
    spring.redis.host=localhost
    # Redis服务器连接端口  
    spring.redis.port=6379  
    # Redis服务器连接密码
    spring.redis.password=neuai-iot-redis
    # 连接池最大连接数（使用负值表示没有限制）  
    spring.redis.pool.max-active=200
    # 连接池最大阻塞等待时间（使用负值表示没有限制）  
    spring.redis.pool.max-wait=-1
    # 连接池中的最大空闲连接  
    spring.redis.pool.max-idle=10
    # 连接池中的最小空闲连接  
    spring.redis.pool.min-idle=0
    # 连接超时时间（毫秒）
    spring.redis.timeout=1000

1、添加引用

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
    </dependency>

2、添加自定义序列化器，这里使用fastjson

package com.example.springbootredis;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    
    import java.nio.charset.Charset;
    
    public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
        public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
        private Class<T> clazz;
    
        public FastJsonRedisSerializer(Class<T> clazz) {
            super();
            this.clazz = clazz;
        }
    
        @Override
        public byte[] serialize(T t) throws SerializationException {
            if (null == t) {
                return new byte[0];
            }
            return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
        }
    
        @Override
        public T deserialize(byte[] bytes) throws SerializationException {
            if (null == bytes || bytes.length <= 0) {
                return null;
            }
            String str = new String(bytes, DEFAULT_CHARSET);
            return (T) JSON.parseObject(str, clazz);
        }
    }

3、添加RedisConfig配置

package com.example.springbootredis;
    
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    public class RedisConfig {
    
        @Bean
        @ConditionalOnMissingBean(name = "redisTemplate")
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
    
            //使用fastjson序列化
            FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer(Object.class);
            // value值的序列化采用fastJsonRedisSerializer
            template.setValueSerializer(fastJsonRedisSerializer);
            template.setHashValueSerializer(fastJsonRedisSerializer);
            // key的序列化采用StringRedisSerializer
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashKeySerializer(new StringRedisSerializer());
    
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
        @Bean
        @ConditionalOnMissingBean(StringRedisTemplate.class)
        public StringRedisTemplate stringRedisTemplate(
                RedisConnectionFactory redisConnectionFactory) {
            StringRedisTemplate template = new StringRedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    }

4、测试使用

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/")
    public class IndexController {
    
    	@Autowired
    	private StringRedisTemplate template;
    
    	/**
    	 * 根据key值从Redis缓存取得数据
    	 * 
    	 * @param key
    	 * @return
    	 */
    	@RequestMapping("/redis/get/{key}")
    	private String get(@PathVariable("key") String key) {
    		// 返回缓存中的数据
    		return template.opsForValue().get(key);
    	}
    
    	/**
    	 * 设置数据到Redis缓存中
    	 * 
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	@RequestMapping("/redis/set/{key}/{value}")
    	private Boolean set(@PathVariable("key") String key, @PathVariable("value") String value) {
    		boolean flag = true;
    		try {
    			// 设置缓存中的数据
    			template.opsForValue().set(key, value);
    		} catch (Exception e) {
    			e.printStackTrace();
    			flag = false;
    		}
    		return flag;
    	}
    
    }

5、Redis连接通用类

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.BoundSetOperations;
    import org.springframework.data.redis.core.HashOperations;
    import org.springframework.data.redis.core.ListOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Component;
    
    /**
     * spring redis 工具类
     * 
     **/
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    @Component
    public class RedisCache
    {
        @Autowired
        public RedisTemplate redisTemplate;
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         * @return 缓存的对象
         */
        public <T> ValueOperations<String, T> setCacheObject(String key, T value)
        {
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            operation.set(key, value);
            return operation;
        }
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         * @param timeout 时间
         * @param timeUnit 时间颗粒度
         * @return 缓存的对象
         */
        public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit)
        {
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            operation.set(key, value, timeout, timeUnit);
            return operation;
        }
    
        /**
         * 获得缓存的基本对象。
         *
         * @param key 缓存键值
         * @return 缓存键值对应的数据
         */
        public <T> T getCacheObject(String key)
        {
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            return operation.get(key);
        }
    
        /**
         * 删除单个对象
         *
         * @param key
         */
        public void deleteObject(String key)
        {
            redisTemplate.delete(key);
        }
    
        /**
         * 删除集合对象
         *
         * @param collection
         */
        public void deleteObject(Collection collection)
        {
            redisTemplate.delete(collection);
        }
    
        /**
         * 缓存List数据
         *
         * @param key 缓存的键值
         * @param dataList 待缓存的List数据
         * @return 缓存的对象
         */
        public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList)
        {
            ListOperations listOperation = redisTemplate.opsForList();
            if (null != dataList)
            {
                int size = dataList.size();
                for (int i = 0; i < size; i++)
                {
                    listOperation.leftPush(key, dataList.get(i));
                }
            }
            return listOperation;
        }
    
        /**
         * 获得缓存的list对象
         *
         * @param key 缓存的键值
         * @return 缓存键值对应的数据
         */
        public <T> List<T> getCacheList(String key)
        {
            List<T> dataList = new ArrayList<T>();
            ListOperations<String, T> listOperation = redisTemplate.opsForList();
            Long size = listOperation.size(key);
    
            for (int i = 0; i < size; i++)
            {
                dataList.add(listOperation.index(key, i));
            }
            return dataList;
        }
    
        /**
         * 缓存Set
         *
         * @param key 缓存键值
         * @param dataSet 缓存的数据
         * @return 缓存数据的对象
         */
        public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet)
        {
            BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
            Iterator<T> it = dataSet.iterator();
            while (it.hasNext())
            {
                setOperation.add(it.next());
            }
            return setOperation;
        }
    
        /**
         * 获得缓存的set
         *
         * @param key
         * @return
         */
        public <T> Set<T> getCacheSet(String key)
        {
            Set<T> dataSet = new HashSet<T>();
            BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);
            dataSet = operation.members();
            return dataSet;
        }
    
        /**
         * 缓存Map
         *
         * @param key
         * @param dataMap
         * @return
         */
        public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap)
        {
            HashOperations hashOperations = redisTemplate.opsForHash();
            if (null != dataMap)
            {
                for (Map.Entry<String, T> entry : dataMap.entrySet())
                {
                    hashOperations.put(key, entry.getKey(), entry.getValue());
                }
            }
            return hashOperations;
        }
    
        /**
         * 获得缓存的Map
         *
         * @param key
         * @return
         */
        public <T> Map<String, T> getCacheMap(String key)
        {
            Map<String, T> map = redisTemplate.opsForHash().entries(key);
            return map;
        }
    
        /**
         * 获得缓存的基本对象列表
         * 
         * @param pattern 字符串前缀
         * @return 对象列表
         */
        public Collection<String> keys(String pattern)
        {
            return redisTemplate.keys(pattern);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70]: /images/20220121/ffd3fb566ec84833bbc5118fa5ec1d6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1]: /images/20220121/8924e9cd0a5649ffb5211bfbea91d73c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 2]: /images/20220121/ee4c3cc2e5e143b6b54225d6dbe840b1.png