guava

        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
        

import com.google.common.cache.*;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


public class _1_CacheLoaderBasicTest {

    public static void main(String[] args) throws Exception{
//        test1();
//        test2();
//        test3();
//        test4();
//        test5();
//        test6();
//        test7();
//        test8();
//        test9();
        test10();
    }

    //测试缓存刷新，
    //注：guava的缓存刷新不是后台根据缓存时间去删除缓存的 而是在程序访问的时候判断 如果缓存到期了 那么就会去从from方法里重新构建数据然后放到缓存里面来
    private static void test9() throws Exception{
            AtomicInteger counter = new AtomicInteger(0);
            CacheLoader cacheLoader = CacheLoader.from(k -> {
                        counter.incrementAndGet();
                        return k;
            });

            LoadingCache cache = CacheBuilder.newBuilder()
                .refreshAfterWrite(2, TimeUnit.SECONDS)
                    .build(cacheLoader);

        String result1 = cache.getUnchecked("Alex");
        TimeUnit.SECONDS.sleep(3);
        String result2 = cache.getUnchecked("Alex");
        System.out.println(counter.get());//2 ，中间数据被过期了 会重新去加载一次 所以这里是2
    }


    //由createCacheLoader()可以知道，不能返回null值给cache，否则会报错
    //所以我们需要Optional的方式来避免这个问题
    private static void test6() {
        CacheLoader> loader = new CacheLoader>()  {
            @Override
            public Optional load(String key) {
                if (key.equals("null"))
                    return Optional.ofNullable(null);
                else
                    return Optional.of(new Employee(key, key, key));
            }
        };
        LoadingCache> cache = CacheBuilder.newBuilder() .build(loader);

        System.out.println(cache.getUnchecked("Alex").get());

        Employee abc = cache.getUnchecked("null").orElse(new Employee("default", "default", "default"));
        System.out.println(abc);//null 拿出来的数据是空，这里返回默认的数据

        //也可以通过下面这种方式来做处理
        Optional def = cache.getUnchecked("null");
        if(!def.isPresent()){
            System.out.println("拿到的数据为空");
        }
    }



    /**测试软引用在缓存中被过期
     * 需要设置堆内存信息
     * -Xms64M -Xmx64M -XX:+PrintGCDetails
     * @throws Exception
     */
    private static void test5() throws Exception{
        LoadingCache cache = CacheBuilder.newBuilder()
                .expireAfterWrite(200, TimeUnit.SECONDS)
                .softValues()//只能对values 做软引用处理
                .build(createCacheLoader2());
        int i = 0;
        //Employee 内部会有一个1M的数组，所以一个Employee对象 至少占1M空间
        //由于软引用在内存快不足的时候会被回收 所以这里运行结果 可以创建很多对象 不止64个
        //todo 但是考虑到软引用的性能影响 一般我们在在缓存中设置size来限制缓存所占内存的总大小 而不是使用软引用来
        for (; ; )  {
            String key = "Alex" + i;
            cache.put(key, new Employee(key, key, key));
//            cache.get(key);
//            System.gc();
            System.out.println("The Employee [" + (i++) + "] is store into cache.");
            TimeUnit.MILLISECONDS.sleep(200);
        }
    }

    //测试弱引用(weakReference) 在缓存中被过期
    public static void test4() throws InterruptedException  {
        LoadingCache cache = CacheBuilder.newBuilder()
                .expireAfterWrite(2, TimeUnit.SECONDS)
                .weakValues()
                .weakKeys()
                .build(createCacheLoader2());
        cache.getUnchecked("Alex");
        cache.getUnchecked("Guava");

        //active method
        //Thread Active design pattern
        System.gc();
        TimeUnit.MILLISECONDS.sleep(100);
        //weak：弱引用 每次gc的时候 都会将其回收， 所以这里从缓存中拿不到数据了
        System.out.println(cache.getIfPresent("Alex"));
    }

