SpringBoot——缓存(注解的使用,整合Redis,自定义CacheManager)

1.JSR107

Java Caching定义了5个核心接口:

  • CachingProvider:定义了创建,配置,获取,管理和控制多个CacheManager。一个应用可以在运行期间访问多个CachingProvider。
  • CacheManager:定义了创建,配置,获取和控制多个Cache,这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有
  • Cache:一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有
  • Entry:一个存储在Cache的key-value对
  • Expiry:每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间,条目为过期的状态。一旦过期,条目将不可访问,更新和删除。缓存有效期可以通过ExpiryPolicy设置

SpringBoot——缓存(注解的使用,整合Redis,自定义CacheManager)_第1张图片

一个应用里面可以有多个缓存提供者(CachingProvider),一个缓存提供者可以获取多个缓存管理器(CacheManager),一个缓存管理器管理着不同的缓存(Cache),缓存中是一个个的缓存键值对(Entry),每个键值对都有一个有效期(Expiry)。缓存管理器和缓存之间的关系有点类似于数据库中连接池和连接的关系。

2.Spring缓存抽象

2.1 简介

Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术,并支持使用JCache(JSR-107)注解简化我们开发。

Cache接口有以下功能:

  • 为缓存的组件规范定义,包含缓存的各种操作集合

Cache接口为缓存的组件规范定义,包含缓存的各种操作集合。Cache接口下Spring提供各种XxxCache的实现,如RedisCache,EhCacheCache,ConcurrentMapCahce等。每次调用需要缓存功能的方法时,Spring会检查指定参数的指定的目标方法是否已经被调用过,如果有就直接从缓存中获取方法调用后的结果,如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。

SpringBoot——缓存(注解的使用,整合Redis,自定义CacheManager)_第2张图片

使用Spring缓存抽象时我们需要关注以下两点:

  • 确认方法需要被缓存以及他们的缓存策略
  • 从缓存中读取之前缓存存储的数据

2.2 缓存注解/重要概念

注解/概念 作用
Cache 缓存接口,定义缓存操作。实现有:RedisCache,EhCacheCache,ConcurrentMapCahce等
CacheManager 缓存管理器,管理各种缓存(Cache)组件
@Cacheable 主要针对方法配置,能够根据方法的请求参数对结果进行缓存
@CacheEvict 清空缓存
@CachePut 保证方法被调用,又希望结果被缓存
@EnableCaching 开启基于注解的缓存
keyGenerator 缓存数据时key生成策略
serialize 缓存数据时value的序列化策略

说明:

  • @Cacheable标注在方法上,表示该方法的结果需要被缓存起来,缓存的键由keyGenerator的策略决定,缓存的值得形式则由serialize序列化策略决定的(序列化还是JSON格式);标注上该注解之后,在缓存时效内再次调用该方法时将不会调用方法本身而是直接从缓存中获取结果
  • @CachePut也标注在方法上,和@Cacheable相似也会将方法的返回值缓存起来,不同的是@CachePut的方法每次都会被调用,而且每次都会将结果缓存起来,适用于对象的更新

1.@Cacheable/@CachePut/@CacheEvict主要的参数

  • value:缓存的名称,字符串/字符数组形式
  • key:缓存的key,需要按照SpELl表达式编写,如果不指定按按照方法所有参数进行组合
  • keyGenerator:key的生成器,可以自己指定key的生成器的组件id。注意:key/keyGenerator二选一使用
  • condition:缓存条件,使用SpEL编写, 在调用方法之前之后都能判断
  • unless(@CachePut,@Cacheable):用于是否缓存的条件,只在方法执行之后判断
  • beforeInvocation(@CacheEvict):是否在执行前清空缓存,默认为false,false的情况下方法执行异常则不会清空
  • allEntries(@CacheEvict):是否清空所有缓存内容,默认为false。

2.缓存可用的SpELl表达式

