緩存cache介紹

1.  為何要用緩存、緩存的目的是為了什么？（https://my.oschina.net/u/3378039/blog/2986697）
 一個程序的瓶頸在於數據庫，內存的速度遠遠大於硬盤的速度，當我們一次又一次請求數據庫或遠程服務時會導致大量的時間耗費在數據庫操作或遠程方法調用上，以致於 程序性能惡化，使用數據緩存可以解決此問題。

下面是常用的緩存管理器以及可用注解方式實現緩存機制的集中類型

 2.@Cacheable/@CachePut/@CacheEvict/@Caching介紹（https://blog.csdn.net/wjacketcn/article/details/50945887）

具體介紹參見鏈接。

其中cacheable的源碼如下：

public @interface Cacheable {

    /**
     * 設定要使用的cache的名字，必須提前定義好緩存
     */
    @AliasFor("cacheNames")
    String[] value() default {};

    /**
     * 同value()，決定要使用那個/些緩存
     */
    @AliasFor("value")
    String[] cacheNames() default {};

    /**
     * 使用SpEL表達式來設定緩存的key，如果不設置默認方法上所有參數都會作為key的一部分
     */
    String key() default "";

    /**
     * 用來生成key，與key()不可以共用
     */
    String keyGenerator() default "";

    /**
     * 設定要使用的cacheManager，必須先設置好cacheManager的bean，這是使用該bean的名字
     */
    String cacheManager() default "";

    /**
     * 使用cacheResolver來設定使用的緩存，用法同cacheManager，但是與cacheManager不可以同時使用
     */
    String cacheResolver() default "";

    /**
     * 使用SpEL表達式設定出發緩存的條件，在方法執行前生效
     */
    String condition() default "";

    /**
     * 使用SpEL設置出發緩存的條件，這里是方法執行完生效，所以條件中可以有方法執行后的value
     */
    String unless() default "";

    /**
     * 用於同步的，在緩存失效（過期不存在等各種原因）的時候，如果多個線程同時訪問被標注的方法
     * 則只允許一個線程通過去執行方法
     */
    boolean sync() default false;

}

（下圖來源於https://www.cnblogs.com/psy-code/p/9537830.html）

3.使用guava和caffeine緩存（據說spring5開始已經開始用caffeine替換guava）。

以下圖列舉集中常用的緩存的性能比較柱狀圖，來源於（https://blog.csdn.net/qq_35981283/article/details/82354081#commentBox）

 

下面主要以guava和caffeine為例，代碼如下：

a.使用guava的情景，代碼如下（參考網址https://blog.csdn.net/chinabestchina/article/details/78009220）：

 application-guava.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
      <cache:annotation-driven/>
    <bean id="cacheManager" class="org.springframework.cache.guava.GuavaCacheManager">
        <property name="cacheSpecification" value="concurrencyLevel=4,expireAfterAccess=100s,expireAfterWrite=100s" />
        <property name="cacheNames">
            <list>
                <value>guavaCache</value>
            </list>
        </property>
    </bean>
</beans>

package com.alice.bean;

public class Student {
    public Integer id;
    public String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.alice.guava;

import com.alice.bean.Student;

public interface StudentService {
    public Student getStudent(Integer id);

    public Student updateStudent(Student stu);

    public void deleteStudent(Integer id);

    public void deleteAllStudent();

    public void myDelete(Integer id);
}

package com.alice.guava;

import com.alice.bean.Student;
import org.springframework.aop.framework.AopContext;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service("studentGuavaCache")
public class StudentGuavaCacheImpl implements StudentService {

    @Cacheable(value = "guavaCache",key="'id_'+#id",condition = "#id<3")
    public Student getStudent(Integer id) {
        Student stu = new Student();
        stu.setId(id);
        stu.setName("apple");
        return stu;
    }

    @CachePut(value = "guavaCache",key="'id_'+#stu.getId()")
    public Student updateStudent(Student stu){
        System.out.println("update stu");
        return stu;
    }


    @CacheEvict(value = "guavaCache",key="'id_'+#id")
    public void deleteStudent(Integer id){

        System.out.println("delete student "+id);
    }

