SpringBoot整合Cache

已于 2022-02-02 09:33:34 修改
阅读量2.2k 收藏 16
点赞数 6
分类专栏： springboot 文章标签： spring boot 缓存 spring java
于 2022-01-18 14:04:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44292366/article/details/122558644
版权

目录

一、Spring Boot与缓存

Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。

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

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

  • Cache接口为缓存的组件规范定义，包含缓存的各种操作集合
  • Cache接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache , ConcurrentMapCache等

每次调用需要缓存功能的方法时，Spring会检查指定参数的指定的目标方法是否 已经被调用过，如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户，下次调用直接从缓存中获取。

  • 使用Spring缓存抽象时我们需要关注以下两点：
  • 确定方法需要被缓存以及他们的缓存策略
  • 从缓存中读取之前缓存存储的数据

1.1 缓存注解

名称含义
Cache缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、 ConcurrentMapCache等
CacheManager缓存管理器，管理各种缓存（Cache）组件
@Cacheable主要针对方法配置，能够根据方法的请求参数对其结果进行缓存
@CacheEvict清空缓存，主要在删除数据后清理之前缓存的值
@CachePut保证方法被调用，又希望结果被缓存，主要用于数据修改后对缓存的数据进行刷新
@EnableCaching开启基于注解的缓存
keyGenerator缓存数据时key生成策略
serialize缓存数据时value序列化策略

1.2 注解主要参数

