springboot+gradle整合redis

首先先大概介绍一下redis
Redis是一个高性能的key-value数据库。
Redis 与其他 key - value 缓存产品有以下三个特点：

• Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
• Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
• Redis支持数据的备份，即master-slave模式的数据备份。
  具体使用的话可查看文档，这边介绍几个常用的
  
  可以看下这篇博客https://www.cnblogs.com/yueshutong/p/9381540.html

一.引入依赖

compile('org.springframework.boot:spring-boot-starter-data-redis')

二.配置application.yml文件

spring:
  redis:
    host: 127.0.0.1
    database: 4
    port: 6379
    timeout: 10000
    jedis:
      pool:
        max-active:  8 #最大连接数
        max-wait: -1   #最大阻塞等待时间(负数表示没限制)
        max-idle: 8  #最大空闲
        min-idle: 0  #最小空闲

三.添加配置文件RedisConfig

RedisConfig

package com.config;
import java.lang.reflect.Method;
import java.time.Duration;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;


/**
 * Redis缓存配置类
 * @author lin29
 *
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    

    @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();
			}
		};
	}
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(timeout)); // 设置缓存有效期一小时
        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }
    
    @Bean
    @SuppressWarnings("rawtypes")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
    	// 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
		RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer); // key序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); // value序列化
        redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); // Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    
     @SuppressWarnings("unused")
	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);
     }
}

配置到这边就可以了，接下来测试以下

四.测试

需要注意的一点，要缓存的 Java 对象必须实现 Serializable 接口，因为 Spring 会将对象先序列化再存入 Redis
首先看以下目录结构

controller代码片段

@RestController
public class UserController {

	@Autowired
	private UserService service;
	
	@RequestMapping("/getUser/{id}")
	public User getUser(@PathVariable String id) {
		return service.getUser(id);
	}
}

service代码片段

@Service
public class UserService {
	
	@Autowired
	private UserDomain domain;
	
	public User getUser(String id) {
		return domain.findById(id);
	}

}

domain代码片段

@Component
@EnableCaching
@CacheConfig(cacheNames = "user")
public class UserDomain {

	@Autowired
	public UserDao dao;
	
	@Cacheable(value="id=", key="#id")
	public User findById(String id) {
		return dao.findById(id);
	}
	
}

dao代码片段

@Mapper
public interface UserDao extends BaseMapper<User>{

	User findById(String id);

}

xml文件

<select id="findById" resultType="com.entity.User" >
	select * from user
	where id = #{id}
</select>

运行后执行

然后打开redis客户端查看结果
db4中可看到结果已经缓存了

到这redis集成完成