    public void myDelete(Integer id){
        try {
            StudentService ss = (StudentService) AopContext.currentProxy();
            ss.deleteStudent(id);
            return ;
        }catch (Exception e){
            e.printStackTrace();

        }
        this.deleteStudent(id);
    }

    @CacheEvict(value = "guavaCache",allEntries = true)
    public void deleteAllStudent(){

        System.out.println("delete all student ");
    }
}

package com.alice.guava;

import com.alice.bean.Student;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.util.Assert;

public class SpringGuavaCacheMain {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:application-cache.xml","classpath:application-spring.xml","classpath:application-mybatis.xml");
        StudentService studentService = (StudentService) ac.getBean("studentGuavaCache");

        Integer id =1;
        Student stu = studentService.getStudent(id);  //新建緩存
        stu = studentService.getStudent(id);   //從緩存中取

        studentService.myDelete(id);
        stu = studentService.getStudent(id);   //從緩存中取

        stu.setName("banana");  //重新設置值
        Student stu1 = studentService.getStudent(id);
        stu.setName("banana");
        studentService.updateStudent(stu); //更新緩存
        stu = studentService.getStudent(id); //從緩存中取出新值

        stu = new Student();  //新實例
        stu.setId(0);
        studentService.updateStudent(stu);  //用新建的實例進行更新，會新建緩存
        stu = studentService.getStudent(0);  //從緩存中取

        studentService.deleteStudent(id);  // 刪除緩存
        stu = studentService.getStudent(id);  //再次新建緩存

        id=2;
        stu = studentService.getStudent(id); //新建緩存
        studentService.deleteAllStudent(); //刪除所有緩存
        id=1;
        stu = studentService.getStudent(id); //因所有緩存被前一步清除，會新建緩存

        id=5;
        stu = studentService.getStudent(id); //不會新建緩存 因為設置了緩存條件必須小於3
        stu = studentService.getStudent(id); //因沒有緩存，不會從緩存中取

        Assert.notNull(stu,"deprecated");
    }
}

2.使用caffeine

這里擴展了下原本的caffeineManager

package com.alice.caffeine;

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.caffeine.CaffeineCacheManager;

import java.util.concurrent.TimeUnit;

public class CaffeineCacheExtManager extends CaffeineCacheManager {

    public CaffeineCacheExtManager(){
        super();
    }
    /**
     * Construct a CaffeineCacheExtManager managing caches with expireAfterWrite feature
     *
     * @param duration
     * @param timeUnit
     */
    public CaffeineCacheExtManager(long duration, String timeUnit) {
        this.setCaffeine(Caffeine.newBuilder().expireAfterWrite(duration, TimeUnit.valueOf(timeUnit.toUpperCase())));
    }

}

application-caffeine.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
       <cache:annotation-driven/>
   
       <bean id="cacheManager" class="org.springframework.cache.caffeine.CaffeineCacheManager"/>

       <bean id="tenSecondCacheManager" class="com.alice.caffeine.CaffeineCacheExtManager">
              <constructor-arg name="duration" value="10"/>
              <constructor-arg name="timeUnit" value="SECONDS"/>
       </bean>
</beans>

package com.alice.caffeine;

import com.alice.bean.Student;

public interface StudentService {
    public Student getStudent(Integer id);
}

package com.alice.caffeine;

import com.alice.bean.Student;
import org.springframework.aop.framework.AopContext;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service("CaffeineCache")
public class StudentCaffeineCacheImpl implements StudentService {

    @Cacheable(cacheManager = CacheMgmtName.TEN_SECOND_CACHE_MANAGER,cacheNames =CacheNames.QUERY_STUINFO_CACHE, key="'id_'+#id",condition = "#id<3")
    public Student getStudent(Integer id) {
        Student stu = new Student();
        stu.setId(id);
        stu.setName("apple");
        return stu;
    }
}

package com.alice.caffeine;

import com.alice.bean.Student;
import com.alice.caffeine.StudentService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test  {
    public static void main(String[] args){
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:application-cache.xml","classpath:application-spring.xml","classpath:application-mybatis.xml","classpath:application-caffeine.xml");
        StudentService studentService = (StudentService) ac.getBean("CaffeineCache");
        int id =1;
        Student stu = studentService.getStudent(id);
        stu = studentService.getStudent(id);
    }
}