spring @Cacheable @CachePut... 使用redis缓存详细步骤

2024-08-26 09:18
文章标签 java 使用 步骤 redis spring 详细 缓存 cacheable cacheput

本文主要是介绍spring @Cacheable @CachePut... 使用redis缓存详细步骤，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

spring @Cacheable @CachePut... 使用redis缓存详细步骤

本文以一个spring的maven工程，整理记录使用注解缓存的问题，基本不需要自己写过多的封装的代码，很多人都实现Cache接口重新定义自己的缓存操作。其实不用也可以，Spring已经做了很多了。

预期目标

  • 查询：如果缓存中存在，直接从缓存中取，不查数据库。如果缓存中没有，从数据库查询并存入缓存，并设置超时时间。

  • 修改：删除缓存中的内容（如果存在）。

  • 删除：同步删除缓存中的内容。

实现步骤

  • pom，只列举关键部分，详细部分可以通过https://download.csdn.net/download/u013041642/10423952下载源码

    <dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-redis</artifactId>
  <version>1.6.0.RELEASE</version>
</dependency>
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.8.1</version>
</dependency>

  • web.xml

    <!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
​
<web-app>
  <display-name>Archetype Created Web Application</display-name>
​
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mybatis.xml, classpath:spring-cache.xml</param-value>
  </context-param>
​
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
​
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
​
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
​
</web-app>

  • spring-mvc.xml

    <context:component-scan base-package="com.susq.work.*" >
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
</context:component-scan>
​
<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

  • config.properties

    ## mysql
database.url=jdbc:mysql://127.0.0.1/credit?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&rewriteBatchedStatements=true
database.username=root
database.password=
database.driverClass=com.mysql.jdbc.Driver
​
## redis
redis.host=127.0.0.1
redis.port=6379
redis.password=foobared
redis.timeout=60000
redis.database=0
redis.pool.maxActive=300
redis.pool.maxIdle=100
redis.pool.maxWait=2000

  • spring-mybatis.xml

    <context:property-placeholder location="classpath:config.properties"/>
​
<context:component-scan base-package="com.susq.work.*">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
​
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource_user"/>
</bean>
​
<tx:annotation-driven transaction-manager="transactionManager" />
​
<bean id="dataSource_user" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${database.driverClass}"/>
    <property name="url" value="${database.url}"/>
    <property name="username" value="${database.username}"/>
    <property name="password" value="${database.password}"/>
</bean>
​
<bean id="userSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource_user"/>
    <property name="configLocation" value="classpath:sqlMapConfig.xml"/>
    <property name="mapperLocations" value="classpath*:com/susq/work/dao/mapper/UserMapper.xml"/>
</bean>
​
<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="sqlSessionFactoryBeanName" value="userSqlSessionFactory"/>
    <property name="basePackage" value="com.susq.work.dao"/>
</bean>

  • spring-cache.xml

    <context:property-placeholder location="classpath:config.properties" />
​
<cache:annotation-driven cache-manager="cacheManager"/>
​
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxTotal" value="${redis.pool.maxActive}" />
    <property name="maxIdle" value="${redis.pool.maxIdle}" />
    <property name="maxWaitMillis" value="${redis.pool.maxWait}" />
    <property name="testOnBorrow" value="false" />
    <property name="testOnReturn" value="false" />
</bean>
​
<bean id="connectionFactory"
      class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    <property name="hostName" value="${redis.host}"/>
    <property name="port" value="${redis.port}"/>
    <property name="password" value="${redis.password}" />
    <property name="timeout" value="${redis.timeout}"/>
    <property name="database" value="${redis.database}"/>
    <property name="poolConfig" ref="jedisPoolConfig"/>
</bean>
​
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <property name="connectionFactory"   ref="connectionFactory" />
    <property name="keySerializer" ref="keySerializer"/>  <!-- key使用String序列化方式 -->
    <property name="hashKeySerializer" ref="keySerializer"/> <!-- value使用String序列化 -->
    <property name="valueSerializer" ref="jackson2JsonRedisSerializer"/> <!-- value使用json序列化 -->
    <!--<property name="hashValueSerializer" ref="jackson2JsonRedisSerializer"/>-->
    <property name="hashValueSerializer" ref="jdkSerializer"/>
</bean>
​
<bean id="keySerializer"
      class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
<bean id="jackson2JsonRedisSerializer"
      class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
<bean id="jdkSerializer"
      class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
<!-- spring自己的缓存管理器，这里定义了缓存位置名称 ，即注解中的value -->
<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
    <property name="caches">
        <set>
            <!-- 这里可以配置多个cache; 不同名称的缓存可以设置前缀用来区分缓存的类型，设置不同的超时时间或是redisTemplate，StringRedisTemplate -->
            <bean class="org.springframework.data.redis.cache.RedisCache">
                <constructor-arg name="redisOperations" ref="redisTemplate"/>
                <constructor-arg name="name" value="common"/>
                <constructor-arg name="prefix" value=""/>
                <constructor-arg name="expiration" value="10" />
            </bean>
            <bean class="org.springframework.data.redis.cache.RedisCache">
                <constructor-arg name="redisOperations" ref="redisTemplate"/>
                <constructor-arg name="name" value="default"/>
                <constructor-arg name="prefix" value="DEF:"/> <!--这是通用的前缀-->
                <constructor-arg name="expiration" value="60"/> <!--这里的单位是秒-->
            </bean>
        </set>
    </property>
