Primavera caché caché utilizando Redis

Reids es clave para la base de datos de caché

Redis web oficial

Redis web oficial no es compatible con la versión de Windows

Windows versión descarga aquí

manifestación

pom.xml

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

applciation.yml

spring:
  cache:
#    cache-names 没有生效
#    cache-names:
#      - cache1
#      - cache2
#    type: redis
    redis:
#      缓存生存时间5s 过期自动消除
      time-to-live: 5000
  redis:
#    redis ip
    host: 127.0.0.1
#    redis 密码
    password: jsong
#    端口号
    port: 6379
server:
  port: 8081

configuraciones de caché Redis también se pueden implementar mediante la configuración de la forma de frijol

RedisConfig.java

el grano también está equipado con una configuración serializado Redis valor clave, para evitar la distorsión de
este blog registra el proceso de aprendizaje del problema de la basura
frijol RedisTemplate puede hacer comentarios, se utiliza para establecer get ReDiS caché, también hizo una serie de tratamientos

	为什么需要序列化呢
	正常我们在使用oracle，mysql存储的时候，同样需要序列化
	只不过这部分工作jdbc帮我们做了，我们不需要在做了

package com.jsong.wiki.redis.config;

import org.springframework.cache.CacheManager;
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.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

import static java.util.Collections.singletonMap;


@Configuration
public class RedisConfig {


    @Bean("myRedisTemplate")
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();

        redisTemplate.setConnectionFactory(redisConnectionFactory);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // 序列化key 否则乱码
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);

        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 序列化value 否则乱码
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return redisTemplate;
    }

    @Bean
    public CacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(defaultCacheConfig())
                .withInitialCacheConfigurations(singletonMap("predefined", defaultCacheConfig().disableCachingNullValues()))
                .transactionAware()
                .build();

        return cacheManager;
    }
// redis配置
    private RedisCacheConfiguration defaultCacheConfig() {
        //  TTL  Time To Live
        /*前缀
         * 过期时间 10s == yml  spring.cache.redis.time-to-live
         * key序列化
         * value序列化
         * */
        RedisCacheConfiguration redisCacheConfiguration =
                RedisCacheConfiguration.defaultCacheConfig()
                        .prefixKeysWith("redis:")
                        .entryTtl(Duration.ofSeconds(10))
                        .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        return redisCacheConfiguration;
    }
}

RedisService.java

Aquí comentario almacenamiento en caché usada

• @EnableCaching
  abierta la caché

• @CacheConfig (cacheManager = "redisCacheManager")
  especifica el administrador de caché

• @Cacheable (valor = "cache1", clave = "# root.caches [0] .name")
  está ajustado y el valor de clave de caché

descripciones de caché primavera, miran a este comentario

package com.jsong.wiki.redis.service;

import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.stereotype.Component;

@EnableCaching
@CacheConfig(cacheManager = "redisCacheManager")
@Component
public class RedisService {

    @Cacheable(value = "cache1",key = "#root.caches[0].name")
    public String getCache1() {
        return "cache1Value";
    }

    @Cacheable(value = "cache2",key = "#root.caches[0].name")
    public String getCache2() {
        return "cache2Value";
    }
}

RedisController.java

package com.jsong.wiki.redis.controller;

import com.jsong.wiki.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class RedisController {
    @Autowired
    RedisService redisService;

    @RequestMapping("/cache1")
    public String getCache1() {
        redisService.getCache2();
        return redisService.getCache1();
    }
}

pruebas de acceso

http: // localhost: 8081 / test / cache1

Redis puede ver, ya tenemos una caché de datos

Como nos fijamos una fecha de caducidad, después de que los Redis caducidad se borrará la caché