Springbootはredisを統合して、キャッシュを実装し、Redisシリアル化ルールを構成します

1. spring-boot-starter-data-redisを導入します

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

2. application.propertiesはredis接続アドレスを構成します

spring.redis.host=192.168.137.142

3. RestTemplateを使用してredisを操作する
   • redisTemplate.opsForValue（）; //操作文字列
   • redisTemplate.opsForHash（）; //操作ハッシュ
   • redisTemplate.opsForSet（）; //操作セット
   • redisTemplate.opsForList（）; //操作リスト
   • redisTemplate.opsForZSet（）; //操作が整然と設定されている
4. キャッシュ、CacheManagerCustomizersを構成します

package com.springcache;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;


/**
 * 快速体验缓存
 * 1 开启基于注解的缓存
 * 2.标注缓存注解即可
 * **/

@MapperScan("com.springcache.dao")
@SpringBootApplication
@EnableCaching
public class SpringCacheApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(SpringCacheApplication.class, args);
    }

}

• サービス

package com.springcache.service.Impl;
import com.springcache.dao.EmpMapper;
import com.springcache.pojo.Emp;
import com.springcache.pojo.EmpExample;
import com.springcache.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author zhaochengyang
 * @version 1.0
 * @date 2020/3/27 13:33
 */

@Service
public class EmpServiceImpl implements EmpService {
    
    

    @Autowired
    private EmpMapper empMapper;

    @Override
    @Cacheable(cacheNames = {
    
    "Emp"})
    public Emp getlists(Integer no) {
    
    
       EmpExample empExample =new EmpExample();
        return empMapper.selectByPrimaryKey(no);
    }
}

• コントローラ

package com.springcache.controller;


import com.alibaba.fastjson.JSONArray;
import com.springcache.pojo.Emp;
import com.springcache.service.EmpService;
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 java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author zhaochengyang
 * @version 1.0
 * @date 2020/3/27 13:30
 */
@Controller
public class EpmController {
    
    


    @Autowired
    private EmpService empService;
    @RequestMapping("/getlist")
    @ResponseBody
    public  String getlist(){
    
    
        Map<String,Object>map =new HashMap<>();

         Emp Emp= empService.getlists(14);

         if (Emp!=null){
    
    
             map.put("Emp",Emp);
         }else {
    
    
             map.put("mgs","失败");
         }
        return JSONArray.toJSONString(map);
    }
}

• Redisシリアル化ルールを構成する

package com.springcache.config;





import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
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.*;
import java.time.Duration;

/**
 * redis配置
 * 主要是配置Redis的序列化规则，用Jackson2JsonRedisSerializer替换默认的jdkSerializer
 */
@Configuration
@EnableCaching
public class RedisConfig {
    
    

    //过期时间1天
    private Duration timeToLive = Duration.ofDays(1);
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    
    
        //默认1
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(this.timeToLive)
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
                .disableCachingNullValues();
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .transactionAware()
                .build();

        return redisCacheManager;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    
    
        StringRedisTemplate template = new StringRedisTemplate(factory);
        template.setValueSerializer(new StringRedisSerializer());
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;

    }
    private RedisSerializer<String> keySerializer() {
    
    
        return new StringRedisSerializer();
    }
    private RedisSerializer<Object> valueSerializer() {
    
    
        return new GenericJackson2JsonRedisSerializer();
    }
}