    //测试Write的expire模式下的缓存存活情况
    private static void test3() throws Exception {
        LoadingCache cache = CacheBuilder.newBuilder()
                //expireAfterWrite,write:包括写(write)和更新(update) 不包括读(read)
                .expireAfterWrite(2, TimeUnit.SECONDS)
                .build(createCacheLoader2());

        cache.getUnchecked("Guava");

        TimeUnit.SECONDS.sleep(1);
        Employee guava = cache.getIfPresent("Guava");
        System.out.println(guava);//1s后guava 此时存活
        TimeUnit.MILLISECONDS.sleep(900);
        guava = cache.getIfPresent("Guava");
        System.out.println(guava);//1.90s guava 此时依然存活

        TimeUnit.SECONDS.sleep(1);
        guava = cache.getIfPresent("Guava");
        System.out.println(guava);//2.99s guava 此时不存活
    }

    //测试Access的expire模式下的缓存存活情况
    private static void test2() throws Exception{
        LoadingCache cache = CacheBuilder.newBuilder()
                //expireAfterAccess,access:包括读(read),写(write),改(update),都会续长缓存的存活期
                .expireAfterAccess(2, TimeUnit.SECONDS)
                .build(createCacheLoader2());
        cache.getUnchecked("Alex");

        TimeUnit.SECONDS.sleep(3);
        Employee alex =  cache.getIfPresent("Alex");//睡眠了 3s 此时缓存获取不到数据
        System.out.println(alex);

        cache.getUnchecked("Guava");

        TimeUnit.SECONDS.sleep(1);
        Employee employee = cache.getIfPresent("Guava");//此时Guava存在
        System.out.println(employee);

        TimeUnit.SECONDS.sleep(1);
        employee = cache.getIfPresent("Guava");//再次获取Guava 依然存在
        System.out.println(employee);

        TimeUnit.SECONDS.sleep(1);
        employee = cache.getIfPresent("Guava");//再次获取Guava 依然存在
        System.out.println(employee);
    }

    //测试基础用法
    public static void test1() throws ExecutionException, InterruptedException {
        //创建一个缓存容器对象 其最大容量是3，容器内元素存放30ms就过期
        LoadingCache cache = CacheBuilder.newBuilder()
                .maximumSize(3)
                .expireAfterAccess(30, TimeUnit.MILLISECONDS)
                .build(createCacheLoader());
        //#################################### 测试30ms时间过期 ####################################
//        System.out.println(cache.get("Alex").getName());
//        TimeUnit.MILLISECONDS.sleep(31);
//        System.out.println(cache.get("Alex").getName());
        //测试到达容量之后 LRU过期
        //#################################### 测试到达size之后被LRU过期(过期策略:size) ####################################
//        System.out.println(cache.get("Alex").getName());
//        System.out.println(cache.get("allen").getName());
//        System.out.println(cache.get("tom").getName());
//        System.out.println(cache.get("amy").getName());//此时Alex被过期调，再拿Alex的话会从DB中拿
//        System.out.println(cache.size());
//        System.out.println(cache.get("Alex").getName());
//        System.out.println();
        //#################################### 测试到达weight之后被LRU过期(过期策略:自定义) ####################################

        //设置一个称重器 称重的方式是：对象的重量weight = name的长度 + empId的长度 + Dept的长度
        Weigher weigher = (key, employee) ->
                employee.getName().length() + employee.getEmpID().length() + employee.getDept().length();

        //设置缓存重量限制为45
        LoadingCache cache2 = CacheBuilder.newBuilder()
                .maximumWeight(45)
                .concurrencyLevel(1)
                .weigher(weigher)
                .build(createCacheLoader());

        cache2.get("Gavin");//缓存重量：15
        cache2.get("Kevin");//缓存重量：30
        cache2.get("Allen");//缓存重量：45
        cache2.get("Jason");//重量已经达到45，此时Gavin被过期

        Employee employee = cache2.getIfPresent("Gavin");//此时再去缓存中拿Gavin 是拿不到的
        System.out.println(employee);


        //#################################### LoadingCache 的一些api ####################################
//        从LoadingCache中拿数据，如果拿不到，会去从DB中拿，
//        cache.get("aa");
//        与get()方法的区别是这里不需要显式捕获异常
//        cache.getUnchecked("aa");
//        从缓存中拿key对应的数据，如果缓存中没有 就返回null，不会去从DB中拿
//        cache.getIfPresent("aa");

    }


//    //测试缓存刷新
//    public void testCacheRefresh() throws InterruptedException  {
//        AtomicInteger counter = new AtomicInteger(0);
//        CacheLoader cacheLoader = CacheLoader .from(k ->  {
//                    counter.incrementAndGet();
//                    return System.currentTimeMillis();
//                });
//
//        LoadingCache cache = CacheBuilder.newBuilder()
////                .refreshAfterWrite(2, TimeUnit.SECONDS)
//                .build(cacheLoader);
//
//        Long result1 = cache.getUnchecked("Alex");
//        TimeUnit.SECONDS.sleep(3);
//        Long result2 = cache.getUnchecked("Alex");
//        assertThat(counter.get(), equalTo(1));
////        assertThat(result1.longValue() != result2.longValue(), equalTo(true));
//    }

