Introduction to the method of integrating Redis with Spring Boot in the caching mechanism

This article involves many technical points: spring Data JPA, Redis, Spring MVC, Spirng Cache, so when reading this article, you need to have a certain understanding of the above technical points or you can take a look first. In this article, we will learn more about the actual technical points in the article (note that you need to download Redis Server to your local area, so make sure your local Redis is available. MySQL database is also used here. Of course, you can also use an in-memory database. test). This article will provide corresponding Eclipse code examples, which are roughly divided into the following steps:

(1) Create a new Java Maven Project;
(2) Add the corresponding code in pom.xml Dependency package;
(3) Write Spring Boot startup class;
(4) Configure application.properties;
(5) Write RedisCacheConfig configuration class;
(6) Write DemoInfo test entity class;
(7) Write the DemoInfoRepository persistence class;
(8) Write the DemoInfoService class;
(9) Write the DemoInfoController class;
(10) Test whether the code runs normally
(11) Custom cache key;

(1) Create a new Java Maven Project;

I won’t go into details about this step, just create a new spring-boot-redis Java maven project;

(2) Add the corresponding dependency package in pom.xml;

Add the corresponding dependency package in Maven, mainly including: spring boot parent node dependency; spring boot web support; cache service spring-context-support; add redis support; JPA operation database; mysql database driver, the specific pom.xml file is as follows:

<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.kfit</groupId>
 <artifactId>spring-boot-redis</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>
 <name>spring-boot-redis</name>
 <url>http://maven.apache.org</url>
 <properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <!-- 配置JDK编译版本. -->
 <java.version>1.8</java.version>
 </properties>
 <!-- spring boot 父节点依赖,
  引入这个之后相关的引入就不需要添加version配置，
  spring boot会自动选择最合适的版本进行添加。
 -->
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.3.3.RELEASE</version>
 </parent>
 <dependencies>
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <scope>test</scope>
  </dependency>
  <!-- spring boot web支持：mvc,aop... -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!--
   包含支持UI模版（Velocity，FreeMarker，JasperReports），
   邮件服务，
   脚本服务(JRuby)，
   缓存Cache（EHCache），
   任务计划Scheduling（uartz）。
  -->
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context-support</artifactId>
  </dependency>
  <!-- 添加redis支持-->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-redis</artifactId>
  </dependency>
  <!-- JPA操作数据库. -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  <!-- mysql 数据库驱动. -->
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
  </dependency>
  <!-- 单元测试. -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>
 </dependencies>
</project>

The above is the complete pom.xml file, each with simple comments .

(3) Write the Spring Boot startup class (com.kfit.App);

package com.kfit;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * Spring Boot启动类;
 *
 * @author Angel(QQ:*********)
 * @version v.0.1
 */
@SpringBootApplication
public class App {
  /**
  * -javaagent:.\lib\springloaded-1.2.4.RELEASE.jar -noverify
  * @param args
  */
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }
}

(4) Configure application.properties;

This is mainly configuration Two resources, the first is the basic information of the database; the second is the redis configuration; the third is the JPA configuration;

Src/main/resouces/application.properties：
########################################################
###datasource 配置MySQL数据源；
########################################################
spring.datasource.url = jdbc:mysql://localhost:3306/test
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10
########################################################
###REDIS (RedisProperties) redis基本配置；
########################################################
# database name
spring.redis.database=0
# server host1
spring.redis.host=127.0.0.1 
# server password
#spring.redis.password=
#connection port
spring.redis.port=6379
# pool settings ...
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
# name of Redis server
#spring.redis.sentinel.master=
# comma-separated list of host:port pairs
#spring.redis.sentinel.nodes=
########################################################
### Java Persistence Api 自动进行建表
########################################################
# Specify the DBMS
spring.jpa.database = MYSQL
# Show or not log for each sql query
spring.jpa.show-sql = true
# hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = update
# Naming strategy
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
# stripped before adding them to the entity manager)
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

(5) Write the RedisCacheConfig configuration class;

There are several main caches The classes to be implemented: the first is the CacheManager cache manager; the second is the specific operation implementation class; the third is the CacheManager factory class (this can be injected using the configuration file configuration, or can be implemented through coding); the fourth It is the cache key production strategy (of course Spring comes with its own generation strategy, but when viewed on the Redis client, it is a serialized key, which looks garbled to our naked eyes. Here we use the built-in cache strategy first).