root:表示根对象,不可省略

  • 被调用方法名methodName,如#root.methodName
  • 被调用方法method
  • 目标对象target
  • 被调用的目标对象类targetClass
  • 被调用的方法的参数列表
  • 方法调用使用的缓存列表caches,如#root.cache[0].name

参数名:方法参数的名字,可以直接使用#参数名,也可以使用#p0

返回值:方法执行后的返回值,如#result

2.3 缓存使用

2.3.1 基本环境搭建

1.创建SpringBoot应用:选中Cache,Mysql,MyBatis,Web模块,pom文件如下:



    4.0.0
    com.test
    spring-boot-cache
    0.0.1-SNAPSHOT
    spring-boot-cache
    Demo project for Spring Boot

    
        1.8
        UTF-8
        UTF-8
        2.3.0.RELEASE
    

    
        
            org.springframework.boot
            spring-boot-starter-cache
        
        
            org.springframework.boot
            spring-boot-starter-jdbc
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            2.1.2
        

        
            mysql
            mysql-connector-java
            runtime
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-dependencies
                ${spring-boot.version}
                pom
                import
            
        
    

    
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                
                    1.8
                    1.8
                    UTF-8
                
            
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    


2.创建数据库表

-- ----------------------------
-- Table structure for department
-- ----------------------------
DROP TABLE IF EXISTS `department`;
CREATE TABLE `department` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `departmentName` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for employee
-- ----------------------------
DROP TABLE IF EXISTS `employee`;
CREATE TABLE `employee` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `lastName` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  `gender` int(2) DEFAULT NULL,
  `d_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

3.创建JavaBean封装数据

public class Employee implements Serializable {
	
	private Integer id;
	private String lastName;
	private String email;
	private Integer gender; //性别 1男  0女
	private Integer dId;
	
	
	public Employee() {
		super();
	}

	
	public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dId = dId;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Integer getGender() {
		return gender;
	}
	public void setGender(Integer gender) {
		this.gender = gender;
	}
	public Integer getdId() {
		return dId;
	}
	public void setdId(Integer dId) {
		this.dId = dId;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="
				+ dId + "]";
	}
	
	

}




public class Department {
	
	private Integer id;
	private String departmentName;
	
	
	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Department(Integer id, String departmentName) {
		super();
		this.id = id;
		this.departmentName = departmentName;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName + "]";
	}
	
	
	
	

}

4.整合MyBatis操作数据库,数据源的配置:驱动可以不用写, SpringBoot会根据连接自动判断

spring.datasource.url=jdbc:mysql://localhost:3306/cache?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
mybatis.configuration.map-underscore-to-camel-case=true

使用注解版的MyBatis:使用@MapperScan指定mapper接口所在的包

@MapperScan("com.test.cache.mapper")
@SpringBootApplication
public class SpringBootCacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootCacheApplication.class, args);
    }

}

创建对应的mapper接口:使用@Mapper标注注解,标明是一个MyBatis的mapper接口

@Mapper
public interface EmployeeMapper {

    @Select("select * from employee where id=#{id}")
    public Employee getEmpById(Integer id);

    @Update("update employee set lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} where id=#{id}")
    public void updateEmp(Employee employee);

    @Delete("delete from employee where id=#{id}")
    public void deleteEmp(Integer id);

    @Insert("insert into employee(lastName,email,gender,d_id) values (#{lastName},#{email},#{gender},#{dId})")
    public void insertEmp(Employee employee);

    @Select("select * from employee where lastName=#{lastName}")
    public Employee getEmpByLastName(String lastName);
}

5.主配置类开启@EnableCaching

2.3.2 缓存快速体验

@CacheConfig(cacheNames="emp") //抽取缓存的公共配置
@Service
public class EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    /**  @Cacheable 将方法的运行结果进行缓存,以后再要相同的数据,直接从缓存中获取,不用再调用方法
     *
     * CacheManager管理多个Cache组件的,对缓存的真正的CRUD在Cache组件中,每一个缓存组件有自己唯一一个名字
     *      属性:
     *         cacheNames/value:指定缓存组件的名字,将方法的返回结果放在哪个缓存中,是数组的形式,可以指定多个缓存
     *         key:缓存数据中使用的key,默认使用方法参数的值,1-方法的返回的值
     *              编写SpEL:#id参数id的值,#root.args[0]
     *         keyGenerator:key的生成器,可以自己指定key的生成器组件id
     *             (key/keyGenerator二选一)
     *         cacheManager:指定缓存管理器
     *         cacheResolver:指定缓存解析器
     *            (cacheManager/cacheResolver二选一使用)
     *         condition:指定符合条件的情况下才缓存
     *         unless:否定缓存,当unless指定的条件为true,方法的返回值就不会被缓存,可以获取到结果进行判断
     *         sync:是否使用异步模式
     * @param id
     * @return
     */
    @Cacheable(cacheNames = "emp",keyGenerator = "myKeyGenerator",condition = "#id>0")
    public Employee getEmp(Integer id){
        System.out.println("查询"+id+"号员工");
        Employee empById = employeeMapper.getEmpById(1);
        return empById;
    }


    /**
     * @CachePut:即调用方法,又更新缓存数据库
     * 修改了数据库的某个数据,同时更新缓存
     * 运行时机:
     *   1.先调用目标方法
     *   2.将目标方法的结果缓存起来
     *
     *  测试步骤:
     *   1.先查询一个员工,查到的结果会放在缓存中
     *      key:1 value:之前的员工
     *   2.以后查询还是之前的结果
     *   3.再更新这个员工
     *      将方法的返回值也放进缓存
     *      key:传入的Employee对象,value:返回更新的Employee对象
     *   4.再来查询这个员工
     *      还是原来的员工?1号员工没有在缓存中更新(key不同)
     *      key = "#employee.id" 使用传入参数的员工id
     *      key ="result.id" 使用返回后的id
     * @Cacheable的key不能使用result.id,因为在方法运行前就要按照这个key查询缓存
     *
     */
    @CachePut(value = "emp",key = "#employee.id")
    public Employee updateEmp(Employee employee){
        System.out.println("更新"+employee.getdId()+"号员工");
        employeeMapper.updateEmp(employee);
        return employee;
    }

    /**
     * @CacheEvict:缓存清除
     *   key:指定要清除的数据
     *   allEntries = true:指定清除这个缓存中所有的数据
     *   beforeInvocation=false(默认)缓存的清除是在方法之前执行
     *      默认代表是在方法之后执行,如果出现异常,这些缓存就不会清除
     */
    @CacheEvict(value = "emp",key = "#id" )
    public void deleteEmp(Integer id){
        System.out.println("删除"+id+"号员工");
    }

    /**
     * @Cacheing 定义复杂的缓存规则
     */
    @Caching(
            cacheable = {
                    @Cacheable(value = "emp",key = "#lastName")
            },
            put = {
                    @CachePut(value = "emp",key = "#result.id"),
                    @CachePut(value = "emp",key = "#result.email")
            }

    )
    public Employee getEmpByLastName(String lastName){
       return employeeMapper.getEmpByLastName(lastName);
    }

}

在上面的使用中,有自定义的keyGenerator。

@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
       return new KeyGenerator(){

            @Override
            public Object generate(Object o, Method method, Object... objects) {
                return method.getName()+"["+ Arrays.asList(o).toString()+"]";
            }
        };
    }

}

@CacheConfig标注在类上,用于抽取@Cacheable的公共属性。

2.4 工作原理

2.4.1 概述

缓存的自动配置类CacheAutoConfiguration向容器中导入CacheConfigurationImportSelector,此类的selectImports方法中添加了许多的配置类,其中SimpleCacheConfiguration默认生效

org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration
org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration
  static class CacheConfigurationImportSelector implements ImportSelector {
        CacheConfigurationImportSelector() {
        }

        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            CacheType[] types = CacheType.values();
            String[] imports = new String[types.length];

            for(int i = 0; i < types.length; ++i) {
//将即将导入的各配置类存入字符数组内
                imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
            }

            return imports;
        }
    }

SimpleCacheConfiguration向容器中导入ConcurrentMapCacheManager

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnMissingBean({CacheManager.class})
@Conditional({CacheCondition.class})
class SimpleCacheConfiguration {
    SimpleCacheConfiguration() {
    }

    @Bean
    ConcurrentMapCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers) {
        ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
        List cacheNames = cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            cacheManager.setCacheNames(cacheNames);
        }

        return (ConcurrentMapCacheManager)cacheManagerCustomizers.customize(cacheManager);
    }
}

ConcurrentMapCacheManager使用ConcurrentMap以k-v的方式存储缓存。

2.4.2 @Cacheable的运行流程

  1. 方法运行之前,先去查询Cache(缓存组件),按照cacheNames指定的名字获取(CacheManager会获取相应的缓存);第一次获取缓存如果没有Cache组件会自动创建,并以cacheNames-cache对放入ConcurrentMap
  2. 去Cache中查找缓存的内容,使用一个key,默认的就是方法的参数;key是按照某种策略生成的,默认是使用keyGenerator生成的,默认使用SimpleKeyGenerator生成key。
  3. 没有查到缓存就调用目标方法
  4. 将目标方法返回的结果,放进缓存中

2.4.3 源码分析

1.默认使用ConcurrentMapCacheManager管理缓存,该类使用ConcurrentMap保存缓存,获取缓存如果没有Cache组件会自动创建,并以cacheNames-cahce放入ConcurrentMap。

public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware {
    private final ConcurrentMap cacheMap = new ConcurrentHashMap(16);
    private boolean dynamic = true;
    @Nullable
    public Cache getCache(String name) {
        Cache cache = (Cache)this.cacheMap.get(name);
//如果没有缓存会自动创建
        if (cache == null && this.dynamic) {
            synchronized(this.cacheMap) {
                cache = (Cache)this.cacheMap.get(name);
                if (cache == null) {
                    cache = this.createConcurrentMapCache(name);
                    this.cacheMap.put(name, cache);
                }
            }
        }

        return cache;
    }
...
}

2.SimpleKeyGenerator生成Key的默认策略:

如果没有参数:key =new SimpleKey();

如果有一个参数:key=参数的值

如果有多个参数:key=new Simple(params);

  public static Object generateKey(Object... params) {
        if (params.length == 0) {
            return SimpleKey.EMPTY;
        } else {
            if (params.length == 1) {
                Object param = params[0];
                if (param != null && !param.getClass().isArray()) {
                    return param;
                }
            }

            return new SimpleKey(params);
        }

3.默认的缓存类ConcurrentMapCache,使用ConcurrentMap存储k-v

public class ConcurrentMapCache extends AbstractValueAdaptingCache {
//通过Key查找key-value
  protected Object lookup(Object key) {
        return this.store.get(key);
    }

//方法调用完后将结果存入缓存中
    public void put(Object key, @Nullable Object value) {
        this.store.put(key, this.toStoreValue(value));
    }
...
}

3.整合Redis

3.1 简介

SpringBoot默认开启的缓存管理器是ConcurrentMapCacheManager,创建缓存组件是ConcurrentMapCache,将缓存数据保存在一个个的ConcurrentMap中,开发的时候我们可以使用缓存中间件:redis,memcache,ehcache等,这些缓存中间件的启用很简单,只要向容器中添加相关的Bean就会启用,可以启用多个缓存中间件。

Redis是一个开源的,内存中的数据结构存储系统,它可以用作数据库,缓存和消息中间件。

3.2 Redis的使用

3.2.1 搭建环境

1.导入依赖

  
        
            org.springframework.data
            spring-data-redis

        
        
        
        
            redis.clients
            jedis
            3.2.0
        

2.在application.properties中指定Redis服务器地址

spring.redis.host=127.0.0.1

3.2.2 RedisTemplate

RedisAutoConfiguration向容器中导入了两个类RedisTemplate redisTemplate和StringRedisTemplate,作为Redis客户端分别操作k-v都为对象,k-v都为字符串的值。

Redis的五大常见数据类型:字符串(String),列表(List),集合(Set),散列(Hash),有序集合(ZSet)。

 stringRedisTemplate.opsForValue()[string字符串]
 stringRedisTemplate.opsForList()[List列表]
 stringRedisTemplate.opsForSet()[Set集合]
 stringRedisTemplate.opsForHash()[Hash散列]
 stringRedisTemplate.opsForZSet()[ZSet有序集合]

3.2.3 Redis缓存的使用

在导入Redis依赖后RedisCacheConfiguration类就会生效,创建RedisCacheManager,并使用RedisCache进行缓存数据,要缓存的对象的类要实现Serializable接口,默认情况下是以JDK序列化数据存储在Redis中。

要想让对象以JSON形式存储在Redis中,需要自定义RedisCacheManager,使用GenericJackson2JsonRedisSerializer类对value就行序列化。

 @Bean
    @ConditionalOnMissingBean
    public RedisTemplate empRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
//创建Jackson2JsonRedisSerializer序列化器,传入Employee.class
        Jackson2JsonRedisSerializer ser = new Jackson2JsonRedisSerializer(Employee.class);
        template.setDefaultSerializer(ser);
        return template;
   }

使用这个序列化器进行测试:
 

     @Autowired
    RedisTemplate employeeRedisTemplate;
    /**
     * 测试保存对象
     */
    @Test
    public void test02(){
        Employee empById = employeeMapper.getEmpById(1);
        //默认如果保存对象,使用JDK序列化,序列化后的数据保存到redis
        employeeRedisTemplate.opsForValue().set("emp01",empById);
        //1.将数组以JSON的方式保存
          //(1)自己将数据转换为JSON
          //(2)redisTemplate默认的序列化规则,改变默认的序列化规则
    }

查看Redis数据库,序列化数据如下:

SpringBoot——缓存(注解的使用,整合Redis,自定义CacheManager)_第3张图片

4.自定义CacheManager

4.1 SpringBoot 1.x版本的RedisCacheManager配置

//自定义CacheManager
    @Bean
    public RedisCacheManager empCacheManager(RedisTemplate empRedisTemplate) {
        //将我们自定义的RedisTemplate作为参数,Spring会自动为我们注入
        RedisCacheManager cacheManager = new RedisCacheManager(empRedisTemplate);
        //使用前缀,默认会将CacheName作为key的前缀,最好设置为true,因为缓存可能有很多类
        cacheManager.setUsePrefix(true);
        return cacheManager;
    }
}

但是如果我们仅仅自定义这一个CacheManager则只能操作Employee这一种类型的数据,因为这个CacheMananger只实现了Employee的泛型,操作其他类型就会报错(可以正常缓存其他类型的数据,但是从缓存中查询出的数据在反序列化时会报错)。这时我们就需要自定义多个CacheManager,比如增加一个可以缓存Department类型的CacheMananger:

 @Bean
    public RedisCacheManager deptCacheManager(RedisTemplate deptRedisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(deptRedisTemplate);
        //使用前缀,默认会将CacheName作为key的前缀
        cacheManager.setUsePrefix(true);
        return cacheManager;
    }

当容器中有多个RedisCacheManager的时候,需要使用@Primary指定一个默认的

4.2 SpringBoot 2.x版本的RedisCacheManager配置

 @Bean
  public CacheManager cacheManager(RedisConnectionFactory factory){
      RedisCacheConfiguration redisCacheConfiguration=RedisCacheConfiguration.defaultCacheConfig()
              .entryTtl(Duration.ofDays(1))
              .disableCachingNullValues()
              .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
      return RedisCacheManager.builder(factory).cacheDefaults(redisCacheConfiguration).build();
  }

 

 

 

你可能感兴趣的:(SpringBoot)