    //测试缓存预加载：可以提前构造好一个hashMap 然后将其放入到缓存中
    //注意：这种缓存构建方法不会经过缓存加工，会直接作为缓存数据存进去
    public static  void test7() {
        CacheLoader loader = CacheLoader.from(String::toUpperCase);
        LoadingCache cache = CacheBuilder.newBuilder().build(loader);

        Map preData = new HashMap() { {
            put("alex", "ALEX");
            put("hello", "hello");
        }
        };

        cache.putAll(preData);
        System.out.println(cache.size());//2
        System.out.println(cache.getUnchecked("alex"));
        System.out.println(cache.getUnchecked("hello"));
    }

    //测试淘汰通知:缓存被淘汰时 应用程序可以拿到被淘汰的信息
    public static void test8(){
        CacheLoader loader = CacheLoader.from(String::toUpperCase);
        RemovalListener listener = notification ->
        {
            if (notification.wasEvicted())
            {
                RemovalCause cause = notification.getCause();
                System.out.println(notification.getKey().equals("Alex"));//true 被淘汰的元素是Alex
                System.out.println(cause.equals(RemovalCause.SIZE));//true 被淘汰的原因是容量不足
            }
        };

        LoadingCache cache = CacheBuilder.newBuilder()
                //
                .maximumSize(3)
                //
                .removalListener(listener)
                //
                .build(loader);
        cache.getUnchecked("Alex");
        cache.getUnchecked("Eachur");
        cache.getUnchecked("Jack");
        cache.getUnchecked("Jenny");
    }

    //测试缓存命中情况
    private static void test10() {
        CacheLoader loader = CacheLoader.from(String::toUpperCase);
        LoadingCache cache = CacheBuilder.newBuilder()
                .maximumSize(5)
                .recordStats()
                .build(loader);

//        缓存创建也可以按照表达式来创建 如下：
//        String spec = "maximumSize=5,recordStats";
//        CacheBuilderSpec builderSpec = CacheBuilderSpec.parse(spec);
//        CacheLoader loader = CacheLoader.from(String::toUpperCase);
//        LoadingCache cache = CacheBuilder.from(builderSpec).build(loader);

        cache.getUnchecked("alex");
        CacheStats stats = cache.stats();
        System.out.println(stats.hashCode());
        System.out.println(stats.hitCount());//0
        System.out.println(stats.missCount());//1 第一次没在缓存中查到 所以也记录到了命中

        cache.getUnchecked("alex");

        stats = cache.stats();
        System.out.println(stats.hashCode());//状态变化了 stat的hashcode会变化
        System.out.println(stats.hitCount());//1
        System.out.println(stats.missCount());//1

        System.out.println(stats.missRate());//0.5
        System.out.println(stats.hitRate());//0.5
    }

    private static  CacheLoader createCacheLoader() {
        return new CacheLoader() {
            @Override
            public Employee load(String key) throws Exception {
//                这里要注意：load的时候不能返回空， 那返回空了怎么办？很有可能命中不了
//                if (key.equals("aa")) return null;
                System.out.println("从数据库中拿数据： " + key);
                return new Employee(key, key, key);
            }
        };
    }

    private static CacheLoader createCacheLoader2()  {
        //也可以使用from()来构建缓存
        return CacheLoader.from(key -> new Employee(key, key, key));
    }
}