com.kfit.config/RedisCacheConfig：
package com.kfit.config;
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;
/**
 * redis 缓存配置;
 *
 * 注意：RedisCacheConfig这里也可以不用继承：CachingConfigurerSupport，也就是直接一个普通的Class就好了；
 *
 * 这里主要我们之后要重新实现 key的生成策略，只要这里修改KeyGenerator，其它位置不用修改就生效了。
 *
 * 普通使用普通类的方式的话，那么在使用@Cacheable的时候还需要指定KeyGenerator的名称;这样编码的时候比较麻烦。
 *
 * @author Angel(QQ:412887952)
 * @version v.0.1
 */
@Configuration
@EnableCaching//启用缓存，这个注解很重要；
publicclass RedisCacheConfig extends CachingConfigurerSupport {
 /**
  * 缓存管理器.
  * @param redisTemplate
  * @return
  */
 @Bean
 public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
  CacheManager cacheManager = new RedisCacheManager(redisTemplate);
  returncacheManager;
 }
 /**
  * redis模板操作类,类似于jdbcTemplate的一个类;
  *
  * 虽然CacheManager也能获取到Cache对象，但是操作起来没有那么灵活；
  *
  * 这里在扩展下：RedisTemplate这个类不见得很好操作，我们可以在进行扩展一个我们
  *
  * 自己的缓存类，比如：RedisStorage类;
  *
  * @param factory : 通过Spring进行注入，参数在application.properties进行配置；
  * @return
  */
 @Bean
 public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
  RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
  redisTemplate.setConnectionFactory(factory);
  //key序列化方式;（不然会出现乱码;）,但是如果方法上有Long等非String类型的话，会报类型转换错误；
  //所以在没有自己定义key生成策略的时候，以下这个代码建议不要这么写，可以不配置或者自己实现ObjectRedisSerializer
  //或者JdkSerializationRedisSerializer序列化方式;
//  RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;
//  redisTemplate.setKeySerializer(redisSerializer);
//  redisTemplate.setHashKeySerializer(redisSerializer);
  returnredisTemplate;
 }
}

There are very detailed comments in the above code, but here I will briefly mention it:

RedisCacheConfig does not need to inherit here: CachingConfigurerSupport, that is, just use an ordinary Class. ; The main thing here is that we need to re-implement the key generation strategy later. As long as the KeyGenerator is modified here, it will take effect without modification in other locations. If you use the ordinary class method, you also need to specify the name of the KeyGenerator when using @Cacheable; this is more troublesome when coding.

(6) Write DemoInfo test entity class;

Write a test entity class: com.kfit.bean.DemoInfo:

package com.kfit.bean;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
/**
 * 测试实体类，这个随便;
 * @author Angel(QQ:412887952)
 * @version v.0.1
 */
@Entity
publicclass DemoInfo implements Serializable{
 privatestaticfinallongserialVersionUID = 1L;
 @Id@GeneratedValue
 privatelongid;
 private String name;
 private String pwd;
 publiclong getId() {
  returnid;
 }
 publicvoid setId(longid) {
  this.id = id;
 }
 public String getName() {
  returnname;
 }
 publicvoid setName(String name) {
  this.name = name;
 }
 public String getPwd() {
  returnpwd;
 }
 publicvoid setPwd(String pwd) {
  this.pwd = pwd;
 }
 @Override
 public String toString() {
  return"DemoInfo [id=" + id + ", name=" + name + ", pwd=" + pwd + "]";
 }
}

(7) Write DemoInfoRepository Persistence class;

DemoInfoRepository is implemented using Spirng Data JPA:

com.kfit.repository.DemoInfoRepository：
package com.kfit.repository;
import org.springframework.data.repository.CrudRepository;
import com.kfit.bean.DemoInfo;
/**
 * DemoInfo持久化类
 * @author Angel(QQ:412887952)
 * @version v.0.1
 */
publicinterface DemoInfoRepository extends CrudRepository<DemoInfo,Long> {
}

(8) Writing DemoInfoService class;

Writing DemoInfoService, there are two technical aspects here, the first is Use Spring @Cacheable annotation and RedisTemplate object to operate. The specific code is as follows:

com.kfit.service.DemoInfoService:

package com.kfit.service;
import com.kfit.bean.DemoInfo;
/**
 * demoInfo 服务接口
 * @author Angel(QQ:412887952)
 * @version v.0.1
 */
publicinterface DemoInfoService {
 public DemoInfo findById(longid);
 publicvoid deleteFromCache(longid);
 void test();
}
com.kfit.service.impl.DemoInfoServiceImpl:
package com.kfit.service.impl;
import javax.annotation.Resource;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import com.kfit.bean.DemoInfo;
import com.kfit.repository.DemoInfoRepository;
import com.kfit.service.DemoInfoService;
/**
 *
 *DemoInfo数据处理类
 *
 * @author Angel(QQ:412887952)
 * @version v.0.1
 */