参数名解释示例
value | cacheNames缓存的名称，在 spring 配置文件中定义，必须指定至少一个，二选一@Cacheable(value=”mycache”) 或者 @Cacheable(cacheNames={”cache1”,”cache2”}
key | keyGenerator缓存的 key，可以为空，如果指定要按照 SpEL 表达 式编写，如果不指定，则缺省按照方法的所有参数进行组合，二选一@Cacheable(value=”testcache”,key=”#userName”)
condition缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存/清除缓存，在调用方法之前之后都能判断@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
allEntries (@CacheEvict )是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
beforeInvocation (@CacheEvict)是否在方法执行前就清空，缺省为 false，如果指定 为 true，则在方法还没有执行的时候就清空缓存， 缺省情况下，如果方法执行抛出异常，则不会清空缓存@CachEvict(value=”testcache”， beforeInvocation=true)
unless (@CachePut) (@Cacheable)用于否决缓存的，不像condition，该表达式只在方 法执行之后判断，此时可以拿到返回值result进行判断。条件为true不会缓存，fasle才缓存@Cacheable(value=”testcache”,unless=”#result == null”)

1.3 SpEl表达式

名字位置描述示例
methodNameroot object当前被调用的方法名#root.methodName
methodroot object当前被调用的方法#root.method.name
targetroot object当前被调用的目标对象#root.target
targetClassroot object当前被调用的目标对象类#root.targetClass
argsroot object当前被调用的目标对象类#root.args[0]
cachesroot object当前方法调用使用的缓存列表（如@Cacheable(value={“cache1”, “cache2”})），则有两个cache#root.caches[0].name
argument nameevaluation context方法参数的名字，可以直接 #参数名 ，也可以使用 #p0或#a0 的 形式，0代表参数的索引；#iban 、 #a0 、 #p0
resultevaluation context方法执行后的返回值（仅当方法执行之后的判断有效，如 ‘unless’，’cache put’的表达式 ’cache evict’的表达式 beforeInvocation=false）#result

1.4 基本使用

包结构：

在这里插入图片描述

  1. pom文件

     <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--druid数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!--mybatis 依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>
        <!--缓存依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
    </dependencies>

  2. yml配置文件，配置数据源连接信息和mybatis的配置

    spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///test?serverTimezone=UTC
    username: root
    password: root123456

mybatis:
  configuration:
    #    开启mybatis-plus的驼峰命名
    map-underscore-to-camel-case: true
    #    开启sql打印
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
debug: true

  3. 在启动类上开启Cache的注解扫描，并配置Mapper接口的扫描路径

    /**
 * 1.开启基于注解的缓存 @EnableCaching
 */
@EnableCaching
@MapperScan("com.veo.mapper")
@SpringBootApplication
public class SpringbootCacheApplication {

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

}

  4. 创建对象

    @Data
@NoArgsConstructor
@AllArgsConstructor
public class Department implements Serializable {
    private Integer id;
    private String departmentName;
}

//------------------------------------------------

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee implements Serializable {
    private Integer id;
    private String lastName;
    private String email;
    private Integer gender;
    private Integer dId;
}

  5. 创建对象的Mapper接口

    @Repository
public interface EmployeeMapper {

    @Select("select * from employee")
    List<Employee> getAllEmployees();

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


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

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

    @Select("select * from employee wehre last_name=#{lastName}")
    Employee getEmployeeByLastName(String lastName);

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

    @Repository
public interface DeptMapper {

    @Select("select * from department where id=#{id}")
    Department getDepartmentById(Integer id);
}

  6. 创建Service接口

    public interface EmployeeService {

    Employee getEmployeeById(Integer id);

    List<Employee> getAllEmployees();

    Employee updateEmployeeById(Employee employee);

    void deleteEmployeeById(Integer id);

    Employee getEmployeeByLastName(String lastName);
}

public interface DeptService {

    Department getDepartmentById(Integer id);
}

  1. 创建接口的实现类，在接口的实现类中使用Cache注解

    @Service
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    /**
     *   cacheNames/value：指定缓存组件的名字;将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；
     *   key：缓存数据使用的key；可以用它来指定。默认是使用方法参数的值  1-方法的返回值
     *   编写SpEL； #id;参数id的值   #a0  #p0  #root.args[0]
     *   key = "#methodName+'['+#id+']'"  等价与 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，结果不缓存，返回结果为true不缓存，为false才缓存
     *    sync：是否使用异步模式，使用异步模式后unless不可以使用
     * @param id
     * @return
     */
    @Cacheable(cacheNames = "emp",keyGenerator = "myKeyGenerator",condition = "#id>1 and #id<5",unless = "#id==2 and #result==null")
    @Override
    public Employee getEmployeeById(Integer id) {
        System.out.println("getEmployeeById" + id);
        return employeeMapper.getEmployeeById(id);
    }

    @Override
    public List<Employee> getAllEmployees() {
        System.out.println("getAllEmployees");
        return employeeMapper.getAllEmployees();
    }

    @Override
    public Employee updateEmployeeById(Employee employee) {
        System.out.println("updateEmployeeById" + employee.getId());
        employeeMapper.updateEmployeeById(employee);
    }

    @Override
    public void deleteEmployeeById(Integer id) {
        System.out.println("deleteEmployeeById" + id);
        employeeMapper.deleteEmployeeById(id);

    }

    @Override
    public Employee getEmployeeByLastName(String lastName) {
        System.out.println("getEmployeeByLastName" + lastName);
        return employeeMapper.getEmployeeByLastName(lastName);
    }
}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
 DeptMapper deptMapper;

    @Override
    public Department getDepartmentById(Integer id) {
        return deptMapper.getDepartmentById(id);
    }
}

  1. 编写Controller

    @RestController
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;

    @GetMapping("/getAllEmp")
    public List<Employee> getAllEmployee(){
        return employeeService.getAllEmployees();
    }

    @GetMapping("/emp/{id}")
    public Employee getEmployeeById(@PathVariable("id")Integer id){
        return employeeService.getEmployeeById(id);
    }

    @GetMapping("/emp")
    public Employee updateEmployee(Employee employee){
        return employeeService.updateEmployeeById(employee);;
    }

    @GetMapping("/delEmp/{id}")
    public String deleteEmployee(@PathVariable("id") Integer id){
        employeeService.deleteEmployeeById(id);
        return "success";
    }
    
    @GetMapping("/getEmpByName/{name}")
    public Employee getEmpByName(@PathVariable("name") String lastName){
        return employeeService.getEmployeeByLastName(lastName);
    }
}

  2. 配置自定义的keyGenerator

    @Configuration
public class MyCacheConfig {

    @Bean
    public SimpleKeyGenerator keyGenerator(){
        return new SimpleKeyGenerator(){
            @Override
            public Object generate(Object target, Method method, Object... params) {
                //自定key返回格式getEmployeeById[id]
                return method.getName() + "[" + Arrays.asList(params) + "]";
            }
        };
    }
}

结果：调用getEmployeeById(Integer id)方法后会缓存id为2,3,4并且返回结果不为空的对象到缓存中。

使用@CachePut、@CacheEvict、@Caching注解

	@Cacheable(cacheNames = "emp",key = "#id")
    @Override
    public Employee getEmployeeById(Integer id) {
        System.out.println("getEmployeeById" + id);
        return employeeMapper.getEmployeeById(id);
    }

/**
     * @CachePut：既调用方法，又更新缓存数据；同步更新缓存
     * 修改了数据库的某个数据，同时更新缓存；
     * 运行时机：
     *  1、先调用目标方法
     *  2、将目标方法的结果缓存起来
     *  3、可以使用spEl的result来获取方法返回的结果
     *
     * 测试步骤：
     *  1、查询1号员工；查到的结果会放在缓存中；
     *          key：1  value：lastName：张三
     *  2、以后查询还是之前的结果，从缓存中拿到的数据
     *  3、更新1号员工；【lastName:zhangsan；gender:0】
     *          将方法的返回值也放进缓存了；
     *          key：为传入的employee对象  值：返回的employee对象；
     *  4、查询1号员工？为什么是没更新前的？【1号员工没有在缓存中更新】
     *      应该是更新后的员工，但是查询发现还是第一次缓存的结果，并不是更新后的数据，主要为修改和查询时的key不同
     *      查询时key 为传入的参数的员工id，查询时key为传入的employee对象，此时缓存中有查询id的缓存所以没有更新
     *      解决方法：统一指定存入缓存中的key
     *          key = "#employee.id":使用传入的参数的员工id；
     *          key = "#result.id"：使用返回后的id
     *      @Cacheable的key是不能用#result 方法执行之前先查缓存
     * @param employee
     */
    @CachePut(value = "emp",key = "#result.id")
    @Override
    public Employee updateEmployeeById(Employee employee) {
        System.out.println("updateEmployeeById" + employee.getId());
        employeeMapper.updateEmployeeById(employee);
        return employee;
    }

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

 /**
     * @Caching 定义复杂的缓存规则
     * 这要定义的复杂规则中有@CachePut注解，则该方法一定会被执行
     * 所以根据名字查询方法一定会被调用，不会从缓存中拿数据
     * @param lastName
     * @return
     */
    @Caching(
            cacheable = {
                    @Cacheable(value="emp",key = "#lastName")
            },
            put = {
                    @CachePut(value="emp",key = "#result.id"),
                    @CachePut(value="emp",key = "#result.email")
            }
    )
    @Override
    public Employee getEmployeeByLastName(String lastName) {
        System.out.println("getEmployeeByLastName" + lastName);
        return employeeMapper.getEmployeeByLastName(lastName);
    }

抽取公共配置到@CacheConfig中

@CacheConfig(cacheNames = "emp",keyGenerator = "myKeyGenerator")
@Service
public class EmployeeServiceImpl implements EmployeeService {
    @Autowired
    EmployeeMapper employeeMapper;

    @Cacheable()
    @Override
    public Employee getEmployeeById(Integer id) {
        System.out.println("getEmployeeById" + id);
        return employeeMapper.getEmployeeById(id);
    }


    @CachePut()
    @Override
    public Employee updateEmployeeById(Employee employee) {
        System.out.println("updateEmployeeById" + employee.getId());
        employeeMapper.updateEmployeeById(employee);
        return employee;
    }


    @Override
    public List<Employee> getAllEmployees() {
        System.out.println("getAllEmployees");
        return employeeMapper.getAllEmployees();
    }

    @CacheEvict(beforeInvocation = true,allEntries = true)
    @Override
    public void deleteEmployeeById(Integer id) {
        System.out.println("deleteEmployeeById" + id);
//        employeeMapper.deleteEmployeeById(id);
        int i = 10/0;
    }
}

使用小结：

  1. @Cacheable
    • 先去缓存中根据key查询数据，查到数据就返回，查不到执行目标方法后将返回的结果缓存，默认key为方法的参数
    • 不可以使用spEl的result来获取返回的结果
    • 可以指定缓存的添加和key的生成方式
  2. @CachePut
    • 先调用目标方法将方法的返回结果缓存，并根据key更新缓存中的数据，和@Cacheable使用的是要指定一致的key，否则会根据默认方法的参数进行缓存，查询的时候就不是更新之后的数据而还是先前的数据
    • 目标方法一定会得到执行
  3. @CacheEvict
    • 和上面注解一起使用时，也要配置一致的key，否则key默认为方法的参数值，默认是在方法执行之后清除对应key的缓存，方法执行有异常就不清除缓存
    • allEntries = true：指定清除这个缓存中所有的数据
    • beforeInvocation = true：代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除
  4. @Caching
    • 定义复杂的缓存规则
    • 其中有@CachePut注解时，目标方法一定会得到执行
  5. @CacheConfig
    • 抽取公共的配置属性到类上面

1.5 基本原理

查看缓存自动配置类CacheAutoConfiguration，自动配置类导入了CacheConfigurationImportSelector类，查看此类发现该类导入了

  • 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

十个CacheConfiguration配置类对象，默认生效的是SimpleCacheConfiguration查看该类发现该类型向容器中注入了一个ConcurrentMapCacheManager的缓存CacheManager，查看该类主要实现了CacheManager接口中的getCache()，方法返回Cache对象，在ConcurrentMapCacheManager中重写了该方法并返回一个ConcurrentMapCache对象来对Cache进行操作，在该ConcurrentMapCache中使用ConcurrentMap来存放Cache。

debug查看@Cacheable注解的运行流程如下：

  1. 方法运行之前，先去查询ConcurrentMapCache（缓存组件），根据cacheNames来获取Cache对象，由于第一次获取Cache组件还没有创建，此时Cache会自动创建，之后会去Cache中使用一个key（默认就是方法的参数），去缓存中查找，没有查到缓存就调用目标方法，并将目标方法返回的结果，放进缓存中。
  2. key默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key，生成策略如下：
    • 如果没有参数：key=new SimpleKey()；
    • 如果有一个参数：key=参数的值
    • 如果有多个参数：key=new SimpleKey(params)；

总结：@Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据，核心组件为ConcurrentMapCacheManager和ConcurrentMapCache。

1.6 整合redis实现缓存

  1. 导入Redis依赖后默认的CacheManager为RedisCacheManager，之后就使用Redis来作为缓存工具

     <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

<dependencies>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--druid数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!--mybatis 依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>
        <!--缓存依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
    </dependencies>

  2. yml配置Redis的连接信息

    spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///ssm?serverTimezone=UTC
    username: root
    password: root
  redis:
    host: 127.0.0.1
    port: 6379

mybatis:
  configuration:
    #    开启mybatis-plus的驼峰命名
    map-underscore-to-camel-case: true
    #    开启sql打印
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
debug: true

  3. 默认RedisTemplate保存对象时使用jdk序列化机制来将对象序列化后保存到Redis中，这时去Redis中查看对象为乱码的格式，可以在容器中注入自定义的RedisTemplate使用json方法来序列化对象，方式如下，乱码如图：
    在这里插入图片描述

    • 对象实现序列化接口
    @Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee implements Serializable {
    private Integer id;
    private String lastName;
    private String email;
    private Integer gender;
    private Integer dId;
}

//------------------------------------------------

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Department implements Serializable {
    private Integer id;
    private String departmentName;
}
    • 配置序列化为json的自定义RedisTemplate对象并注入容器中
    @Configuration
public class MyRedisConfig {

    //Employee的Redis序列化器
    @Bean("empRedisTemplate")
    public RedisTemplate<Object, Employee> empRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Employee> template = new RedisTemplate<>();
        Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        //根据源码查看可以自定义设置默认的序列化器，参考源码配置
        template.setDefaultSerializer(serializer);
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    //Department的Redis序列化器
    @Bean("deptRedisTemplate")
    public RedisTemplate<Object, Department> deptRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Department> template = new RedisTemplate<>();
        Jackson2JsonRedisSerializer<Department> serializer = new Jackson2JsonRedisSerializer<Department>(Department.class);
        //根据源码查看可以自定义设置默认的序列化器
        template.setDefaultSerializer(serializer);
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}
    • 测试
    @SpringBootTest
class SpringbootCacheApplicationTests {

    @Autowired
    EmployeeService employeeService;

    @Autowired
    DeptService deptService;

    /**
     * 操作k-v都为object
     */
    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 操作k-v都为字符串
     */
    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @Autowired
    RedisTemplate<Object, Employee> employeeRedisTemplate;

    @Autowired
    RedisTemplate<Object, Department> departmentRedisTemplate;

    /**
	 * Redis常见的五大数据类型
	 *  String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合）
	 *  stringRedisTemplate.opsForValue()[String（字符串）]
	 *  stringRedisTemplate.opsForList()[List（列表）]
	 *  stringRedisTemplate.opsForSet()[Set（集合）]
	 *  stringRedisTemplate.opsForHash()[Hash（散列）]
	 *  stringRedisTemplate.opsForZSet()[ZSet（有序集合）]
	 */
    @Test
    void contextLoads2() {
        Employee employee = employeeService.getEmployeeById(2);
        employeeRedisTemplate.opsForValue().set("emp-01",employee);
        System.out.println(employeeRedisTemplate.opsForValue().get("emp-01"));
        Department department = deptService.getDepartmentById(1);
        departmentRedisTemplate.opsForValue().set("dept-01",department);
        System.out.println(departmentRedisTemplate.opsForValue().get("dept-01"));
    }

}

在这里插入图片描述

  1. 使用RedisCacheManager缓存数据时，RedisCacheManager内部使用jdk的序列化方法进行缓存，所以在redis中会出入之前的乱码，这时可以自定义配置RedisCacheManager，配置如下：

    @Configuration
public class MyRedisConfig {

    //Employee的Redis序列化器
    @Bean
    public RedisTemplate<Object, Employee> empRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Employee> template = new RedisTemplate<>();
        Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        //根据源码查看可以自定义设置默认的序列化器
        template.setDefaultSerializer(serializer);
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }


    //Department的Redis序列化器
    @Bean
    public RedisTemplate<Object, Department> deptRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Department> template = new RedisTemplate<>();
        Jackson2JsonRedisSerializer<Department> serializer = new Jackson2JsonRedisSerializer<Department>(Department.class);
        //根据源码查看可以自定义设置默认的序列化器
        template.setDefaultSerializer(serializer);
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    /**
     * 默认的序列化器
     * 有多个序列化器是要使用@Primay指定一个默认的序列化器
     * 要使用指定的序列化器是要在其缓存注解上面配置
     * @param redisConnectionFactory
     * @return
     */
    @Primary
    @Bean
    public RedisCacheManager defaultRedisCacheManager(RedisConnectionFactory redisConnectionFactory){
        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
                        //配置对key的序列化，这里使用string来序列化
                        .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                        //配置对value的序列化，使用jsong来序列化
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                        //不保存null值的缓存
                        .disableCachingNullValues()
                        //设置key的前缀 默认为： prefix + cache name + "::" + cache entry key
                        .prefixCacheNameWith("->");

        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                //配置RedisCacheManager的相关配置信息并将缓存中的内容和spring中的事务同步
                .cacheDefaults(configuration).transactionAware().build();

        return cacheManager;
    }

    /**
     * 针对于Employee序列化的RedisCacheManager
     * @Bean 默认使用方法名作为bean的id
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisCacheManager empRedisCacheManager(RedisConnectionFactory redisConnectionFactory){
        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
                //配置对key的序列化，这里使用string来序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                //配置对value的序列化，使用jsong来序列化
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<Employee>(Employee.class)))
                //不保存null值的缓存
                .disableCachingNullValues()
                //设置key的前缀 默认为： prefix + cache name + "::" + cache entry key
                .prefixCacheNameWith("->");

        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                //配置RedisCacheManager的相关配置信息并将缓存中的内容和spring中的事务同步
                .cacheDefaults(configuration).transactionAware().build();

        return cacheManager;
    }

    /**
     * 针对于Department序列化的RedisCacheManager
     * @Bean 默认使用方法名作为bean的id
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisCacheManager deptRedisCacheManager(RedisConnectionFactory redisConnectionFactory){
        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
                //配置对key的序列化，这里使用string来序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                //配置对value的序列化，使用jsong来序列化
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<Department>(Department.class)))
                //不保存null值的缓存
                .disableCachingNullValues()
                //设置key的前缀 默认为： prefix + cache name + "::" + cache entry key
                .prefixCacheNameWith("->");

        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                //配置RedisCacheManager的相关配置信息并将缓存中的内容和spring中的事务同步
                .cacheDefaults(configuration).transactionAware().build();

        return cacheManager;
    }

}

  2. 应用自定义配置的RedisCacheManager于缓存注解上面

    @CacheConfig(cacheNames = "dept",cacheManager = "deptRedisCacheManager")
@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    DeptMapper deptMapper;

    @Cacheable
    @Override
    public Department getDepartmentById(Integer id) {
        return deptMapper.getDepartmentById(id);
    }
}

  3. 也可以编码方式使用缓存

    @Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    DeptMapper deptMapper;

    @Autowired
    @Qualifier("deptRedisCacheManager")
    RedisCacheManager redisCacheManager;

    @Override
    public Department getDepartmentById(Integer id) {
        Department department = deptMapper.getDepartmentById(id);
        Cache deptCache = redisCacheManager.getCache("dept");
        deptCache.put("->dept:" + id, department);
        return department;
    }
}

  4. redis数据如下：

在这里插入图片描述
spring-cache官网文档

流风川
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SpringBoot整合J2Cache
大军的博客
03-28 2245
SpringBoot整合J2Cache
SpringBoot中注解缓存@Cacheable
qq_38845271的博客
06-26 4380
SpringBoot中注解缓存 @Cacheable 及控制台展示 执行 SQL 查看是否缓存成功 SpringBoot 的maven的项目中，首先在 pom.xml文件中 注入 Spring Boot 缓存支持启动器 及 Ehcache 坐标 <dependency> <groupId>org.springframework.boot</grou...
Spring boot Cache
生命不息，奋斗不止
11-15 4368
spring boot 缓存
springboot整合springcache(数据库redis)
suqinyi的博客
05-28 1698
系列文章目录 文章目录系列文章目录一、说明：二、原理梳理2.1、 比较重要的源码类2.2、 原理说明：三、默认缓存的数据类型四、整合4.1、引入依赖4.2、先看下配置源码是怎么样的4.3、创建配置类（照猫画虎）4.4、配置文件（application.properties）4.5、使用4.5.1、@Cacheable(开启缓存功能)4.5.2、@CacheEvict（失效模式）4.5.3、@Caching（组合使用）4.5.4、@CachePut（双写模式）4.5.5、redisTemplate获取数据方法
springboot中的缓存介绍之cache
最新发布
qq_37741426的博客
05-28 923
springboot中的缓存介绍之cache
SpringBoot之缓存篇
热门推荐
ToBeMaybe_的博客
09-05 1万+
SpringBoot缓存
springboot缓存——Cache
Mr_likes的博客
06-20 2103
Cache是一个类似Map的数据结构，并临时存储以Key为索引的值。其中常用的几个注解：@EnableCaching：开启基于缓存的注解 加载启动类上。@Cacheable：作用于查询
Springboot—Spring Cache 缓存方案详解及代码-Ehcache
深圳市多克创新科技有限公司
10-16 6462
java 缓存详解及代码
springboot整合cache
07-30
springboot整合cache，利用springboot默认的缓存技术，添加两个注解搞定一切。让你进一步的更快去使用缓存，持久层使用的mybatis，对springboot整合mybatis不熟悉的也可以借鉴
Springboot整合GuavaCache缓存过程解析
08-25
SpringBoot整合GuavaCache缓存过程解析 SpringBoot是一款流行的Java框架，提供了许多便捷的功能来简化开发过程。其中，缓存机制是SpringBoot中的一个重要组件，可以帮助提高应用程序的性能和响应速度。GuavaCache是...
springboot整合jetcache完整代码
07-22
本文将详细介绍如何在SpringBoot项目中整合JetCache，并探讨其本地缓存和Redis缓存的使用，以及如何实现多缓存的并行使用。 首先，整合SpringBoot和JetCache，你需要在项目的pom.xml文件中添加JetCache的依赖。Jet...
SpringBoot加入Guava Cache实现本地缓存代码实例
08-25
SpringBoot 中 Guava Cache 的应用 在本文中，我们将介绍如何在 SpringBoot 项目中使用 Guava Cache 实现本地缓存。Guava Cache 是一个高性能的缓存框架，由 Google 开发维护。它提供了一个灵活的缓存机制，可以...
springboot整合redis实例
03-06
为了更高效地使用Redis，还可以配置过期时间、利用Lua脚本执行批量操作、配合Spring Cache实现缓存等。在实际项目中，可以根据需求进行扩展和优化，例如使用`Redisson`客户端以获得更丰富的功能。在测试时，可以使用...
【SpringBoot高级篇】SpringBoot集成cache(LinkedHashMap)本地缓存
输入技术、输出想法
04-29 5852
SpringBoot整合cacheSpring Boot与缓存一、JSR107二、Spring缓存抽象三、几个重要概念&缓存注解搭建基本环境导入数据库文件 创建出employee表PomymljavaBean封装数据DepartmentEmployee整合MyBatis操作数据库DepartmentMapperEmployeeMapper业务逻辑DeptServiceEmployeeServicecontrollerDeptControllerEmployeeController启动类快速体验缓存不
SpringBoot 之 Cache
const_
08-06 541
文章目录1、缓存核心接口2、Spring缓存抽象3、SpringBoot缓存工作原理4、SpringBoot中Cache缓存的使用 1、缓存核心接口 Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。 CachingProvider定义了创建、配置、获取、管理和控制多个CacheManage...
【Spring系列】Spring Boot Cache
wenxueliu的博客
12-28 1001
Spring 3.1中引入了基于注解的Cache的支持，在spring-context包中定义了org.springframework.cache.CacheManager和org.springframework.cache.Cache接口，用来统一不同的缓存的技术。CacheManager是Spring提供的各种缓存技术管理的抽象接口，而Cache接口包含缓存的增加、删除、读取等常用操作。
Spring Cache入门
MengW9的博客
10-12 866
前言 今天这篇文章是比较偏“教程”一点的文章。但也由浅入深，认真地分析了源码，并且介绍了一些在使用Spring Cache中常见的问题和解决方案，肯定是比简单的入门文档更有深度一些的，相信大家看了之后会有一定的收获。 为什么使用缓存 前几天我在文章《我是如何把一个15分钟的程序优化到了10秒的》中，提到了一些在代码层面优化性能的方法。其中第一个就是使用缓存。 使用缓存是一个很“高性价比”...
Spring学习笔记（三十二）——SpringBoot中cache缓存的介绍和使用
不愿意做鱼的小鲸鱼の博客
10-21 3183
目录Spring Boot与缓存什么是cachejava cache：JSR107Spring缓存抽象redis和cache的使用场景和区别SpringBoot缓存的使用0. 开启缓存的注解：@EnableCaching1. 导入数据库文件2. 导入依赖3. 编写配置文件4. 创建javaBean封装类5. 编写dao层6. 编写service层7. 编写控制层8. 编写MyCacheConfig配置类（可选）测试结果整合redis注解缓存并设置时间 Spring Boot与缓存 什么是cache cach
localCache与集中式cache
redcreen的专栏
11-22 1312
使用memcache缓存数据,减少对数据库的直接访问,提高网站性能已经成了各大网站最基本的技术.如何更好的提高memcache缓存的利用率及命中次数会在后面的blog中单独介绍,本文主要探讨为何及如何使用本地缓存(java localcache)提高网站性能. localcache与memcache性能比较 先来个本地缓存与memcache缓存的性能比较,有个直观上的概念   Cache 请求方式
springboot整合cache缓存
03-16
Spring Boot可以很方便地整合缓存，常用的缓存框架有Ehcache、Redis、Guava等。在Spring Boot中，我们可以通过注解的方式来使用缓存，常用的注解有@Cacheable、@CachePut、@CacheEvict等。其中，@Cacheable用于查询缓存，如果缓存中有数据，则直接返回缓存中的数据，否则执行方法并将结果存入缓存；@CachePut用于更新缓存，每次都会执行方法并将结果存入缓存；@CacheEvict用于删除缓存，可以指定删除某个缓存或者清空所有缓存。在使用缓存时，需要先配置缓存管理器，然后在需要缓存的方法上添加相应的注解即可。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值