在springboot项目中使用redis缓存

提示—未整理完整代码

前期准备

1.搭建一个springboot+mybatis项目
2.安装redis（未上传，可前往官网下载）
3.安装redis桌面管理工具（未上传）

添加redis依赖，配置文件，工具类

1.在pom.xml里添加依赖

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

2.在resource文件夹下添加配置文件application-redis.yml

#application-redis.yml
#redis配置
spring:
  redis:
    #redis数据库索引
    database: 0
    #redis服务器地址
    host: "127.0.0.1"
    #redis端口号
    port: 6379
    #redis密码
    password:
    #redis连接池配置
    jedis:
      pool:
        #连接池最大的连接数（使用负值时表示没有任何限制）
        max-active: 200
        # 连接池最大阻塞等待时间（使用负值时表示没有任何限制）
        max-wait: -1
        #连接池中最大空闲连接数
        max-idle: 10
        #连接池中最小空闲连接数
        min-idle: 0
  #连接超时（单位ms）
  timeout: 1000

3.在config文件夹下创建RedisConfig.java文件

package com.hospital.total_managed.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate<String,Object>();
        //配置连接工厂
        template.setConnectionFactory(factory);
        //设置序列化类
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        //设置key类型
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        //使用指定的类型
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        //key采用String类型序列化
        template.setKeySerializer(stringRedisSerializer);

        //hash的key使用String类型序列化
        template.setHashKeySerializer(stringRedisSerializer);

        //Value的序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);

        //hash的value序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();
        return template;

    }

}

4.在utils文件夹下添加RedisUtils工具类

package com.hospital.total_managed.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.concurrent.TimeUnit;

@Component
public final class RedisUtils {

    @Autowired
    private RedisTemplate<String,Object> template;

    /**
     * 指定缓存失效时间
     * @param key
     * @param time
     * @return
     */

    public Boolean expire(String key,long time){
        try {
            if (time>0){
                template.expire(key,time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取过期时间
     * @param key
     * @return
     */
    public long getExpire(String key){
        return template.getExpire(key);
    }

    /**
     * 判断key是否存在
     */
    public boolean hasKey(String key){
        try {
            return template.hasKey(key);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     */
    public void del(String... key){
        if (key!=null&&key.length>0){
            if (key!=null && key.length==1){
                template.delete(key[0]);
            }else {
                template.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 获取key的值
     */
    public Object get(String key){
        return key==null?null:template.opsForValue().get(key);
    }

    /**
     * 设置key的值
     */
    public boolean set(String key,Object value){
        try {
            template.opsForValue().set(key,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置键并设置有效时间
     */
    public boolean set(String key,Object value,long time){
        try {
            if (time>0){
                template.opsForValue().set(key,value,time,TimeUnit.SECONDS);
                return true;
            }else {
                template.opsForValue().set(key,value);
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

}

更新版

package com.hospital.total_managed.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import java.util.Collection;
import java.util.concurrent.TimeUnit;

/**
 * redis工具类
 */
@Component
public final class RedisUtils {

    @Autowired
    private RedisTemplate<String,Object> template;

    //应对空指针
    public static RedisUtils redisUtils;
    @PostConstruct
    public void init(){
        redisUtils = this;
    }


    /**
     * 指定缓存失效时间
     * @param key
     * @param time
     * @return
     */
    public Boolean expire(String key,long time){
        try {
            if (time>0){
                template.expire(key,time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取过期时间
     * @param key
     * @return
     */
    public long getExpire(String key){
        return template.getExpire(key);
    }

    /**
     * 判断key是否存在
     */
    public boolean hasKey(String key){
        try {
            return template.hasKey(key);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     */
    public void del(String... key){
        if (key!=null&&key.length>0){
            if (key!=null && key.length==1){
                template.delete(key[0]);
            }else {
                template.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 获取key的值
     */
    public Object get(String key){
        return key==null?null:template.opsForValue().get(key);
    }

    /**
     * 设置key的值
     */
    public boolean set(String key,Object value){
        try {
            template.opsForValue().set(key,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置键并设置有效时间
     */
    public boolean set(String key,Object value,long time){
        try {
            if (time>0){
                template.opsForValue().set(key,value,time,TimeUnit.SECONDS);
                return true;
            }else {
                template.opsForValue().set(key,value);
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

}

测试

1.写入缓存

redisUtils.set(key,value,60*60*24*1);

2.读取缓存

String get_value = this.redisUtils.get("key");

3.若出现redis连接失败，可检查redis服务是否正常，比较坑的就是其他依赖包有bug。如下图，就是netty依赖的bug，导致redis无法连接，修改版本后正常。