本地连接服务器Redis配置，附带springboot中redis的yml配置

一时失言乱红尘 2024-03-31 14:53 55阅读 0赞

首先，我们安装完redis，并对redis有**基础**了解之后，肯定是想通过redis工具可视化工具连接redis，或使用springboot操作redis，下面先说说会遇到的问题吧。

### Problem One ###

**springboot操作redis失败！**

解决办法：

**①修改redis.conf配置文件**

![cd4b6edcfcea4adaa31dca68a4009f93.png][]

![4e82b1387229450180f1f732ff62ab00.png][]

**②开放端口（安全组操作）**

![c5c403ed04904f1d8b38b284e58f93da.png][]

**③测试**

springboot jedis测试

@Test
        public void demo5() { //Zset 数据操作
            Jedis jedis = new Jedis("192.168.204.88", 6379);
            String ping = jedis.ping();
            System.out.println("PING:" + ping);
       }

![9f18f8c50a0f4033af90fe684c4520be.png][]

**Ping**成功啦！ 说明我们连接成功了

温馨提示：大家启动redis服务的时候，要**指定自己自定义的redis.conf文件.**

**例如：**

redis-server /Mytool/Redis6/redis.conf

### **redis可视化工具（Redis Desktop Manager）** ###

![cf57620e6d9643e691ce534bb6a1de16.png][]

这里我就不写安装的过程了，下面这个是给大家推荐其他博主的安装帮助方法。

[Redis Desktop Manager(Redis可视化工具)安装及使用教程][Redis Desktop Manager_Redis]

### **springboot整合redis** ###

**application.yml 配置文件**

redis:
      # redis数据库索引(默认为0)，我们使用索引为3的数据库，避免和其他数据库冲突
      database: 0
      # redis服务器地址（默认为loaclhost）
      host: 192.168.204.88
      # redis端口（默认为6379）
      port: 6379
      # redis访问密码（默认为空）
    #  password:
      # redis连接超时时间（单位毫秒）
      timeout: 0
      # redis连接池配置
      pool:
        # 最大可用连接数（默认为8，负数表示无限）
        max-active: 8
        # 最大空闲连接数（默认为8，负数表示无限）
        max-idle: 8
        # 最小空闲连接数（默认为0，该值只有为正数才有用）
        min-idle: 0
        # 从连接池中获取连接最大等待时间（默认为-1，单位为毫秒，负数表示无限）
        max-wait: -1

下面是redis的使用方法 此方法借鉴博主sangeng.

utils包 RedisCache类

