1.创建和数据表，写好实体类
2.配置好数据源，配置好mybatis，开启驼峰命名法
3.在Springboot启动类上加上dao接口所在包的扫描和开启缓存注解
package com.atguigu; import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cache.annotation.EnableCaching; /** * 一、搭建基本环境 * 1.执行数据库文件，创建department表和employee表 * 2.创建javabean(即实体类)封装数据 * 3.整合mybatis * 1.配置数据源 * 2.使用注解版的mybatis * （1）使用@MapperScan注解扫描Mapper接口所在的包 * 二、快速体验缓存 * 1、开启基于注解的缓存：在springboot的启动类上使用@EnableCaching注解 * 2、标注缓存注解即可 * @Cacheable 添加缓存 * @CacheEvict 删除缓存 * @CachePut 更新缓存 */ @MapperScan(value = "com.atguigu.mapper") @SpringBootApplication @EnableCaching//开启基于注解的缓存 public class SpringbootCache01Application { public static void main(String[] args) { SpringApplication.run(SpringbootCache01Application.class, args); } }
4.写好dao接口的方法，这里使用注解的方式
package com.atguigu.mapper;
import com.atguigu.bean.Employee;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
public interface EmployeeMapper {
@Select("select * from employee where id=#{id}")
public Employee findEmpById(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 deleteEmpById(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 findEmpByLastName(String lastName);
}
5.写业务层
package com.atguigu.service; import com.atguigu.bean.Employee; import com.atguigu.mapper.EmployeeMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cache.annotation.*; import org.springframework.stereotype.Service; @CacheConfig(cacheNames = "emp")//抽取缓存的公共配置，这样下面配置缓存的时候就不用了配置cacheNames了 @Service public class EmployeeService { @Autowired EmployeeMapper employeeMapper; /** * 将方法的运行结果进行缓存；以后再要相同的数据，直接从缓存中获取，不用调用方法； * CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一一个名字； * * * 原理： * 1、自动配置类；CacheAutoConfiguration * 2、缓存的配置类 * 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.GuavaCacheConfiguration * org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默认】 * org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration * 3、哪个配置类默认生效：SimpleCacheConfiguration； * * 4、给容器中注册了一个CacheManager：ConcurrentMapCacheManager * 5、可以获取和创建ConcurrentMapCache类型的缓存组件；他的作用将数据保存在ConcurrentMap中； * * 运行流程： * @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、将目标方法返回的结果，放进缓存中 * * @Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存， * 如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据； * * 核心： * 1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件 * 2）、key使用keyGenerator生成的，默认是SimpleKeyGenerator * * * 几个属性： * cacheNames/value：指定缓存组件的名字;将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存； * * key：缓存数据使用的key；可以用它来指定。默认是使用方法参数的值 1-方法的返回值 * 编写SpEL； #i d;参数id的值 #a0 #p0 #root.args[0] * getEmp[2] * * keyGenerator：key的生成器；可以自己指定key的生成器的组件id * key/keyGenerator：二选一使用; * * * cacheManager：指定缓存管理器；或者cacheResolver指定获取解析器 * * condition：指定符合条件的情况下才缓存； * ,condition = "#id>0" * condition = "#a0>1"：第一个参数的值>1的时候才进行缓存 * * unless:否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断 * unless = "#result == null" * unless = "#a0==2":如果第一个参数的值是2，结果不缓存； * sync：是否使用异步模式 * @param id * @return * */ @Cacheable(cacheNames = "emp") public Employee findEmpById(Integer id){ System.err.println("查询=====>"+id+" 号员工"); return employeeMapper.findEmpById(id); } /** * @CachePut：既调用方法，又更新缓存数据；同步更新缓存 * 修改了数据库的某个数据，同时更新缓存； * 运行时机： * 1、先调用目标方法 * 2、将目标方法的结果缓存起来 * * 测试步骤： * 1、查询1号员工；查到的结果会放在缓存中； * key：1 value：lastName：张三 * 2、以后查询还是之前的结果 * 3、更新1号员工；【lastName:zhangsan；gender:0】 * 将方法的返回值也放进缓存了； * key：传入的employee对象 值：返回的employee对象； * 4、查询1号员工？ * 应该是更新后的员工； * key = "#employee.id":使用传入的参数的员工id； * key = "#result.id"：使用返回后的id * @Cacheable的key是不能用#result * 为什么是没更新前的？【1号员工没有在缓存中更新】 * 因为保存的缓存的key和更新的缓存的key不一样 * 所以，在使用更新，清除缓存注解的时候一定要保证和添加缓存的注解的key相同 */ @CachePut(value = "emp",key ="#employee.id") public Employee updateEmp(Employee employee){ System.err.println("============================>updateEmp调用了"); employeeMapper.updateEmp(employee); return employee; } /** * @CacheEvict：缓存清除 * key：指定要清除的数据 * allEntries = true：指定清除这个缓存中所有的数据 * beforeInvocation = false：缓存的清除是否在方法之前执行 * 默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除 * * beforeInvocation = true： * 代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除 */ @CacheEvict(value = "emp",key = "#id") public void deleteEmpById(Integer id){ System.err.println("============================>deleteEmpById调用了"); employeeMapper.deleteEmpById(id); } @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){ System.err.println("============================>getEmpByLastName调用了"); Employee empByLastName = employeeMapper.findEmpByLastName(lastName); return empByLastName; } }
二、Springboot整合redis作为缓存
流程
* 整合redis作为缓存 * Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 * 1、安装redis：使用docker； * 2、引入redis的starter * 3、配置redis * 4、测试缓存 * 原理：CacheManager===Cache 缓存组件来实际给缓存中存取数据 * 1）、引入redis的starter，容器中保存的是 RedisCacheManager； * 2）、RedisCacheManager 帮我们创建 RedisCache 来作为缓存组件；RedisCache通过操作redis缓存数据的 * 3）、默认保存数据 k-v 都是Object；利用序列化保存；如何保存为json * 1、引入了redis的starter，cacheManager变为 RedisCacheManager； * 2、默认创建的 RedisCacheManager 操作redis的时候使用的是 RedisTemplate<Object, Object> * 3、RedisTemplate<Object, Object> 是 默认使用jdk的序列化机制 * 4）、自定义CacheManager； */
1.引入redis的starter
<!--引入redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
2.配置redis
• 在application.properties中配置redis的主机地址
spring.redis.host=192.168.144.143
• 启动类与上面相同
@MapperScan(value = "com.atguigu.mapper")
@SpringBootApplication
@EnableCaching//开启基于注解的缓存
public class SpringbootCache01Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootCache01Application.class, args);
}
}
• 自定义cacheMange使用json序列化方式
package com.atguigu.config;
import com.atguigu.bean.Department;
import com.atguigu.bean.Employee;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.net.UnknownHostException;
@Configuration
public class MyRedisConfig {
@Bean
public RedisTemplate<Object, Employee> employeeRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
RedisTemplate<Object, Employee> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
template.setDefaultSerializer(serializer);
return template;
}
/**
* 自定义缓存管理器，向redis数据库中存入json格式的数据
* @param redisConnectionFactory
* @return
*/
@Primary
@Bean
public CacheManager empCacheManager(RedisConnectionFactory redisConnectionFactory) {
RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
//.entryTtl(Duration.ofSeconds(10)) //设置过期时间
//.disableCachingNullValues() //禁止缓存null对象
.computePrefixWith(cacheName -> "yourAppName".concat(":").concat(cacheName).concat(":")) //此处定义了cache key的前缀，避免公司不同项目之间的key名称冲突
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) //定义了key和value的序列化协议，同时hash key和hash value也被定义
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(Employee.class)));
return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(cacheConfiguration).build();
}
}
• 缓存注解啥的都不变
@Cacheable 添加缓存 @CacheEvict 删除缓存 @CachePut 更新缓存