SpringBoot整合redis

1、SpringBoot配置类

1.1导入redis的依赖

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

1.2配置application.yml

	spring:
	  redis:
	      database: 0
	      host: 192.168.147.144
	      port: 6379
	      password: 123456
	      jedis:
	          pool:
	              max-active: 100
	              max-idle: 3
	              max-wait: -1
	              min-idle: 0
	      timeout: 1000

1.3 新建一个config包，创建一个RedisConfig类

RedisConfig.java

	package com.javaxl.springboot02.config;
	
	import com.fasterxml.jackson.annotation.JsonAutoDetect;
	import com.fasterxml.jackson.annotation.PropertyAccessor;
	import com.fasterxml.jackson.databind.ObjectMapper;
	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.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.Jackson2JsonRedisSerializer;
	import org.springframework.data.redis.serializer.StringRedisSerializer;
	
	import java.lang.reflect.Method;
	import java.time.Duration;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;
	
	
	/**
	 * redis配置类
	 **/
	@Configuration
	@EnableCaching//开启注解式缓存
	//继承CachingConfigurerSupport，为了自定义生成KEY的策略。可以不继承。
	public class RedisConfig extends CachingConfigurerSupport {
	
	    /**
	     * 生成key的策略 根据类名+方法名+所有参数的值生成唯一的一个key
	     *
	     * @return
	     */
	    @Bean
	    @Override
	    public KeyGenerator keyGenerator() {
	        return new KeyGenerator() {
	            @Override
	            public Object generate(Object target, Method method, Object... params) {
	                StringBuilder sb = new StringBuilder();
	                sb.append(target.getClass().getName());
	                sb.append(method.getName());
	                for (Object obj : params) {
	                    sb.append(obj.toString());
	                }
	                return sb.toString();
	            }
	        };
	    }
	
	    /**
	     * 管理缓存
	     *
	     * @param redisConnectionFactory
	     * @return
	     */
	    @Bean
	    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
	        //通过Spring提供的RedisCacheConfiguration类，构造一个自己的redis配置类，从该配置类中可以设置一些初始化的缓存命名空间
	        // 及对应的默认过期时间等属性，再利用RedisCacheManager中的builder.build()的方式生成cacheManager：
	        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();  // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
	        config = config.entryTtl(Duration.ofMinutes(1))     // 设置缓存的默认过期时间，也是使用Duration设置
	                .disableCachingNullValues();     // 不缓存空值
	
	        // 设置一个初始化的缓存空间set集合
	        Set<String> cacheNames = new HashSet<>();
	        cacheNames.add("my-redis-cache1");
	        cacheNames.add("my-redis-cache2");
	
	        // 对每个缓存空间应用不同的配置
	        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
	        configMap.put("my-redis-cache1", config);
	        configMap.put("my-redis-cache2", config.entryTtl(Duration.ofSeconds(120)));
	
	        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)     // 使用自定义的缓存配置初始化一个cacheManager
	                .initialCacheNames(cacheNames)  // 注意这两句的调用顺序，一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
	                .withInitialCacheConfigurations(configMap)
	                .build();
	        return cacheManager;
	    }
	
	    @Bean
	    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
	        RedisTemplate<Object, Object> template = new RedisTemplate<>();
	        template.setConnectionFactory(connectionFactory);
	
	        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
	        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
	
	        ObjectMapper mapper = new ObjectMapper();
	        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
	        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
	        serializer.setObjectMapper(mapper);
	
	        template.setValueSerializer(serializer);
	        //使用StringRedisSerializer来序列化和反序列化redis的key值
	        template.setKeySerializer(new StringRedisSerializer());
	        template.afterPropertiesSet();
	        return template;
	    }
	
	    @Bean
	    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
	        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
	        stringRedisTemplate.setConnectionFactory(factory);
	        return stringRedisTemplate;
	    }
	
	}

简介：RedisConfig类里的方法

为什么要继承 CachingConfigurerSupport 类？

