文章目录
源码地址：https://gitee.com/huanglei1111/springboot-demo/tree/master/springboot-ehcache
Springboot：整合redis对接口数据进行缓存
一、注解及其属性介绍
@Cacheable
- cacheNames：指定缓存的名称
@Cacheable({"menu", "menuById"})关联多个缓存名，当执行方法之前，这些关联的每一个缓存都会被检查，而且只要至少其中一个缓存命中了，那么这个缓存中的值就会被返回
-
key：定义组成的key值，如果不定义，则使用全部的参数计算一个key值。可以使用spring El表达式
-
keyGenerator：定义key生成的类，和key的不能同时存在
-
sync：如果设置sync=true：a. 如果缓存中没有数据，多个线程同时访问这个方法，则只有一个方法会执行到方法，其它方法需要等待; b. 如果缓存中已经有数据，则多个线程可以同时从缓存中获取数据
-
condition和unless 只满足特定条件才进行缓存：
1.condition: 在执行方法前，condition的值为true，则缓存数据
2.unless ：在执行方法后，判断unless ，如果值为true，则不缓存数据
3.conditon和unless可以同时使用，则此时只缓存同时满足两者的记录
@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
@CacheEvict
删除缓存
- allEntries = true: 清空缓存book1里的所有值
- allEntries = false: 默认值，此时只删除key对应的值
@CachePut
每次执行都会执行方法，无论缓存里是否有值，同时使用新的返回值的替换缓存中的值。这里不同@Cacheable：@Cacheable如果缓存没有值，从则执行方法并缓存数据，如果缓存有值，则从缓存中获取值
@CacheConfig
@CacheConfig: 类级别的注解：如果我们在此注解中定义cacheNames，则此类中的所有方法上 @Cacheable的cacheNames默认都是此值。当然@Cacheable也可以重定义cacheNames的值
二、代码实现
1.创建数据库
-- 判断数据表是否存在，存在则删除
DROP TABLE IF EXISTS tb_user;
-- 创建“用户信息”数据表
CREATE TABLE `tb_user` (
`user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户编号',
`user_name` varchar(50) NOT NULL COMMENT '用户名称',
`blog_url` varchar(50) NOT NULL COMMENT '博客地址',
`blog_remark` varchar(50) DEFAULT NULL COMMENT '博客备注',
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表';
-- 添加数据
INSERT INTO tb_user(user_name,blog_url,blog_remark) VALUES('拒绝熬夜啊的博客','https://blog.csdn.net/weixin_43296313/','您好，欢迎访问 拒绝熬夜啊的博客');
2.application.yaml配置问加你
#Spring配置
spring:
#缓存管理器
cache:
type: redis
#Redis配置
redis:
database: 0 #Redis数据库索引（默认为0）
host: 127.0.0.1 #Redis服务器地址
port: 6379 #Redis服务器连接端口
password: #Redis服务器连接密码（默认为空）
jedis:
pool:
max-active: 8 #连接池最大连接数（使用负值表示没有限制）
max-wait: -1s #连接池最大阻塞等待时间（使用负值表示没有限制）
max-idle: 8 #连接池中的最大空闲连接
min-idle: 0 #连接池中的最小空闲连接
lettuce:
shutdown-timeout: 100ms #关闭超时时间，默认值100ms
#使用Thymeleaf模板引擎
thymeleaf:
mode: HTML5
encoding: UTF-8
cache: false #使用Thymeleaf模板引擎，关闭缓存
servlet:
content-type: text/html
#DataSource数据源
datasource:
url: jdbc:mysql://localhost:3306/mybatis_test?useSSL=false&
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver
#MyBatis配置
mybatis:
type-aliases-package: com.hl.springbootehcache.pojo #别名定义
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #指定 MyBatis 所用日志的具体实现，未指定时将自动查找
map-underscore-to-camel-case: true #开启自动驼峰命名规则（camel case）映射
lazy-loading-enabled: true #开启延时加载开关
aggressive-lazy-loading: false #将积极加载改为消极加载（即按需加载）,默认值就是false
#lazy-load-trigger-methods: "" #阻挡不相干的操作触发，实现懒加载
cache-enabled: true #打开全局缓存开关（二级环境），默认值就是true
3.redisConfig.java配置类
package com.hl.springbootehcache.config;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
import java.lang.reflect.Method;
import java.time.Duration;
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
//配置redis的过期时间
private static final Duration TIME_TO_LIVE = Duration.ZERO;
@Bean(name = "jedisPoolConfig")
public JedisPoolConfig jedisPoolConfig() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
//控制一个pool可分配多少个jedis实例
jedisPoolConfig.setMaxTotal(500);
//最大空闲数
jedisPoolConfig.setMaxIdle(200);
//每次释放连接的最大数目，默认是3
jedisPoolConfig.setNumTestsPerEvictionRun(1024);
//逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);
//连接的最小空闲时间 默认1800000毫秒(30分钟)
jedisPoolConfig.setMinEvictableIdleTimeMillis(-1);
jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(10000);
//最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
jedisPoolConfig.setMaxWaitMillis(1500);
jedisPoolConfig.setTestOnBorrow(true);
jedisPoolConfig.setTestWhileIdle(true);
jedisPoolConfig.setTestOnReturn(false);
jedisPoolConfig.setJmxEnabled(true);
jedisPoolConfig.setBlockWhenExhausted(false);
return jedisPoolConfig;
}
@Bean("connectionFactory")
public JedisConnectionFactory connectionFactory() {
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName("127.0.0.1");
redisStandaloneConfiguration.setDatabase(0);
// redisStandaloneConfiguration.setPassword(RedisPassword.of("123456"));
redisStandaloneConfiguration.setPort(6379);
//获得默认的连接池构造器
JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
(JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
//指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！）
jpcb.poolConfig(jedisPoolConfig());
//通过构造器来构造jedis客户端配置
JedisClientConfiguration jedisClientConfiguration = jpcb.build();
//单机配置 + 客户端配置 = jedis连接工厂
return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
}
@Bean
public RedisTemplate<Object, Object> redisTemplate(JedisConnectionFactory connectionFactory) {
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(connectionFactory);
GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
//初始化参数和初始化工作
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
/**
* 缓存对象集合中，缓存是以key-value形式保存的,
* 当不指定缓存的key时，SpringBoot会使用keyGenerator生成Key。
*/
@Override
@Bean
public KeyGenerator keyGenerator() {
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
//类名+方法名
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};
}
/**
* 缓存管理器
* @param connectionFactory 连接工厂
* @return cacheManager
*/
@Bean
public CacheManager cacheManager(JedisConnectionFactory connectionFactory) {
//新建一个Jackson2JsonRedis的redis存储的序列化方式
GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
//解决查询缓存转换异常的问题
// 配置序列化（解决乱码的问题）
//entryTtl设置过期时间
//serializeValuesWith设置redis存储的序列化方式
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(TIME_TO_LIVE)
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
.disableCachingNullValues();
//定义要返回的redis缓存管理对象
return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).build();
}
}
4.UserInfo实体类
@Data
public class UserInfo implements Serializable {
private int userId; //用户编号
private String userName; //用户姓名
private String blogUrl; //博客地址
private String blogRemark; //博客信息
}
5.UserMapper.java
@Mapper
@Repository
public interface UserMapper {
/**
* 根据用户ID，获取用户信息
*/
@Select("SELECT * FROM tb_user WHERE user_id = #{userId}")
public UserInfo getUserById(int userId);
/**
* 新增用户，并获取自增主键
*/
@Insert("INSERT INTO tb_user(user_name,blog_url,blog_remark) VALUES(#{userName},#{blogUrl},#{blogRemark});")
@Options(useGeneratedKeys = true, keyColumn = "user_id", keyProperty = "userId")
public int insertUser(UserInfo userInfo);
/**
* 修改用户
*/
@Update("UPDATE tb_user SET user_name = #{userName},blog_url = #{blogUrl} ,blog_remark = #{blogRemark} WHERE user_id = #{userId}")
public int updateUser(UserInfo userInfo);
/**
* 删除用户
*/
@Delete("DELETE FROM tb_user WHERE user_id = #{userId}")
public int deleteUser(int userId);
}
6.Uservice及实现类
public interface UserService {
UserInfo getUserById(int userId);
UserInfo insertUser(UserInfo userInfo);
UserInfo updateUser(UserInfo userInfo);
int deleteUser(int userId);
}
/**
* 用户信息业务逻辑类
* @author hl
* 缓存就在这层工作
* @Cacheable，将查询结果缓存到redis中，（key="#p0"）指定传入的第一个参数作为redis的key。
* @CachePut，指定key，将更新的结果同步到redis中
* @CacheEvict，指定key，删除缓存数据，allEntries=true,方法调用后将立即清除缓存
**/
@CacheConfig(cacheNames = "userCache")
@Service
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = Exception.class)
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
/**
* 根据用户ID，获取用户信息
*/
@Override
@Cacheable(key = "#p0") // #p0 表示第一个参数
public UserInfo getUserById(int userId) {
return userMapper.getUserById(userId);
}
/**
* 新增用户，并获取自增主键
*/
@Override
@CachePut(key = "#p0.userId")
public UserInfo insertUser(UserInfo userInfo) {
userMapper.insertUser(userInfo);
return userInfo;
}
/**
* 修改用户
*/
@Override
@CachePut(key = "#p0.userId")
public UserInfo updateUser(UserInfo userInfo) {
userMapper.updateUser(userInfo);
return userInfo;
}
/**
* 删除用户
* 如果在@CacheEvict注解中添加allEntries=true属性，
* 将会删除所有的缓存
*/
@Override
@CacheEvict(key = "#p0")
public int deleteUser(int userId) {
return userMapper.deleteUser(userId);
}
}
7.UserController.java
@Controller
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
/**
* 获取用户信息
*/
@RequestMapping(value = "getUserById",method = RequestMethod.GET)
@ResponseBody
public HttpResponseTemp<?> getUserById(int userId) {
UserInfo userInfo = userService.getUserById(userId);
return ResultStat.OK.wrap(userInfo,"获取用户信息成功");
}
/**
* 新增用户
*/
@ResponseBody
@RequestMapping("insertUser")
public HttpResponseTemp<?> insertUser() {
//创建新用户
UserInfo userInfo = new UserInfo();
userInfo.setUserName("hl的博客");
userInfo.setBlogUrl("www.baidu.com");
userInfo.setBlogRemark("您好，欢迎访问 hl的博客");
UserInfo userInfo1 = userService.insertUser(userInfo);
return ResultStat.OK.wrap(userInfo1.getUserId(),"新增用户成功");
}
/**
* 修改用户
*/
@ResponseBody
@RequestMapping("updateUser")
public HttpResponseTemp<?> updateUser(int userId) {
UserInfo userInfo = new UserInfo();
userInfo.setUserId(userId);
userInfo.setUserName("hl的博客_02");
userInfo.setBlogUrl("www.baidu.com");
userInfo.setBlogRemark("您好，欢迎访问 hl的博客");
UserInfo userInfo1 = userService.updateUser(userInfo);
return ResultStat.OK.wrap(userInfo1.getUserId(),"修改用户成功");
}
/**
* 删除用户
*/
@ResponseBody
@RequestMapping("deleteUser")
public HttpResponseTemp<?> deleteUser(int userId) {
int result = userService.deleteUser(userId);
return ResultStat.OK.wrap(result,"删除用户成功");
}
}
8.注意
- 实体类要实现序列化
public class UserInfo implements Serializable - 在项目启动类加上注解
@EnableCaching开启缓存
三、测试
1.测试查询
redis中也有数据了
查看控制台的sql语句，只有一条打印，说明是只有第一条是从数据库中查询的其他的是从redis中获取的
2.测试新增
3.测试修改
这里博客名称变成02了
4.测试删除
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