</bean>

  • service实现类, 在对应的方法上加上注解

    @Cacheable 调用方法时， 返回结果作为value放入缓存

    @CachePut 调用方法时 方法入参作为value 放入缓存

    @CacheEvict 调用方法是 从缓存中删除key 指定的数据

    condition 方法调用前判断，满足时，存入缓存， condition 默认为“”

    unless 方法调用后判断，满足时，不存 unless 默认为 “”

    这里的spel 表达式中，#result 代表返回值， 比如第一个selectByPrimaryKey接口上的#result就代表返回的user实例。

    package com.susq.work.service.impl;
​
import com.susq.work.dao.UserMapper;
import com.susq.work.model.User;
import com.susq.work.service.UserService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
​
import javax.annotation.Resource;
​
/**
 * @author susq
 * @since 2018-01-09-16:56
 */
@Service("userService")
public class UserServiceImpl implements UserService {
​
    @Resource
    private UserMapper userMapper;
​
    @Override
    @Cacheable(cacheNames = "common", key = "#id", unless = "#result != null")
    public User selectByPrimaryKey(String id) {
        return userMapper.selectByPrimaryKey(id);
    }
​
    @CachePut(value = "common", key = "#user.getId()")
    public User save(User user) {
        userMapper.saveUser(user);
        return user;
    }
​
    @CachePut(value = "common", key = "#user.getId()")
    public User update(User user) {
        userMapper.updateBySelective(user);
        return user;
    }
​
    @Override
    @CacheEvict(value = "common", key = "#id")
    public void delete(String id) {
        userMapper.delete(id);
    }
}

结果展示

  • 写了个Controller 测一测，单元测试也可以

    package com.susq.work.controller;
​
import com.susq.work.model.User;
import com.susq.work.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
​
/**
 * @author susq
 * @since 2018-05-03-19:04
 */
@RestController
@Slf4j
@RequestMapping(value = "/mybatis")
public class MybatisController {
​
    @Resource
    private UserService userService;
​
    @RequestMapping(value = "/get")
    public User getUser(@RequestParam String id) {
        User user = userService.selectByPrimaryKey(id);
        log.info("my log " + user);
        return user;
    }
​
    @RequestMapping(value = "/save")
    public Map<String, String> saveUser(@RequestBody User user) {
        userService.save(user);
        Map<String, String> result = new HashMap<>();
        result.put("success", "00000000");
        return result;
    }
​
    @RequestMapping(value = "/update")
    public void updateUser(@RequestBody User user) {
        userService.update(user);
    }
​
    @RequestMapping(value = "/delete")
    public Map<String, String> deleteUser(@RequestParam String id) {
        userService.delete(id);
        Map<String, String> result = new HashMap<>();
        result.put("success", "00000000");
        return result;
    }
}

  • 调两次get接口，可以看到日志如下, 第一次查询的时候，缓存中还没有，直接从数据库中查的，后面再请求就是从redis拿了。但是common缓存我配置的超时时间是10秒，10秒过后，再请求又会查一次数据库放入缓存了。

    2018-05-18 21:52:35.405 DEBUG [http-nio-8090-exec-1]com.susq.work.dao.UserMapper.selectByPrimaryKey.debug:132 -==>  Preparing: select id, name, address from user where id = ? 
2018-05-18 21:52:35.468 DEBUG [http-nio-8090-exec-1]com.susq.work.dao.UserMapper.selectByPrimaryKey.debug:132 -==> Parameters: 1(String)
2018-05-18 21:52:35.493 DEBUG [http-nio-8090-exec-1]com.susq.work.dao.UserMapper.selectByPrimaryKey.debug:132 -<==      Total: 1
2018-05-18 21:52:35.794 INFO  [http-nio-8090-exec-1]com.susq.work.controller.MybatisController.getUser:30 -my log User(id=1, name=tingsuby, address=中国)
2018-05-18 21:52:38.797 INFO  [http-nio-8090-exec-3]com.susq.work.controller.MybatisController.getUser:30 -my log User(id=1, name=tingsuby, address=中国)

  • 也可以运行redis终端，请求一次get, 会看到我们的缓存已经加进去了，并且带着我们配置的前缀COMMON:


    上面 配置的 valueSerializer 是GenericJackson2JsonRedisSerializer ， 所以get 以后基本我们能看到我们存进去的原始信息，虽然汉字不能正常显示，起码比JdkSerializationRedisSerializer 辨识度好多了。

