《深入分布式缓存》之“自己动手写缓存”

<dependency>

           <groupId>javax.cache</groupId>

           <artifactId>cache-api</artifactId>

           <version>1.0.0</version>

</dependency>

publicinterface ExpiryPolicy<K, V> {

 Duration getExpiryForCreatedEntry(Entry<?extends K, ? extends V>entry);

   DurationgetExpiryForAccessedEntry(Entry<? extends K, ? extends V>entry);

   Duration getExpiryForModifiedEntry(Entry<?extends K, ? extends V>entry);

}

//定义了使用简单弱引用的数据存储器，代码经过剪裁，完整代码请参考github

public classWeakValueDataStore<K, V> implements DataStore<K, V> {

ConcurrentHashMap<K,ValueHolder<V>> map = new ConcurrentHashMap<K,ValueHolder<V>>();

          @Override

      public ValueHolder<V> get(K key)throws StoreAccessException {

               return map.get(key);

      }

      @Override

      public PutStatus put(K key, V value)throws StoreAccessException {

               ValueHolder<V> v = newWeakValueHolder<V>(value);

               map.put(key, v);

               return PutStatus.PUT;

      }

      @Override

      public ValueHolder<V> remove(K key)throws StoreAccessException {

               return map.remove(key);

      }

          @Override

      public void clear() throwsStoreAccessException {

               map.clear();

      }

}

//简单的弱引用实现

public classWeakValueHolder<V> implements ValueHolder<V> {

      public WeakValueHolder(V value) {

/* 使用JDK提供的WeakReference，建立对象的弱引用

* 在没有强引用时，JVM GC将回收对象，调用WeakReference.get时

* 返回null

   */

               this.v = new WeakReference<V>(value);

      }

      privateWeakReference<V> v;

      @Override

      public V value() {

               return this.v.get();

      }

}

@Test

public voidTestWeakValue() throws InterruptedException {

      CsCache<String, User> cache = newCsCache<String, User>(new WeakValueDataStore<String, User>());

      String key = "leo";

      User user = new User();

      user.setName("leo");

      cache.put(key, user);

/* 释放对象的强引用，等待JVM GC */

      user = null;

      System.out.println("Hello " + cache.get(key).getName());

      System.gc();

      Thread.sleep(10000);

/* JVM调度显式GC后，回收了name是leo的user

* get返回null

*/

      System.out.println("Hello " + cache.get(key));

}

          @Override

      public ValueHolder<V> get(K key)throws StoreAccessException {

      LRUEntry<K, ValueHolder<?>>entry = (LRUEntry<K, ValueHolder<?>>) getEntry(key);

               if (entry == null) {

                        return null;

               }

                    /**

               在获取数据的时候，将该entity节点数据移动到列表头。

               moveToFirst(entry);

               return (ValueHolder<V>)entry.getValue();

      }

      @Override

      public PutStatus put(K key, V value)throws StoreAccessException {

               LRUEntry<K,ValueHolder<?>> entry = (LRUEntry<K, ValueHolder<?>>)getEntry(key);

               PutStatus status =PutStatus.NOOP;

               if (entry == null) {

                              /**

                        数据缓存列表中的数据已经超过预定值，则删除列表中

                              尾的节点数据，以实现LRU算法

                        **/

                        if (map.size() >=maxSize) {

                                 map.remove(last.getKey());

                                        removeLast();

                        }

                        entry = newLRUEntry<K, ValueHolder<?>>(key, newBasicValueHolder<V>(value));

                        status = PutStatus.PUT;

               } else {

                        entry.setValue(newBasicValueHolder<V>(value));

                        status =PutStatus.UPDATE;

               }

               /**

               新添加的数据要加到列表的头部

               **/

               moveToFirst(entry);

               map.put(key, entry);

               return status;

}

//缓存客户端实例的创建

//缓存池是用ConcurrentMap来实现的，用以缓存已经创建好的缓存实例