@Service
publicclass DemoInfoServiceImpl implements DemoInfoService {
 @Resource
 private DemoInfoRepository demoInfoRepository;
 @Resource
 private RedisTemplate<String,String> redisTemplate;
 @Override
 publicvoid test(){
  ValueOperations<String,String> valueOperations = redisTemplate.opsForValue();
  valueOperations.set("mykey4", "random1="+Math.random());
  System.out.println(valueOperations.get("mykey4"));
 }
 //keyGenerator="myKeyGenerator"
 @Cacheable(value="demoInfo") //缓存,这里没有指定key.
 @Override
 public DemoInfo findById(longid) {
  System.err.println("DemoInfoServiceImpl.findById()=========从数据库中进行获取的....id="+id);
  returndemoInfoRepository.findOne(id);
 }
 @CacheEvict(value="demoInfo")
 @Override
 publicvoid deleteFromCache(longid) {
  System.out.println("DemoInfoServiceImpl.delete().从缓存中删除.");
 }
}

(9) Write the DemoInfoController class;

package com.kfit.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.kfit.bean.DemoInfo;
import com.kfit.service.DemoInfoService;
/**
 * 测试类.
 * @author Angel(QQ:412887952)
 * @version v.0.1
 */
@Controller
publicclass DemoInfoController {
 @Autowired
  DemoInfoService demoInfoService;
 @RequestMapping("/test")
 public@ResponseBody String test(){
  DemoInfo loaded = demoInfoService.findById(1);
System.out.println("loaded="+loaded);
DemoInfo cached = demoInfoService.findById(1);
  System.out.println("cached="+cached);
  loaded = demoInfoService.findById(2);
  System.out.println("loaded2="+loaded);
  return"ok";
 }
 @RequestMapping("/delete")
 public@ResponseBody String delete(longid){
  demoInfoService.deleteFromCache(id);
  return"ok";
 }
 @RequestMapping("/test1")
 public@ResponseBody String test1(){
  demoInfoService.test();
  System.out.println("DemoInfoController.test1()");
  return"ok";
 }
}

(10) Test whether the code is running normally

Start the application, access address: 127.0.0.1:8080/test

View the console to see:

DemoInfoServiceImpl.findById()========== Obtained from the database....id=1
loaded=DemoInfo [id=1, name=Zhang San, pwd=123456]
cached=DemoInfo [id=1, name=Zhang San, pwd=123456]
DemoInfoServiceImpl.findById()========== Obtained from the database....id=2
loaded2=DemoInfo [id=2, name=Zhang San, pwd=123456]

If you see the above print information, then the cache is successful.

Access address: 127.0.0.1:8080/test1

random1=0.9985031320746356
DemoInfoController.test1()

Second visit: http ://127.0.0.1:8080/test

loaded=DemoInfo [id=1, name=Zhang San, pwd=123456]
cached=DemoInfo [id=1, name=Zhang Three, pwd=123456]
loaded2=DemoInfo [id=2, name=Zhang San, pwd=123456]

At this time, all data is cached.

At this time, perform the deletion action: 127.0.0.1:8080/delete?id=1

Then access: 127.0.0.1:8080/test

DemoInfoServiceImpl .findById()========== Obtained from the database....id=1
loaded=DemoInfo [id=1, name=Zhang San, pwd=123456]
cached =DemoInfo [id=1, name=张三, pwd=123456]
loaded2=DemoInfo [id=2, name=张三, pwd=123456]

（11）Customized Cache key;

在com.kfit.config.RedisCacheConfig类中重写CachingConfigurerSupport中的keyGenerator ,具体实现代码如下：

/**
  * 自定义key.
  * 此方法将会根据类名+方法名+所有参数的值生成唯一的一个key,即使@Cacheable中的value属性一样，key也会不一样。
  */
 @Override
 public KeyGenerator keyGenerator() {
  System.out.println("RedisCacheConfig.keyGenerator()");
  returnnew KeyGenerator() {
   @Override
   public Object generate(Object o, Method method, Object... objects) {
    // This will generate a unique key of the class name, the method name
    //and all method parameters appended.
    StringBuilder sb = new StringBuilder();
    sb.append(o.getClass().getName());
    sb.append(method.getName());
    for (Object obj : objects) {
     sb.append(obj.toString());
    }
    System.out.println("keyGenerator=" + sb.toString());
    returnsb.toString();
   }
  };
 }

这时候在redis的客户端查看key的话还是序列化的肉眼看到就是乱码了，那么我改变key的序列方式，这个很简单，redis底层已经有具体的实现类了，我们只需要配置下：