一些问题

  • @Cacheable注解不起作用

    人们都说缓存的配置文件，要在spring的主配置文件中才生效，放在<context-param> 里面不起作用，我就直接在 spring-mvc.xml 中 import resouce 引入了spring-cache的配置文件，发现根本无卵用。除非在springMVC容器扫描的时候，扫描除Controller外所有的Bean 才起作用。但是SpringMVC 的容器我们只是放Controller 的Bean的，其余的Bean应该加载在Spring 主容器中，所以这样做并不好。 于是我试了一下放在web.xml 的 <context-param> 节点中时可以的。而且如果有多个文件，加载的顺序并不重要，例如

     <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mybatis.xml, classpath:spring-cache.xml</param-value>
  </context-param>

    或者

     <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-cache.xml, classpath:spring-mybatis.xml</param-value>
  </context-param>

    都是可以的。

这篇关于spring @Cacheable @CachePut... 使用redis缓存详细步骤的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1108162。

相关文章

springboot健康检查监控全过程

springboot健康检查监控全过程

《springboot健康检查监控全过程》文章介绍了SpringBoot如何使用Actuator和Micrometer进行健康检查和监控,通过配置和自定义健康指示器,开发者可以实时监控应用组件的状态,... 目录1. 引言重要性2. 配置Spring Boot ActuatorSpring Boot Act
阅读更多...
使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)

使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)

《使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)》在现代软件开发中,处理JSON数据是一项非常常见的任务,无论是从API接口获取数据,还是将数据存储为JSON格式,解析... 目录1. 背景介绍1.1 jsON简介1.2 实际案例2. 准备工作2.1 环境搭建2.1.1 添加
阅读更多...
Java实现任务管理器性能网络监控数据的方法详解

Java实现任务管理器性能网络监控数据的方法详解

《Java实现任务管理器性能网络监控数据的方法详解》在现代操作系统中,任务管理器是一个非常重要的工具,用于监控和管理计算机的运行状态,包括CPU使用率、内存占用等,对于开发者和系统管理员来说,了解这些... 目录引言一、背景知识二、准备工作1. Maven依赖2. Gradle依赖三、代码实现四、代码详解五
阅读更多...
Redis连接失败：客户端IP不在白名单中的问题分析与解决方案

Redis连接失败：客户端IP不在白名单中的问题分析与解决方案

《Redis连接失败：客户端IP不在白名单中的问题分析与解决方案》在现代分布式系统中,Redis作为一种高性能的内存数据库,被广泛应用于缓存、消息队列、会话存储等场景,然而,在实际使用过程中,我们可能... 目录一、问题背景二、错误分析1. 错误信息解读2. 根本原因三、解决方案1. 将客户端IP添加到Re
阅读更多...
java如何分布式锁实现和选型

java如何分布式锁实现和选型

《java如何分布式锁实现和选型》文章介绍了分布式锁的重要性以及在分布式系统中常见的问题和需求,它详细阐述了如何使用分布式锁来确保数据的一致性和系统的高可用性,文章还提供了基于数据库、Redis和Zo... 目录引言：分布式锁的重要性与分布式系统中的常见问题和需求分布式锁的重要性分布式系统中常见的问题和需求
阅读更多...
SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

《SpringBoot基于MyBatis-Plus实现LambdaQuery查询的示例代码》MyBatis-Plus是MyBatis的增强工具,简化了数据库操作,并提高了开发效率,它提供了多种查询方... 目录引言基础环境配置依赖配置（Maven）application.yml 配置表结构设计demo_st
阅读更多...
如何使用celery进行异步处理和定时任务(django)

如何使用celery进行异步处理和定时任务(django)

《如何使用celery进行异步处理和定时任务(django)》文章介绍了Celery的基本概念、安装方法、如何使用Celery进行异步任务处理以及如何设置定时任务,通过Celery,可以在Web应用中... 目录一、celery的作用二、安装celery三、使用celery 异步执行任务四、使用celery
阅读更多...
使用Python绘制蛇年春节祝福艺术图

使用Python绘制蛇年春节祝福艺术图

《使用Python绘制蛇年春节祝福艺术图》：本文主要介绍如何使用Python的Matplotlib库绘制一幅富有创意的“蛇年有福”艺术图,这幅图结合了数字,蛇形,花朵等装饰,需要的可以参考下... 目录1. 绘图的基本概念2. 准备工作3. 实现代码解析3.1 设置绘图画布3.2 绘制数字“2025”3.3
阅读更多...
在Ubuntu上部署SpringBoot应用的操作步骤

在Ubuntu上部署SpringBoot应用的操作步骤

《在Ubuntu上部署SpringBoot应用的操作步骤》随着云计算和容器化技术的普及,Linux服务器已成为部署Web应用程序的主流平台之一,Java作为一种跨平台的编程语言,具有广泛的应用场景,本... 目录一、部署准备二、安装 Java 环境1. 安装 JDK2. 验证 Java 安装三、安装 mys
阅读更多...
Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

《Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单》：本文主要介绍Springboot的ThreadPoolTaskScheduler线... 目录ThreadPoolTaskScheduler线程池实现15分钟不操作自动取消订单概要1，创建订单后
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2