SpringBoot中快速体验缓存（Cache）使用

小鱼儿 2022-04-08 19:49 495阅读 0赞

## 一、基本项目搭建 ##

测试项目是基于SpringBoot+Mybatis+Maven；

###### 1、搭建基本环境，具体步骤如下： ######

（1）、新建数据库，导入数据库文件，创建出department和employee表；

（2）、创建SpringBoot-cache工程，选择具体模块，如下图；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]

（3）、在pom.xml文件中，加入cache依赖

<dependency>
    	    <groupId>javax.cache</groupId>
    	    <artifactId>cache-api</artifactId>
    	    <version>1.0.0</version>
    	</dependency>

（4）、创建JavaBean封装数据，以Employee表为例；

public class Employee { 
    	
    	private Integer id;
    	private String lastName;
    	private String email;
    	private Integer gender; //性别 1男 0女
    	private Integer dId;
    
    	//setter、getter方法略
    }

（5）、在配置文件中，配置数据库；

//配置项目对外访问路径
    server.servlet.context-path=/cache
    
    //配置数据源
    spring.datasource.url=jdbc:mysql://192.168.1.106:3307/mybatis
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    
    //开启驼峰命名
    mybatis.configuration.map-underscore-to-camel-case=true
    
    //打开操作数据库的日志
    logging.level.com.scorpios.cache.mapper=debug

（6）、整合Mybatis操作数据；

@Mapper
    public interface EmployeeMapper { 
    
        //查
        @Select("select * from employee where id = #{id}")
        public Employee getEmpById(Integer id);
    
        //增
        @Insert("insert into employee (lastName,email,gender,did) values ( #{lastName},#{email},#{gender},#{dId})")
       public void addEmp(Employee emp);
    
        //删
        @Delete("delete from employee where id = #{id}")
        public void delEmpById(Integer id);
    
        //改
        @Update("update employee set lastName=#{lastName},email=#{email},gender=#{gender},did=#{dId} where id=#{id}")
        public void updateEmp(Employee emp);
    }

（7）、配置扫描Mapper包；

@MapperScan("com.scorpios.cache.mapper")		//配置扫描mapper包
    @SpringBootApplication
    public class SpringbootCacheApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(SpringbootCacheApplication.class, args);
        }
    
    }

（8）、测试访问：[http://localhost:8080/cache/emp/1][http_localhost_8080_cache_emp_1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]

多次访问，控制台输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 2]

## 二、快速体验Cache使用 ##

1、想要使用Cache缓存，首先了解关于Cache的注解，并需要开启缓存注解：@EnableCaching  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 3]  
开启缓存功能的注解

@EnableCaching //开启缓存注解
    @MapperScan("com.scorpios.cache.mapper")
    @SpringBootApplication
    public class SpringbootCacheApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(SpringbootCacheApplication.class, args);
        }
    }

2、@Cacheable注解使用和说明  
编写Service层，调用Dao层，并在Service层，对操作Dao层的数据进行缓存

@Service
    public class EmployeeService { 
        
        @Autowired
        EmployeeMapper employeeMapper;
    
        @Cacheable(cacheNames = "emp",key = "#root.args[0]")
        public Employee getEmpById(Integer id){ 
            System.out.println("查询"+id+"号员工");
            Employee emp = employeeMapper.getEmpById(id);
            System.out.println(emp);
            return emp;
        }
    }

(1)、测试结果  
多次发送请求，控制台只显示查询了一次数据库操作，缓存成功。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 4]

(2)、@Cacheable参数具体说明  
@Cacheable:将方法的运行结果缓存，以后再要相同的数据，直接从缓存中获取，不用调用方法；

cacheNames/value：指定缓存组件的名字，将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；
    	例如：@Cacheable(cacheNames = {}"emp","dept"},key = "#root.args[0]")
    	
    	key：可以用它来指定缓存数据使用的key，默认是使用方法参数的值；（也可以指定自己的生成策略）
    	
    	keyGenerator：key的生成器；可以自己指定key的生成器的组件id；key/keyGenerator：二选一使用；
    	
    	cacheManager：指定缓存管理器；或者cacheResolver指定获取解析器；
    	
    	condition：指定符合条件的情况下才缓存；
    	例如：@Cacheable(cacheNames = {}"emp","dept"},key = "#root.args[0]",condition="#root.args[0]>0")
    	
    	unless：否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断；
    	
    	sync：是否使用异步模式；

(3)、指定自己的key生成策略和key的SPEL表达式的说明：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 5]

