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

最新推荐文章于 2024-09-21 18:15:12 发布

止步前行

最新推荐文章于 2024-09-21 18:15:12 发布

阅读量2.8k

点赞数

分类专栏： SpringBoot 文章标签： Cache Redis SpringBoot 缓存

本文链接：https://blog.csdn.net/zxd1435513775/article/details/85091793

版权

SpringBoot 专栏收录该内容

27 篇文章 10 订阅

订阅专栏

一、基本项目搭建

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

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

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

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

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

	<!-- https://mvnrepository.com/artifact/javax.cache/cache-api -->
	<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
在这里插入图片描述

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

二、快速体验Cache使用

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

@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)、测试结果
多次发送请求，控制台只显示查询了一次数据库操作，缓存成功。
在这里插入图片描述

(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表达式的说明：
在这里插入图片描述

@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)、测试结果：
发送更新用户信息请求：
在这里插入图片描述

控制台输出：
在这里插入图片描述

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

(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。
表明之前的缓存已清除
在这里插入图片描述

(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支持的缓存配置。
在这里插入图片描述

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

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

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，并用客户端连接：
在这里插入图片描述

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中写数据
在这里插入图片描述

从Redis中读数据：
在这里插入图片描述

(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中写数据，会发现是一堆字节码
在这里插入图片描述

(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));
    }
}