SpringBoot使用Redis缓存的实现方法

（1）pom.xml引入jar包，如下：

  <dependency>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-data-redis</artifactid>
    </dependency>

　　（2）修改项目启动类，增加注解@enablecaching，开启缓存功能，如下：

package springboot;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.cache.annotation.enablecaching;
import org.springframework.scheduling.annotation.enablescheduling;
@springbootapplication
@enablescheduling
@enablecaching
public class springbootapplication{
  public static void main(string[] args) {
    springapplication.run(springbootapplication.class, args);
  }
}

　　（3）application.properties中配置redis连接信息，如下：

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

　　（4）新建redis缓存配置类redisconfig，如下：

package springboot.config;
import org.springframework.beans.factory.annotation.value;
import org.springframework.cache.cachemanager;
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.data.redis.cache.rediscachemanager;
import org.springframework.data.redis.connection.redisconnectionfactory;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.core.stringredistemplate;
import org.springframework.data.redis.serializer.jackson2jsonredisserializer;
import com.fasterxml.jackson.annotation.jsonautodetect;
import com.fasterxml.jackson.annotation.propertyaccessor;
import com.fasterxml.jackson.databind.objectmapper;
/**
 * redis缓存配置类
 * @author szekinwin
 *
 */
@configuration
@enablecaching
public class redisconfig extends cachingconfigurersupport{
  @value("${spring.redis.host}")
  private string host;
  @value("${spring.redis.port}")
  private int port;
  @value("${spring.redis.timeout}")
  private int timeout;
  //自定义缓存key生成策略
//  @bean
//  public keygenerator keygenerator() {
//    return new keygenerator(){
//      @override
//      public object generate(object target, java.lang.reflect.method method, object... params) {
//        stringbuffer sb = new stringbuffer();
//        sb.append(target.getclass().getname());
//        sb.append(method.getname());
//        for(object obj:params){
//          sb.append(obj.tostring());
//        }
//        return sb.tostring();
//      }
//    };
//  }
  //缓存管理器
  @bean 
  public cachemanager cachemanager(@suppresswarnings("rawtypes") redistemplate redistemplate) {
    rediscachemanager cachemanager = new rediscachemanager(redistemplate);
    //设置缓存过期时间 
    cachemanager.setdefaultexpiration(10000);
    return cachemanager;
  }
  @bean
  public redistemplate<string, string> redistemplate(redisconnectionfactory factory){
    stringredistemplate template = new stringredistemplate(factory);
    setserializer(template);//设置序列化工具
    template.afterpropertiesset();
    return template;
  }
   private void setserializer(stringredistemplate template){
      @suppresswarnings({ "rawtypes", "unchecked" })
      jackson2jsonredisserializer jackson2jsonredisserializer = new jackson2jsonredisserializer(object.class);
      objectmapper om = new objectmapper();
      om.setvisibility(propertyaccessor.all, jsonautodetect.visibility.any);
      om.enabledefaulttyping(objectmapper.defaulttyping.non_final);
      jackson2jsonredisserializer.setobjectmapper(om);
      template.setvalueserializer(jackson2jsonredisserializer);
   }
}

　　（5）新建usermapper，如下：

package springboot.dao;
import org.apache.ibatis.annotations.delete;
import org.apache.ibatis.annotations.insert;
import org.apache.ibatis.annotations.mapper;
import org.apache.ibatis.annotations.param;
import org.apache.ibatis.annotations.select;
import org.apache.ibatis.annotations.update;
import org.springframework.cache.annotation.cacheconfig;
import org.springframework.cache.annotation.cacheevict;
import org.springframework.cache.annotation.cacheput;
import org.springframework.cache.annotation.cacheable;
import springboot.domain.user;
@mapper
@cacheconfig(cachenames = "users")
public interface usermapper {
  @insert("insert into user(name,age) values(#{name},#{age})")
  int adduser(@param("name")string name,@param("age")string age);
  @select("select * from user where id =#{id}")
  @cacheable(key ="#p0") 
  user findbyid(@param("id") string id);
  @cacheput(key = "#p0")
  @update("update user set name=#{name} where id=#{id}")
  void updatabyid(@param("id")string id,@param("name")string name);
  //如果指定为 true，则方法调用后将立即清空所有缓存
  @cacheevict(key ="#p0",allentries=true)
  @delete("delete from user where id=#{id}")
  void deletebyid(@param("id")string id);
}

　　@cacheable将查询结果缓存到redis中，（key="#p0"）指定传入的第一个参数作为redis的key。

　　@cacheput，指定key，将更新的结果同步到redis中

　　@cacheevict，指定key，删除缓存数据，allentries=true,方法调用后将立即清除缓存

　　（6）service层与controller层跟上一篇整合一样，启动redis服务器，redis服务器的安装与启动可以参考之前的博客，地址如下：

　　　　

　　（7）配置log4j日志信息，如下：

## log4j配置
log4j.rootcategory=debug,stdout
## 控制台输出
log4j.appender.stdout=org.apache.log4j.consoleappender
log4j.appender.stdout.layout=org.apache.log4j.patternlayout
log4j.appender.stdout.layout.conversionpattern=%d{yyyy-mm-dd hh:mm:ss,sss} %5p %c{1}:%l - %m%n

 　　（8）验证redis缓存

　　首先我们向user表总插入一条数据，数据库显示如下：

　　现在，我们查询一下user表中id=24的数据，观擦控制台输出的信息，如下：

　　通过控制台输出信息我们可以知道，这次执行了数据库查询，并开启了redis缓存查询结果。接下来我们再次查询user表中id=24的数据，观察控制台，如下：

　　通过控制台输出信息我们可以知道，这次并没有执行数据库查询，而是从redis缓存中查询，并返回查询结果。我们查看redis中的信息，如下：

　　方法finduser方法使用了注解@cacheable(key="#p0")，即将id作为redis中的key值。当我们更新数据的时候，应该使用@cacheput(key="#p0")进行缓存数据的更新，否则将查询到脏数据。

总结

以上所述是小编给大家介绍的springboot使用redis缓存的实现方法，希望对大家有所帮助