@Cacheable(cacheNames = "emp",keyGenerator = "myKeyGenerator")
    public Employee getEmpById(Integer id){ 
            System.out.println("查询"+id+"号员工");
            Employee emp = employeeMapper.getEmpById(id);
            System.out.println(emp);
            return emp;
    }

自定义自己的key生成策略

@Configuration
    public class MyCacheConfig { 
    
        @Bean("myKeyGenerator")
        public KeyGenerator keyGenerator(){ 
    
            return new KeyGenerator() { 
                @Override
                public Object generate(Object target, Method method, Object... params) { 
    
                    return method.getName()+Arrays.asList(params).toString();
                }
            };
    
        }
    }

(4)、@Cacheable运行流程

1、方法运行之前，先去查询Cache(缓存组件)，按照cacheNames指定的名字获取；
    		（CacheManager先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
    		
    	2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；
    		key是按照某种策略生成的；默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key；
    			SimpleKeyGenerator生成key的默认策略：
    				如果没有参数：key=new SimpleKey();
    				如果有一个参数：key=参数的值
    				如果有多个参数：key=new SimpleKey(params);
    				
    	3、没有查到缓存就调用目标方法；
    	
    	4、将目标方法返回的结果，放进缓存中；

3、@CachePut注解使用和说明  
作用：在目标方法调用之后，将目标方法的执行结果放入缓存，既调用方法，又更新缓存数据；

(1)、测试代码：

@CachePut(cacheNames = "emp",key = "#result.id")//key需要注意
        public Employee updateEmp(Employee employee){ 
            System.out.println("更新的员工信息："+employee);
            employeeMapper.updateEmp(employee);
            return employee;
        }

(2)、测试结果：  
发送更新用户信息请求：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 6]

控制台输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 7]

发送查询请求后，控制台并没有任何输出，说明是从缓存中拿的数据：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 8]

(3)、重要说明：

@CachePut(cacheNames = "emp",key = "#result.id")//key需要注意

如果我们在使用@CachePut注解时，不指定key，这会使用方法的默认参数，这样的话，与@Cacheable注解的key不一致，导致，我们更新过后，再次查询信息时，并不会得到缓存信息。这主要是以为key不一致导致的，需要注意。

4、@CacheEvit注解使用和说明  
作用：缓存清除  
(1)、测试代码：

@CacheEvict(cacheNames = "emp",key ="#root.args[0]")
        public void deleteEmp(Integer id){ 
    
            //模拟删除
            System.out.println("删除数据，员工id为：" +id );
    
        }

(2)、测试结果：  
第一次查询id为1的员工，控制台打印查询数据库请求，第二次查询则不会去查询数据库；  
然后发送删除id为1的员工请求，控制台打印，删除信息；  
最后再次发送查询id为1的员工，控制台再次打印查询数据库的SQL。  
表明之前的缓存已清除  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 9]

(3)、@CachePut参数说明：

key：指定要清除的数据；
    
    allEntries=true；指定清除这个缓存中所有的数据；
    
    beforeInvocation=false;缓存的清除是否在方法之前执行
    	默认代表缓存清除操作是在方法之后执行；如果出现异常缓存就不会清除
    	
    beforeInvocation=true:
    	代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除

4、@Caching注解使用和说明  
可以指定多个缓存规则，下面是@Caching的源码

@Target({ ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Caching { 
    
    	Cacheable[] cacheable() default { };
    
    	CachePut[] put() default { };
    
    	CacheEvict[] evict() default { };
    
    }

示例代码：

@Caching(
                cacheable = { 
                     @Cacheable(cacheNames = "emp",key = "#lastName")
                },
    
                put = { 
                     @CachePut(cacheNames = "emp",key="#result.id"),
                     @CachePut(cacheNames = "emp",key="#result.email")
                }
        )
        public Employee getEmpByNames(String lastName){ 
    
        }

4、@CacheConfig注解使用和说明  
可以在类上加上次注解，用于指定类级别的公共缓存属性，例如使用公共缓存名字和id的生成策略

@CacheConfig(cacheNames = "emp")
    @Service
    public class EmployeeService { 
    
    }

## 三、SpringBoot整合Redis作为缓存 ##

在我们没有配置使用其他缓存中间件时，SpringBoot默认使用的是ConcurrentMapCacheManager，然后用这个Manager来创建ConcurrentMapCache，并将数据保存在ConcurrentMap<Object,Object>中；下图是SpringBoot支持的缓存配置。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 10]

但在实际的开发中，我们经常会使用一些缓存中间件，如：Redis、MemCached、eheache等；

1、安装Redis：安装Redis可以参考前面文章的RabbitMQ和ElasticSearch，用Docker安装比较方便，启动起来后，用客户端连接上Redis，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 11]