//key序列化方式;（不然会出现乱码;）,但是如果方法上有Long等非String类型的话，会报类型转换错误；
//所以在没有自己定义key生成策略的时候，以下这个代码建议不要这么写，可以不配置或者自己实现ObjectRedisSerializer
//或者JdkSerializationRedisSerializer序列化方式;
    RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;
    redisTemplate.setKeySerializer(redisSerializer);
    redisTemplate.setHashKeySerializer(redisSerializer);

综上以上分析:RedisCacheConfig类的方法调整为：

package com.kfit.config;
import java.lang.reflect.Method;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
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.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * redis 缓存配置;
 *
 * 注意：RedisCacheConfig这里也可以不用继承：CachingConfigurerSupport，也就是直接一个普通的Class就好了；
 *
 * 这里主要我们之后要重新实现 key的生成策略，只要这里修改KeyGenerator，其它位置不用修改就生效了。
 *
 * 普通使用普通类的方式的话，那么在使用@Cacheable的时候还需要指定KeyGenerator的名称;这样编码的时候比较麻烦。
 *
 * @author Angel(QQ:412887952)
 * @version v.0.1
 */
@Configuration
@EnableCaching//启用缓存，这个注解很重要；
publicclass RedisCacheConfig extends CachingConfigurerSupport {
  /**
   * 缓存管理器.
   * @param redisTemplate
   * @return
   */
  @Bean
  public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
    CacheManager cacheManager = new RedisCacheManager(redisTemplate);
    returncacheManager;
  }
  /**
   * RedisTemplate缓存操作类,类似于jdbcTemplate的一个类;
   *
   * 虽然CacheManager也能获取到Cache对象，但是操作起来没有那么灵活；
   *
   * 这里在扩展下：RedisTemplate这个类不见得很好操作，我们可以在进行扩展一个我们
   *
   * 自己的缓存类，比如：RedisStorage类;
   *
   * @param factory : 通过Spring进行注入，参数在application.properties进行配置；
   * @return
   */
  @Bean
  public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
    redisTemplate.setConnectionFactory(factory);
    //key序列化方式;（不然会出现乱码;）,但是如果方法上有Long等非String类型的话，会报类型转换错误；
    //所以在没有自己定义key生成策略的时候，以下这个代码建议不要这么写，可以不配置或者自己实现ObjectRedisSerializer
    //或者JdkSerializationRedisSerializer序列化方式;
    RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;
    redisTemplate.setKeySerializer(redisSerializer);
    redisTemplate.setHashKeySerializer(redisSerializer);
    returnredisTemplate;
  }
  /**
   * 自定义key.
   * 此方法将会根据类名+方法名+所有参数的值生成唯一的一个key,即使@Cacheable中的value属性一样，key也会不一样。
   */
  @Override
  public KeyGenerator keyGenerator() {
    System.out.println("RedisCacheConfig.keyGenerator()");
    returnnew KeyGenerator() {
      @Override
      public Object generate(Object o, Method method, Object... objects) {
       // This will generate a unique key of the class name, the method name
       //and all method parameters appended.
       StringBuilder sb = new StringBuilder();
       sb.append(o.getClass().getName());
       sb.append(method.getName());
       for (Object obj : objects) {
         sb.append(obj.toString());
       }
       System.out.println("keyGenerator=" + sb.toString());
       returnsb.toString();
      }
    };
  }
}

这时候在访问地址：127.0.0.1:8080/test

这时候看到的Key就是：com.kfit.service.impl.DemoInfoServiceImplfindById1

在控制台打印信息是：

（1）keyGenerator=com.kfit.service.impl.DemoInfoServiceImplfindById1
（2）DemoInfoServiceImpl.findById()=========从数据库中进行获取的....id=1
（3）keyGenerator=com.kfit.service.impl.DemoInfoServiceImplfindById1
（4）loaded=DemoInfo [id=1, name=张三, pwd=123456]
（5）keyGenerator=com.kfit.service.impl.DemoInfoServiceImplfindById1
（6）cached=DemoInfo [id=1, name=张三, pwd=123456]
（7）keyGenerator=com.kfit.service.impl.DemoInfoServiceImplfindById2
（8）keyGenerator=com.kfit.service.impl.DemoInfoServiceImplfindById2
（10）DemoInfoServiceImpl.findById()=========从数据库中进行获取的....id=2
（11）loaded2=DemoInfo [id=2, name=张三, pwd=123456]

其中@Cacheable,@CacheEvict下节进行简单的介绍，这节的东西实在是太多了，到这里就打住吧，剩下的就需要靠你们自己进行扩展了。

The above is the detailed content of Introduction to the method of integrating Redis with Spring Boot in the caching mechanism. For more information, please follow other related articles on the PHP Chinese website!