源码分析：Guava Cache的使用以及源码分析-Builder

快来打我* 2022-01-05 06:13 293阅读 0赞

Guava Cache是性能非常高的本地缓存，其他的还有ehcache等。相对于本地缓存还有分布式缓存，其实就是独立于业务的第三方应用，比如redis、memcahe或者自己弄个机器加大内存，把它当作另外一个集群的分布式缓存同样是可以的，但是要做到高可用不是一件简单的事情。另外，内存缓存有个不可避免的问题是易丢失，所以要持久化的就老老实实弄一个redis或者直接入库。这里主要记录是标题的内容，话不多直接开始，先是使用，然后在看builder，学习谷歌大神写的代码得分好篇文章了，这篇文章主要就是上述两者：

### Guava Cache的使用 ###

使用相对简单，这也是它流传广泛的一个重要原因吧，直接上平时使用的代码：

public LoadingCache<String, String> serviceCache =
          CacheBuilder.newBuilder().maximumSize(20000).expireAfterWrite(10, TimeUnit.SECONDS)
              .recordStats().build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) {
              return service.query(key);
            }
          });

### Builder ###

这里我们可以看到LoadingCache是通过newBuilder的方式建立的，这里用到的是Builder设计模式，先看上构建cache的类似实现，这是摘自[这篇文章][Link 1]的一个例子，这个很好理解，一个bean中有个静态内部类Builder，其中的属性就是外部person对应的属性，它对外暴露属性，并把返回Buildler自身，直到使用bulid()，new出外部类。

/**
     * @author SunKing1927 2015年11月2日
     *         Java Builder模式
     */
    public class Person {
        private String name;
        private int age;
        private boolean sex;
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    
        public boolean isSex() {
            return sex;
        }
    
        public static class Builder {
            private String name;
            private int age;
            private boolean sex;
    
            public Builder name(String n) {
                name = n;
                return this;
            }
    
            public Builder age(int a) {
                age = a;
                return this;
            }
    
            public Builder sex(boolean s) {
                sex = s;
                return this;
            }
    
            public Person build() {
                return new Person(this);
            }
        }
    
        private Person(Builder builder) {
            name = builder.name;
            age = builder.age;
            sex = builder.sex;
        }
    }

下边看一下经典的Builder是如何实现的，下边是UML类图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb3llcWl1_size_16_color_FFFFFF_t_70][]

从上图可以看到，经典Buider模式中有四个角色：

1、要建造的产品Product -- LoadingCache

2、抽象的Builder -- 我们的例子中略去了抽象层，我们可以随时抽象

3、Builder的具体实现ConcreteBuilder -- 对应maximumSize、expireAfterWrite等

4、使用者Director -- 对应的类

有了上述的这些点，我们来看下guava cache的Builder代码的实现，首先是创建一个CacheBuilder

/**
       * 静态公共方法暴露出来进行构建
       */
      public static CacheBuilder<Object, Object> newBuilder() {
        return new CacheBuilder<Object, Object>();
      }

剩下的就是利用各种属性进行赋值，我们这里只使用其中一个作为例子

/**
       * 1、对参数进行校验
       * 2、赋值之后返回CacheBuilder对象本身，和上边的Person本身是很想的
       */
      public CacheBuilder<K, V> maximumSize(long size) {
        checkState(this.maximumSize == UNSET_INT, "maximum size was already set to %s",
            this.maximumSize);
        checkState(this.maximumWeight == UNSET_INT, "maximum weight was already set to %s",
            this.maximumWeight);
        checkState(this.weigher == null, "maximum size can not be combined with weigher");
        checkArgument(size >= 0, "maximum size must not be negative");
        this.maximumSize = size;
        return this;
      }
    
      public CacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) {
        checkState(expireAfterWriteNanos == UNSET_INT, "expireAfterWrite was already set to %s ns",
            expireAfterWriteNanos);
        checkArgument(duration >= 0, "duration cannot be negative: %s %s", duration, unit);
        this.expireAfterWriteNanos = unit.toNanos(duration);
        return this;
      }

第三步就是调用build()方法进行构建LocalCache类

/**
       * 1、LocalCache调用其静态内部类LocalLoadingCache的构造方法new了一个LocalCache，这一点和上边的person很像
       */
      public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
          CacheLoader<? super K1, V1> loader) {
        checkWeightWithWeigher();
        return new LocalCache.LocalLoadingCache<K1, V1>(this, loader);
      }
    
      static class LocalLoadingCache<K, V>
          extends LocalManualCache<K, V> implements LoadingCache<K, V> {
    
        LocalLoadingCache(CacheBuilder<? super K, ? super V> builder,
            CacheLoader<? super K, V> loader) {
          super(new LocalCache<K, V>(builder, checkNotNull(loader)));
        }
      }
    
      /**
       * new LocalCache的过程就是把builder中的属性赋值到LocalCache中属性的过程
       */
      LocalCache(
          CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
        concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
    
        keyStrength = builder.getKeyStrength();
        valueStrength = builder.getValueStrength();
    
        keyEquivalence = builder.getKeyEquivalence();
        valueEquivalence = builder.getValueEquivalence();
    
        maxWeight = builder.getMaximumWeight();
        weigher = builder.getWeigher();
        expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
        expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
        refreshNanos = builder.getRefreshNanos();
    
        removalListener = builder.getRemovalListener();
        removalNotificationQueue = (removalListener == NullListener.INSTANCE)
            ? LocalCache.<RemovalNotification<K, V>>discardingQueue()
            : new ConcurrentLinkedQueue<RemovalNotification<K, V>>();
    
        ticker = builder.getTicker(recordsTime());
        entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
        globalStatsCounter = builder.getStatsCounterSupplier().get();
        defaultLoader = loader;
    
        int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
        if (evictsBySize() && !customWeigher()) {
          initialCapacity = Math.min(initialCapacity, (int) maxWeight);
        }

CacheLoader是一个抽象类，第一个例子中返回了它的一个实现

/**
     * CacheLoader是一个抽象类，返回的是CacheLoader的一个实现，至于其中的方法什么时候调用，完全看localCache的需要
     */
     new CacheLoader<String, String>() { 
       @Override 
        public String load(String key) { 
         return service.query(key); 
       } 
     }

至此guava localcache对象便生成了，嗯，这只是很简单的第一步。

[Link 1]: https://www.cnblogs.com/begin1949/p/4930896.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hb3llcWl1_size_16_color_FFFFFF_t_70]: /images/20211229/8758ec01cf1d4c7dbfe2a9da5d8c8dec.png