2、Redis整合步骤：  
(1)、引入Redis的starter

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

(2)、在application.properties文件中配置Redis

spring.redis.host=192.168.1.106

(3)、启动Redis，并用客户端连接：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 12]

3、测试普通字符串代码：

RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootCacheApplicationTests { 
    
        @Autowired
        RedisTemplate redisTemplate;    //k-v都是对象
    
        @Autowired
        StringRedisTemplate stringRedisTemplate;    //操作k-v都是字符串
    
        @Test
        public void testRedis(){ 
            //给Redis中保存数据
            stringRedisTemplate.opsForValue().append("msg","helloworld");
    
    		//从Redis中取数据
    		String msg = stringRedisTemplate.opsForValue().get("msg");
           System.out.println("msg from redis:"+msg);
        }
    }

(1)、测试结果：  
往Redis中写数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 13]

从Redis中读数据：  
![在这里插入图片描述][2018122015550234.png]

(2)、说明：  
Redis常见的五大数据类型：String(字符串)、list(列表)、set(集合)、hash(散列)、ZSet(有序集合)

stringRedisTemplate.opsForValue()		操作String字符串
    stringRedisTemplate.opsForList()		操作list列表
    stringRedisTemplate.opsForSet()		操作Set集合
    stringRedisTemplate.opsForHash()		操作Hash散列
    stringRedisTemplate.opsForZSet		操作Zset有序集合

4、测试存储对象：

@Test
    public void testRedis(){ 
       //给Redis中保存数据
        redisTemplate.opsForValue().set("emp",employeeMapper.getEmpById(1));
    }

(1)、测试结果：  
往Redis中写数据，会发现是一堆字节码  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 14]

(2)、自定义序列化器

@Configuration
    public class MyRedisConfig { 
    
        @Bean
        public RedisTemplate<Object, Employee> myRedisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { 
                RedisTemplate<Object, Employee> template = new RedisTemplate<>();
                template.setConnectionFactory(redisConnectionFactory);
            //设置自定义序列化器
            Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
    
            template.setDefaultSerializer(serializer);
                return template;
            }
    }

(3)、测试代码，需要自动注入自己的序列化器：

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootCacheApplicationTests { 
    
        @Autowired
        EmployeeMapper employeeMapper;
    
        @Autowired
        RedisTemplate myRedisTemplate;  //自定义的序列化器
    
        @Test
        public void testRedis(){ 
            //给Redis中保存数据
            myRedisTemplate.opsForValue().set("emp",employeeMapper.getEmpById(1));
        }
    }

(4)、测试结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 15]

## 四、小结 ##

1、想要使用缓存，需要先开启缓存注解@EnableCaching；

2、熟练对@Cacheable、@CachePut、@CacheEvict、@Caching注解的使用，特别是属性的使用；  
3、SpringBoot整合Redis作为缓存；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]: /images/20220404/2ac4a12a27ba4838b2a0911bb7b6124d.png
[http_localhost_8080_cache_emp_1]: http://localhost:8080/cache/emp/1
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]: /images/20220404/6a9b321765304c6494c29272a39475a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 2]: /images/20220404/a0ca101b31f94d389407f373e2621417.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 3]: /images/20220404/39f14b549efd41299b1fb3438f65f494.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 4]: /images/20220404/dff45bdc076a4ce3b90c010a4fc35b25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 5]: /images/20220404/e0ea6ba26f4545ba9097a82d204914c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 6]: /images/20220404/cbad8032bdf44b88bfbee697613ca60d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 7]: /images/20220404/906b3230ca4e4a3ab8bb6dff5b8561e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 8]: /images/20220404/8f2995327b18483289b7ff0304ab8f15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 9]: /images/20220404/9477716a0f664b55bfe16baedd91f6e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 10]: /images/20220404/230867e83c354e1cab88f1d4564667fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 11]: /images/20220404/1bd42076603242298b24304eaa67e333.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 12]: /images/20220404/0fb706a6d36d4e278f85bd8bccc63b75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 13]: /images/20220404/e55f24ff1499444a813665b38e4d1c91.png
[2018122015550234.png]: /images/20220404/aa545e5d4ded4f368deaa498c14d911b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 14]: /images/20220404/a1467a27ead945ea9add7107467b4371.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 15]: /images/20220404/c1f632f335e84dfb991553a0f1e73b6c.png