SpringBoot 整合MyBatis 使用Radis做缓存

阳光穿透心脏的1/2处 2021-09-19 09:28 385阅读 0赞

# 项目目录结构 #

SpringBoot1.x代码地址： [GitHub: SpringBootRedisCache][GitHub_ SpringBootRedisCache]

SpringBoot2 .x 源码地址：https://gitee.com/bseaworkspace/springboot2all  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70][]

# POM #

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>bsea</groupId>
        <artifactId>SpringBootRedisCache</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.9.RELEASE</version>
            <relativePath/> 
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <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>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.38</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.2.0</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.46</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
    
        </dependencies>
        <repositories>
            <repository>
                <id>alimaven</id>
                <name>aliyun maven</name>
                <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            </repository>
        </repositories>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

# 运行结果： #

第一次运行，显示7000  
![在这里插入图片描述][20190511211243731.png]

直接修改数据库，改成9000  
![在这里插入图片描述][20190511211331128.png]

刷新浏览器以后，页面显示还是7000， 因为第二次没有去数据库查询，直接从缓存里面拿出结果。  
![在这里插入图片描述][20190511211402683.png]

# Redis可以看到缓存的key #

完整的key名字： “computer::1”，“computer::2” …  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]

# 关键代码 #

Radis配置类，其中配置了缓存过期时间。

## 把过期时间设置成20秒 ##

SpringBootRedisCache\\src\\main\\java\\com\\zz\\config\\RedisConfig.java

cacheManager.setDefaultExpiration(20);

20 秒以后刷新浏览器

# SpringBoot2 配置文件，有些不同 #

package com.zz.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.cache.RedisCacheWriter;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.time.Duration;
    
    @Configuration
    public class RedisConfig extends CachingConfigurerSupport {
    
    	// 自定义缓存key生成策略
    	@Bean
    	public KeyGenerator keyGenerator() {
    		return new KeyGenerator() {
    			@Override
    			public Object generate(Object target, java.lang.reflect.Method method, Object... params) {
    				StringBuffer sb = new StringBuffer();
    				sb.append(target.getClass().getName());
    				sb.append(method.getName());
    				for (Object obj : params) {
    					sb.append(obj.toString());
    				}
    				return sb.toString();
    			}
    		};
    	}
    
    	// 缓存管理器
    	@Bean
    	public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    		RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
    				.entryTtl(Duration.ofHours(1)); // 设置缓存有效期一小时
    		return RedisCacheManager
    				.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
    				.cacheDefaults(redisCacheConfiguration).build();
    	}
    
    	@Bean
    	@SuppressWarnings({"rawtypes", "unchecked"})
    	public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory connectionFactory){
    		RedisTemplate<Object,Object> redisTemplate=new RedisTemplate<>();
    		redisTemplate.setConnectionFactory(connectionFactory);
    		//使用Jackson2JsonRedisSerializer替换默认的序列化规则
    		Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
    		ObjectMapper objectMapper=new ObjectMapper();
    		objectMapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
    		objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    		jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    
    
    		//设置value的序列化规则
    		redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    		//设置key的序列化规则
    		redisTemplate.setKeySerializer(new StringRedisSerializer());
    		redisTemplate.afterPropertiesSet();
    		return redisTemplate;
    	}
    
    //	private void setSerializer(StringRedisTemplate template) {
    //		@SuppressWarnings({ "rawtypes", "unchecked" })
    //		Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    //		ObjectMapper om = new ObjectMapper();
    //		om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    //		om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    //		jackson2JsonRedisSerializer.setObjectMapper(om);
    //		template.setValueSerializer(jackson2JsonRedisSerializer);
    //	}
    }

# @Cacheable @CachePut @CacheEvict #

## 三个注解都是用在方法或者类上 ##

## @Cacheable 如果缓存里面有，就返回缓存里面的结果，没有，就去数据库里面查询。（一般用在查询的方法上面） ##

## @CachePut， 直接操作数据库， 并且数据库操作完成以后，更新缓存。（一般是用在修改的方法上面） ##

## @CacheEvict 删除缓存， 一般用在删除的方法上面。 ##

package com.zz.service;
    
    import com.zz.entity.Computer;
    import org.springframework.cache.annotation.CacheConfig;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.CachePut;
    import org.springframework.cache.annotation.Cacheable;
    
    @CacheConfig(cacheNames = "computer")
    public interface ComputerService {
        @CacheEvict(key = "#p0", allEntries = true)
        int deleteByPrimaryKey(Long id);
    
        int insert(Computer record);
    
        int insertSelective(Computer record);
        @Cacheable(key = "#p0")
        Computer selectByPrimaryKey(Long id);
        @CachePut(key = "#p0.sno")
        int updateByPrimaryKeySelective(Computer record);
    
        int updateByPrimaryKey(Computer record);
    }

[GitHub_ SpringBootRedisCache]: https://github.com/bseayin/springdemos/tree/master/SpringBootRedisCache
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70]: /images/20210726/4bbd180e885449e6b79efcf9a7214060.png
[20190511211243731.png]: /images/20210726/e42848adb03840cdab6707ce775a733e.png
[20190511211331128.png]: /images/20210726/ab7fc88a0e9341c89b5255e0d48e6857.png
[20190511211402683.png]: /images/20210726/8461d11cbb0044af828a9db99105d750.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]: /images/20210726/b58d9333340546ca9176b7bc791e6fb2.png