package com.example.springsecurity_one.utils;
    
    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.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Component;
    
    import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    @Component
    public class RedisCache
    {
        @Autowired
        public RedisTemplate redisTemplate;
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         */
        public <T> void setCacheObject(final String key, final T value)
        {
            redisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         * @param timeout 时间
         * @param timeUnit 时间颗粒度
         */
        public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
        {
            redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
        }
    
        /**
         * 设置有效时间
         *
         * @param key Redis键
         * @param timeout 超时时间
         * @return true=设置成功；false=设置失败
         */
        public boolean expire(final String key, final long timeout)
        {
            return expire(key, timeout, TimeUnit.SECONDS);
        }
    
        /**
         * 设置有效时间
         *
         * @param key Redis键
         * @param timeout 超时时间
         * @param unit 时间单位
         * @return true=设置成功；false=设置失败
         */
        public boolean expire(final String key, final long timeout, final TimeUnit unit)
        {
            return redisTemplate.expire(key, timeout, unit);
        }
    
        /**
         * 获得缓存的基本对象。
         *
         * @param key 缓存键值
         * @return 缓存键值对应的数据
         */
        public <T> T getCacheObject(final String key)
        {
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            return operation.get(key);
        }
    
        /**
         * 删除单个对象
         *
         * @param key
         */
        public boolean deleteObject(final String key)
        {
            return redisTemplate.delete(key);
        }
    
        /**
         * 删除集合对象
         *
         * @param collection 多个对象
         * @return
         */
        public long deleteObject(final Collection collection)
        {
            return redisTemplate.delete(collection);
        }
    
        /**
         * 缓存List数据
         *
         * @param key 缓存的键值
         * @param dataList 待缓存的List数据
         * @return 缓存的对象
         */
        public <T> long setCacheList(final String key, final List<T> dataList)
        {
            Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
            return count == null ? 0 : count;
        }
    
        /**
         * 获得缓存的list对象
         *
         * @param key 缓存的键值
         * @return 缓存键值对应的数据
         */
        public <T> List<T> getCacheList(final String key)
        {
            return redisTemplate.opsForList().range(key, 0, -1);
        }
    
        /**
         * 缓存Set
         *
         * @param key 缓存键值
         * @param dataSet 缓存的数据
         * @return 缓存数据的对象
         */
        public <T> BoundSetOperations<String, T> setCacheSet(final String key, final 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(final String key)
        {
            return redisTemplate.opsForSet().members(key);
        }
    
        /**
         * 缓存Map
         *
         * @param key
         * @param dataMap
         */
        public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
        {
            if (dataMap != null) {
                redisTemplate.opsForHash().putAll(key, dataMap);
            }
        }
    
        /**
         * 获得缓存的Map
         *
         * @param key
         * @return
         */
        public <T> Map<String, T> getCacheMap(final String key)
        {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * 往Hash中存入数据
         *
         * @param key Redis键
         * @param hKey Hash键
         * @param value 值
         */
        public <T> void setCacheMapValue(final String key, final String hKey, final T value)
        {
            redisTemplate.opsForHash().put(key, hKey, value);
        }
    
        /**
         * 获取Hash中的数据
         *
         * @param key Redis键
         * @param hKey Hash键
         * @return Hash中的对象
         */
        public <T> T getCacheMapValue(final String key, final String hKey)
        {
            HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
            return opsForHash.get(key, hKey);
        }
    
        /**
         * 删除Hash中的数据
         * 
         * @param key
         * @param hkey
         */
        public void delCacheMapValue(final String key, final String hkey)
        {
            HashOperations hashOperations = redisTemplate.opsForHash();
            hashOperations.delete(key, hkey);
        }
    
        /**
         * 获取多个Hash中的数据
         *
         * @param key Redis键
         * @param hKeys Hash键集合
         * @return Hash对象集合
         */
        public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
        {
            return redisTemplate.opsForHash().multiGet(key, hKeys);
        }
    
        /**
         * 获得缓存的基本对象列表
         *
         * @param pattern 字符串前缀
         * @return 对象列表
         */
        public Collection<String> keys(final String pattern)
        {
            return redisTemplate.keys(pattern);
        }
    }

config包 RedisConfig类

package com.example.springsecurity_one.config;
    
    import com.example.springsecurity_one.utils.FastJsonRedisSerializer;
    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.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedisConfig {
    
        @Bean
        @SuppressWarnings(value = { "unchecked", "rawtypes" })
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
        {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(connectionFactory);
    
            FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
    
            // 使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(serializer);
    
            // Hash的key也采用StringRedisSerializer的序列化方式
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(serializer);
    
            template.afterPropertiesSet();
            return template;
        }
    }

[cd4b6edcfcea4adaa31dca68a4009f93.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/354f595ef5c84071a79c575463170aa4.png
[4e82b1387229450180f1f732ff62ab00.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8ffaf9bcdfa94c5a98238997bdfa7ce0.png
[c5c403ed04904f1d8b38b284e58f93da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/0fbc822f28a04d6294bd9cd6fc1cf0a0.png
[9f18f8c50a0f4033af90fe684c4520be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/7daab080ff9f4959851708cde3cc8072.png
[cf57620e6d9643e691ce534bb6a1de16.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/bcdf4a51ca444e99b73549569004da2c.png
[Redis Desktop Manager_Redis]: https://blog.csdn.net/JacaCao/article/details/106088148