@Configuration
@ConditionalOnClass(CacheManager.class)
@ConditionalOnBean(CacheAspectSupport.class)
@ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
@EnableConfigurationProperties(CacheProperties.class)
@AutoConfigureAfter({ CouchbaseAutoConfiguration.class, HazelcastAutoConfiguration.class,
		HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
@Import(CacheConfigurationImportSelector.class)
public class CacheAutoConfiguration {
    。。。。
}

static class CacheConfigurationImportSelector implements ImportSelector {

		@Override
		public String[] selectImports(AnnotationMetadata importingClassMetadata) {
			CacheType[] types = CacheType.values();
			String[] imports = new String[types.length];
			for (int i = 0; i < types.length; i++) {
				imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
			}
			return imports;
		}

	}

@Bean
	public ConcurrentMapCacheManager cacheManager() {
		ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
		List<String> cacheNames = this.cacheProperties.getCacheNames();
		if (!cacheNames.isEmpty()) {
			cacheManager.setCacheNames(cacheNames);
		}
		return this.customizerInvoker.customize(cacheManager);
	}

@Override
	@Nullable
	public Cache getCache(String name) {
        //从map中获取缓存
		Cache cache = this.cacheMap.get(name);
        //如果没有获取到就给资源加锁，获取到了则直接返回。
		if (cache == null && this.dynamic) {
			synchronized (this.cacheMap) {
                //加锁后再次验证防止加锁前缓存已经被创建
				cache = this.cacheMap.get(name);
				if (cache == null) {
                    //如果仍旧为空，则进行缓存创建
					cache = createConcurrentMapCache(name);
					this.cacheMap.put(name, cache);
				}
			}
		}
		return cache;
	}

protected Cache createConcurrentMapCache(String name) {
		SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
		return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256),
				isAllowNullValues(), actualSerialization);
	}

public class ConcurrentMapCache extends AbstractValueAdaptingCache {

	private final String name;
	//缓存存储的真正位置。
	private final ConcurrentMap<Object, Object> store;
    ....
}

  /**
     * 配置自己的缓存key生成策略,可以在注解@Cacheable的属性keyGenerator上使用
     */
    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        //Lamda表达式写法
        return (target, method, params) -> method.getName() + Arrays.asList(params).toString();
        //正常写法
        return new KeyGenerator(){
            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName() + Arrays.asList(params).toString();
            }
        };
    }

@CacheEvict(value = "emp",key = "#id",allEntries = false，beforeInvocation = false)	

  @Caching(
            cacheable = {
                    @Cacheable(value = "emp",key = "#callPhone")
            },
            put = {
                    @CachePut(value = "emp",key = "#result.id"),
                    @CachePut(value = "emp",key = "#result.idCard")
            }
    )

@CacheConfig(cacheNames = "",keyGenerator = "",cacheManager = "")

@Configuration
//生效条件：存在org.springframework.data.redis.connection.RedisConnectionFactory类;
@ConditionalOnClass(RedisConnectionFactory.class)
//在此配置类生效后引入RedisAutoConfiguration.class
@AutoConfigureAfter(RedisAutoConfiguration.class)
//生效条件：容器中有RedisConnectionFactory.class的对象
@ConditionalOnBean(RedisConnectionFactory.class)
//生效条件：容器中不存在org.springframework.cache.CacheManager的对象;
@ConditionalOnMissingBean(CacheManager.class)
@Conditional(CacheCondition.class)
class RedisCacheConfiguration {
	。。。。
}

@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

  @Autowired
    private StringRedisTemplate stringRedisTemplate;

	@Test
	public void contextLoads() {
	    //存入一个数据
        stringRedisTemplate.opsForValue().append("emp", "1");
        //存入一个list
        stringRedisTemplate.opsForList().leftPush("list", "a");
        stringRedisTemplate.opsForList().leftPush("list", "b");
        stringRedisTemplate.opsForList().leftPush("list", "c");
	}

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        //此处直接new了一个RedisTemplate
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
    public RedisTemplate<Object, String> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        //创建模板对象
        RedisTemplate<Object, String> redisTemplate = new RedisTemplate<>();
        //创建序列化规则
        GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer();
        //设置默认的序列化规则
        redisTemplate.setDefaultSerializer(serializer);
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }

    @Bean
    public RedisCacheManager cacheManager(RedisTemplate<Object, Object> redisTemplate) {
        //创建CacheManager时传入了redisTemplate，序列化时就使用了这个template里的序列化规则
        //这个redisTemplate是从容器中获取的。如果我们自定义了并且名称就叫redisTemplate,这里
        //就会使用我们自己的序列化规则。
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        cacheManager.setUsePrefix(true);
        List<String> cacheNames = this.cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            cacheManager.setCacheNames(cacheNames);
        }
        return (RedisCacheManager)this.customizerInvoker.customize(cacheManager);
    }

	@Bean
	public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,
			ResourceLoader resourceLoader) {
        //创建一个builder
		RedisCacheManagerBuilder builder = RedisCacheManager
				.builder(redisConnectionFactory)
            	//设置默认的缓存配置
				.cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));
		List<String> cacheNames = this.cacheProperties.getCacheNames();
		if (!cacheNames.isEmpty()) {
			builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
		}
		return this.customizerInvoker.customize(builder.build());	
	}

/*
* 此方法获取了一个默认的RedisCacheConfiguration 缓存配置
*/
private org.springframework.data.redis.cache.RedisCacheConfiguration determineConfiguration(
			ClassLoader classLoader) {
		if (this.redisCacheConfiguration != null) {
			return this.redisCacheConfiguration;
		}
    	//从配置文件中获取redis的配置信息
		Redis redisProperties = this.cacheProperties.getRedis();
		org.springframework.data.redis.cache.RedisCacheConfiguration config = 	org.springframework.data.redis.cache.RedisCacheConfiguration
				.defaultCacheConfig();
    	//设置序列化解析规则
		config = config.serializeValuesWith(SerializationPair
				.fromSerializer(new JdkSerializationRedisSerializer(classLoader)));
    	//如果设置了过期时间就配置上
		if (redisProperties.getTimeToLive() != null) {
			config = config.entryTtl(redisProperties.getTimeToLive());
		}
        //如果设置了前缀就配置上
		if (redisProperties.getKeyPrefix() != null) {
			config = config.prefixKeysWith(redisProperties.getKeyPrefix());
		}
    	//默认存储空值
		if (!redisProperties.isCacheNullValues()) {
			config = config.disableCachingNullValues();
		}
    	//配置是否使用前缀，默认使用
		if (!redisProperties.isUseKeyPrefix()) {
			config = config.disableKeyPrefix();
		}
		return config;
	}

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    //创建序列化规则
    GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer()
    //创建默认的缓存配置类，通过链式调用设置序列化规则和缓存过期时间
 RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()               .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer))
        .entryTtl(Duration.ofHours(1));//设置默认过期时间
    return RedisCacheManager
        .builder(redisConnectionFactory).cacheDefaults(config).build();
}