原因是：这里要重写redis键生成策略，怕两个不同的开发人员用到同一个键
例子：列如小明往redis存了一个age键值为11，小李存了age键值为13，小明可能被小李覆盖，可能还不是同一块模板的。
为了避免这种现象：这个键就存在一定的规则：类的全路径名+方法+参数
三个其中一个不同就会产生多个键，最终就不会覆盖。

			 而RedisConfig中的 keyGenerator()//就是重写redis键生成策略的方法

管理缓存

重点：1，cacheManager()方法

1. 参数redisConnectionFactory本来就有值。

    因为你配置了yml，yml配置代表了·三个步骤：1.是注册redis.properties.2.是jedispool连接池相关信息3.connectFactiry，connectFactiry交给spring管理。
    配置了则代表三个步骤都完成了。所以redisConnectionFactory就有值了。
   

2. RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();

    这行代码相当于拿到了ehcache中defaultcache的默认配置，因为这个配置可以修改，
   

3. config = config.entryTtl(Duration.ofMinutes(1))
   .disableCachingNullValues();

    设置缓存的默认过期时间，也是使用Duration设置，
    相当于将2.中拿到的默认策略改成了过期策略
    本且不能  .disableCachingNullValues(); （ 不缓存空值）
   

4. 设置一个初始化的缓存空间set集合

      Set<String> cacheNames = new HashSet<>();
      cacheNames.add("my-redis-cache1");
      cacheNames.add("my-redis-cache2");
      相当于ehcache中建立两个槽，一个槽叫my-redis-cache1，一个叫my-redis-cache2
   

5. 对每个缓存空间（槽）应用不同的配置

     Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
     configMap.put("my-redis-cache1", config); 
     configMap.put("my-redis-cache2", config.entryTtl(Duration.ofSeconds(120)));这里的
     配置改为了2分钟
   

6. 在这里正真将槽和策略绑定

    RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory) 
    // 使用自定义的缓存配置初始化一个cacheManager
    	                .initialCacheNames(cacheNames) // 注意这两句的调用顺序，一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
    	                .withInitialCacheConfigurations(configMap)
    	                .build();	
   

7. return cacheManager; 缓存完了，cacheManager就交给@Bean进行管理

虚拟化器

redisTemplate()方法相当于配置虚拟化器，将虚拟化器serializer绑定到了rdisTenplate上去了
参数： connectionFactory是连接工厂
罪后交给@Bean管理

注解

@Configuration相当于建了一个spring-*.xml配置文件的根标签,相对于xml文件注解更加灵活。
------》相当于

    @Configuration-----》<beans>
    @Bean--------》<bean>
    	<beans>
    	  <bean><bean>
    	</beans>

@EnableCaching//开启注解式缓存

SpringBoot整合redis及其注解式开发

这你就不写其他类和包了，我用的是整合mybatis时用的代码如果你要看请点击链接
链接: https://blog.csdn.net/YoonBongChi/article/details/110388406.

1. 在UserService也就是service包下的接口类的查询方法上加注解

    @Cacheable("这里写槽"); 槽在RedisConfig类中，上面有写到
   

2. 到实体类中继承serializable虚拟化器

   implements  Serializable
   

注意：配置yml文件时一定要注意别放错位置了。

成功的效果图

1. 在UserService也就是service包下的接口类的查询方法上加注解

    @Cacheable(value="这里写槽名"，condition="#bid>30"，key=”’bookid‘+#bid“);
    condition判断条件
    key 自定义建的名字，redis客户端中的键名子改了
   

2. @CachePut和@Cacheable，但@CachePut只负责存不负责取，主要用于后面的读写分离。

3. CacheEviict(value=“这里写槽名”，allEntries=true)
   这个注解是手动清除缓存,根据那个槽，清那个缓存
   写一个方法测试
   CacheEviict(value=“这里写槽名”，allEntries=true)
   void clear();

总结：

springboot整合redis，四步：
一，导入pom依赖

二，配置yml文件

三,配置RedisConfig类

四,注释