SpringBoot项目中使用缓存搭建的基本步骤

在SpringBoot项目中使用缓存搭建的基本步骤
1.实体类

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 + "]";
	}

2.对应的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 deleteEmpById(Integer id);

    @Insert("INSERT INTO employee(lastName,email,gender,dId) VALUES(#{lastName},#{email},#{gender},#{dId})")
    public void insertEmployee(Employee employee);

    @Select("SELECT * FROM employee WHERE lastName=#{lastName}")
    public Employee getEmpBylistName(String lastName);
}

3.service类

/**
 * 注解CacheConfig的作用就是抽取缓存中的公共配置
 * 比如:cacheNames="emp"在其他注解中就不用定义了
 */
@Service
/*@CacheConfig(cacheNames = "emp")*/
public class EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;


    /**
     * 将方法的结果进行缓存,以后再要相同的数据,直接从缓存中获取,不用调用方法
     * <p>
     * CacheManager(缓存管理器)管理多个cache组件的,对缓存的真正CRUD操作在cache组件中,每一个缓存组件都有一个唯一自己的名字
     * 注解Cacheable中的几个属性:
     *    cacheNames/value:指定缓存组件的名字
     *    key:缓存数据使用的key,可以用它来指定,默认是使用方法参数的值,如下参数是1的话,值就是返回值
     *             如果编写SpEl的话:#id,这些都是参数id的值,   #a0,#p0,#root.args[0]
     *    keyGenerator:key的生成器,可以自己指定key的生成器的组件id
     *             key/keyGenerator:二选一使用
     *    cacheManager:指定缓存管理器,或者cacheResolver指定获取解析器
     *    condition:指定符合条件的情况才使用缓存,如condition="#id>0"
     *    unless:否定缓存,当unless指定的条件为true,方法的返回值就不会缓存,可以获取到结果进行判断
     *             unless="#result==null"
     *    sync:是否使用异步模式
     *    原理：
     *   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
     *
     * 注解Cacheable中的几个属性:
     *    cacheNames/value:指定缓存组件的名字,可以指定多个缓存
     *    key:缓存数据使用的key,可以用它来指定,默认是使用方法参数的值,如下参数是1的话,值就是返回值
     *             如果编写SpEl的话:#id,这些都是参数id的值,   #a0,#p0,#root.args[0]
     *             key="#root.methodName+'['+#id+']'"(指定key值)等同于getEmp[1]
     *    keyGenerator:key的生成器,可以自己指定key的生成器的组件id
     *             key/keyGenerator:二选一使用
     *             key = "#root.methodName+'['+#id+']'"
     *             自己指定key:keyGenerator = "myKeyGenerator"(config包下MyCacheConfig类的KeyGenerator方法)
     *
     *    cacheManager:指定缓存管理器,或者cacheResolver指定获取解析器
     *    condition:指定符合条件的情况才使用缓存,如condition="#id>0"
     *       condition = "#id>1 and #root.methodName eq 'aaa'"(当id值大于1时并且缓存名key值为aaa) 可以指定多个条件,当满足这些条件时,才进行缓存,否则不缓存
     *
     *    unless:否定缓存,当unless指定的条件为true,方法的返回值就不会缓存,可以获取到结果进行判断
     *             unless="#result==null"
     *             unless="#a0==2"如果当第一个参数的值为2,结果不缓存
     *
     *    sync:是否使用异步模式(unless不支持)
     *
     *自己指定key:keyGenerator = "myKeyGenerator"(config包下MyCacheConfig类的KeyGenerator方法)
     * @param id
     * @return
     */
    @Cacheable(cacheNames = {"emp"})
    public Employee getEmp(Integer id) {
        System.out.println("查询" + id);
        Employee employee = employeeMapper.getEmpById(id);
        return employee;
    }


    /**
     * 更新数据
     * 注解CachePut:保证方法被调用,又希望结果被缓存
     * 修改了数据库中的数据,同时更新缓存
     * 运行时机:
     *    1.先调用目标方法
     *    2.将目标方法的结果缓存起来
     *测试步骤:
     *   1.查询1号员工,将查到的结果放在缓存中
     *      key值是参数id,当前为1,values值为lastName
     *   2.以后查询还是之前的结果
     *   3.更新1号员工[lastName:zhangsan,gender:0]
     *      将方法的返回值也放进了缓存
     *      更新的key为传入的employee对象,值为返回的employee对象
     *   4.查询1号员工?
     *      应该是更新后的数据
     *      如果想是更新后的数据,key值就应该和查询是放进缓存中的key值一样,这样才能达到同步
     *      更新是指定key应该是:key = "#employee.id",使用传入的参数的员工id
     *                         key="#result.id":使用返回后的id,这两个key是一样的效果
     * @param employee
     * @return
     */
    @CachePut(value = "emp",key = "#result.id")
    public Employee updateEmp(Employee employee){
        System.out.println("更新:"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }


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

    /**
     *注解Caching包括cacheable注解,put注解,evict注解
     *定义复杂的缓存规则
     * 如果按照lastname查询一次数据库时,第二次如果根据的是id还是email都不会从数据库中查询而是从emp缓存中查询的
     * 但是如果put中查询了之后再用cacheable查还会从数据库查
     * 注意:key值的实体类对应的数据库列名不能为空
     * @param lastName
     * @return
     */
    @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.getEmpBylistName(lastName);
    }


}

4.controller类

/**
 * 使用注解RestController是为了返回json数据
 */
@RestController
public class EmployeeCotroller {

    @Autowired
    EmployeeService employeeService;

    /**
     * 查询数据
     *
     * @param id
     * @return
     */
    @RequestMapping("/emp/{id}")
    public Employee getEmployee(@PathVariable("id") Integer id) {
        Employee employee = employeeService.getEmp(id);
        return employee;
    }

    /**
     * 更新数据
     *
     * @param employee
     * @return
     */
    @RequestMapping("/emp")
    public Employee updateEmp(Employee employee) {
        Employee emp = employeeService.updateEmp(employee);
        return emp;
    }

    /**
     * 删除数据
     * @param id
     * @return
     */
    @GetMapping("/delemp")
    public String delEmp(Integer id) {
        employeeService.deleteEmp(id);
        return "success";
    }

    /**
     * 查询lastName为条件的值
     * @param lastName
     * @return
     */
    @GetMapping("/emp/lastname/{lastName}")
   public Employee getEmpByListName(@PathVariable("lastName") String lastName){
       return employeeService.getEmpByLastName(lastName);
   }



}

5.主方法类

/**
 * (一)搭建基本环境
 * 1.导入数据库文件,创建出department和employee表
 * 2.创建javaBean封装数据
 * 3.整合Mybatis操作数据库
 *    1)配置数据源信息
 *    2)使用注解版Mybatis
 *       1.使用@MapperScan注解指定需要扫描的mapper接口所在的包
 * (二)快速体验缓存
 *    SpringBoot步骤:
 *       1)开启注解的缓存EnableCaching
 *       2)标注缓存注解即可
 *       Cacheable-标注方法缓存
 *       CacheEvict-清空缓存
 *       CachePut-保证方法被调用,又希望结果被缓存
 *  默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache；将数据保存在	ConcurrentMap<Object, Object>中
 */
@MapperScan("com.atguigu.springboot01cache.mapper")
@SpringBootApplication
@EnableCaching
public class Springboot01CacheApplication {

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

有关于缓存常见的注解:

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