缓存系统的用来代替直接访问数据库，用来提升系统性能，减小数据库复杂。早期缓存跟系统在一个虚拟机里，这样内存访问，速度最快。 后来应用系统水平扩展，缓存作为一个独立系统存在，如redis，但是每次从缓存获取数据，都还是要通过网络访问才能获取，效率相对于早先从内存里获取，还是差了点。如果一个应用，比如传统的企业应用，一次页面显示，要访问数次redis，那效果就不是特别好，因此，现在有人提出了一二级缓存。即一级缓存跟系统在一个虚拟机内，这样速度最快。二级缓存位于redis里，当一级缓存没有数据的时候，再从redis里获取，并同步到一级缓存里。

现在实现这种一二级缓存的也挺多的，比如 hazelcast,新版的Ehcache..不过，实际上，如果你用spring boot，手里又一个Redis，则不需要搞hazelcastEhcache，只需要200行代码，就能在spring boot基础上，提供一个一二级缓存，代码如下：

import java.io.UnsupportedEncodingException;

import java.util.concurrent.ConcurrentHashMap;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.autoconfigure.AutoConfigureBefore;

import org.springframework.boot.bind.RelaxedPropertyResolver;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Condition;

import org.springframework.context.annotation.ConditionContext;

import org.springframework.context.annotation.Conditional;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.type.AnnotatedTypeMetadata;

import org.springframework.data.redis.cache.RedisCache;

import org.springframework.data.redis.cache.RedisCacheManager;

import org.springframework.data.redis.cache.RedisCachePrefix;

import org.springframework.data.redis.connection.Message;

import org.springframework.data.redis.connection.MessageListener;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisOperations;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.listener.PatternTopic;

import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

@Configuration

@Conditional(StarterCacheCondition.class)

public class CacheConfig {

	@Value("${springext.cache.redis.topic:cache}")

	String topicName ;

	@Bean

	public MyRedisCacheManager cacheManager(RedisTemplate<Object, Object> redisTemplate) {

		MyRedisCacheManager cacheManager = new MyRedisCacheManager(redisTemplate);

		cacheManager.setUsePrefix(true);

		return cacheManager;

	}

@Bean

    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,

            MessageListenerAdapter listenerAdapter) {

        RedisMessageListenerContainer container = new RedisMessageListenerContainer();

        container.setConnectionFactory(connectionFactory);

        container.addMessageListener(listenerAdapter, new PatternTopic(topicName));

        return container;

    }

    @Bean

    MessageListenerAdapter listenerAdapter(MyRedisCacheManager cacheManager ) {

        return new MessageListenerAdapter(new MessageListener(){

			@Override

			public void onMessage(Message message, byte[] pattern) {

				byte[] bs = message.getChannel();

				try {

					String type = new String(bs,"UTF-8");

					cacheManager.receiver(type);

				} catch (UnsupportedEncodingException e) {

					e.printStackTrace();

					// 不可能出错

				}

			}

        });

    }

	class MyRedisCacheManager extends RedisCacheManager{

		public MyRedisCacheManager(RedisOperations redisOperations) {

			super(redisOperations);

		}

		@SuppressWarnings("unchecked")

		@Override

		protected RedisCache createCache(String cacheName) {

			long expiration = computeExpiration(cacheName);

			return new MyRedisCache(this,cacheName, (this.isUsePrefix()? this.getCachePrefix().prefix(cacheName) : null), this.getRedisOperations(), expiration);

		}

		/**

		 * get a messsage for update cache

		 * @param cacheName

		 */

		public void receiver(String cacheName){

			MyRedisCache cache = (MyRedisCache)this.getCache(cacheName);

			if(cache==null){

				return ;

			}

			cache.cacheUpdate();

		}

		//notify other redis clent to update cache( clear local cache in fact)

		public void publishMessage(String cacheName){

			this.getRedisOperations().convertAndSend(topicName, cacheName);

		}

	}

	class MyRedisCache extends RedisCache{

		//local cache for performace

		ConcurrentHashMap<Object,ValueWrapper> local = new ConcurrentHashMap<>();

		MyRedisCacheManager cacheManager;

		public MyRedisCache(MyRedisCacheManager cacheManager,String name, byte[] prefix,

				RedisOperations<? extends Object, ? extends Object> redisOperations, long expiration) {

			super(name, prefix, redisOperations, expiration);

			this.cacheManager = cacheManager;

		}

		@Override

		public ValueWrapper get(Object key) {

			ValueWrapper wrapper = local.get(key);

			if(wrapper!=null){

				return wrapper;

			}else{

				wrapper =   super.get(key);

				if(wrapper!=null){

					local.put(key, wrapper);

				}

				return wrapper;

			}

		}

		@Override

		public void put(final Object key, final Object value) {

			super.put(key, value);

			cacheManager.publishMessage(super.getName());

		}

		@Override

		public void evict(Object key) {

			super.evict(key);

			cacheManager.publishMessage(super.getName());

		}

		@Override

		public ValueWrapper putIfAbsent(Object key, final Object value){

			ValueWrapper wrapper = super.putIfAbsent(key, value);

			cacheManager.publishMessage(super.getName());

			return wrapper;

		}

		public void cacheUpdate(){

			//clear all cache for simplification

			local.clear();

		}

	}

}

class StarterCacheCondition implements Condition {

	@Override

	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

		RelaxedPropertyResolver resolver = new RelaxedPropertyResolver(

				context.getEnvironment(), "springext.cache.");

		String env = resolver.getProperty("type");

		if(env==null){

			return false;

		}

		return "local2redis".equalsIgnoreCase(env.toLowerCase());

	}

}

代码的核心在于spring boot提供一个概念CacheManager&Cache用来表示缓存，并提供了多达8种实现，但由于缺少一二级缓存，因此，需要在Redis基础上扩展，因此实现了MyRedisCacheManger,以及MyRedisCache，增加一个本地缓存。

一二级缓存需要解决的的一个问题是缓存更新的时候，必须通知其他节点的springboot应用缓存更新。这里可以用Redis的 Pub/Sub 功能来实现，具体可以参考listenerAdapter方法实现。

使用的时候，需要配置如下，这样，就可以使用缓存了，性能杠杠的好

springext.cache.type=local2redis

# Redis服务器连接端口

spring.redis.host=172.16.86.56

spring.redis.port=6379