synchronizedpublic <K, V, C extends Configuration<K, V>> Cache<K, V>createCache(String cacheName, C configuration)

                        throwsIllegalArgumentException {

               if (isClosed()) {

                        throw newIllegalStateException();

               }

                 //检查缓存实例名称是否为空

               checkNotNull(cacheName,"cacheName");

                 //检查配置信息是否为空

               checkNotNull(configuration,"configuration");

                 //根据cacheName获取缓存客户端实例

               CsCache107<?, ?> cache =caches.get(cacheName);

               if (cache == null) {

                        //如果无法从事先创建好的缓存池中获取，则创建一个新的实例

                        cache = newCsCache107<K, V>(this, cacheName, configuration);

                        //将新创建的缓存实例加到缓存池中

                              caches.put(cache.getName(),cache);

                        return (Cache<K,V>) cache;

               } else {

                        throw newCacheException("A cache named " + cacheName + " alreadyexists.");

               }

}

public<K, V> Cache<K, V> getCache(String cacheName, Class<K>keyClazz, Class<V> valueClazz) {

               if (isClosed()) {

                        throw newIllegalStateException();

               }

               //判断key类型是否为空

               checkNotNull(keyClazz, "keyType");

               //判断值类型是否为空

               checkNotNull(valueClazz,"valueType");

               //从缓存池中获取缓存实例

              CsCache107<K,V> cache = (CsCache107<K, V>) caches.get(cacheName);

               //如果获取为空则返回null

               if (cache == null) {

                        return null;

               } else {

                        //判断传入的对象和值类型是否与设定的类型一致

                        Configuration<?,?> configuration = cache.getConfiguration(Configuration.class);

                        if(configuration.getKeyType() != null &&configuration.getKeyType().equals(keyClazz)) {

                                 //如果一致则返回实例

                                 return cache;

                        } else {

                                 //如果不一致则抛出类型不一致异常

                                 throw new ClassCastException("Incompatiblecache key types specified, expected "

                                                    +configuration.getKeyType() + " but " + valueClazz + " wasspecified");

                        }

               }

}

privatefinal DataStore<K, V> store;

      private static Logger logger =LoggerFactory.getLogger(CsCache.class);

      //构造方法，参数是传入数据存储和淘汰策略对象

      public CsCache(final DataStore<K, V>dataStore) {

               store = dataStore;

      }

      //根据key值获取缓存数据

      public V get(final K key) {

               try {

                        //从数据存储和淘汰策略对象中获取缓存数据

                        ValueHolder<V>value = store.get(key);

                        if (null == value) {

                                 return null;

                        }

                        //返回缓存数据

                        return value.value();

               } catch (StoreAccessException e){

                        logger.error("storeaccess error : ", e.getMessage());

                        logger.error(e.getStackTrace().toString());

                        return null;

               }

      }

      //缓存数据的存储

      public void put(final K key, final Vvalue) {

               try {

                        将数据直接存放到数据和淘汰策略对象中

                        store.put(key, value);

               } catch (StoreAccessException e){

                        logger.error("storeaccess error : ", e.getMessage());

                        logger.error(e.getStackTrace().toString());

               }

}

      //获取缓存数据

      @Override

      public V get(K key) {

               return csCache.get(key);

      }

      //存放缓存数据

      @Override

      public void put(K key, V value) {

               this.csCache.put(key, value);

      }

      //删除缓存数据

      @Override

      public boolean remove(K key) {

               csCache.remove(key);

               return true;

      }

     //获取缓存提供层对象

CachingProvidercachingProvider = Caching.getCachingProvider();

//获取缓存管理层对象

CacheManagermanager = cachingProvider.getCacheManager();

//创建缓存实例对象

     Cache<String, User> cache =(Cache<String, User>) manager.<String, User,     Configuration<String, User>>createCache("Test", new  MutableConfiguration<String,User>());

     Stringkey = "leo";

     User user = new User();

user.setName("leo");

//将User数据对象存放到缓存中

  cache.put(key, user);

  System.out.println("Hello " +cache.get(key).getName());