springboot对redis的使用

之前一直对redis不太感冒，只会用，不知道在项目怎么整合的，本周就整理下redis

• pom文件中引用jar包

  <!--redis依赖配置-->
  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

• yml文件配置

  redis:
    host: localhost # Redis服务器地址
    database: 0 # Redis数据库索引（默认为0）
    port: 6379 # Redis服务器连接端口
    password: # Redis服务器连接密码（默认为空）
    timeout: 300ms # 连接超时时间（毫秒）

• redis配置类：RedisConfig.java

package com.pt.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * Redis配置类
 * Created by pt on 2020/6/10.
 */
@Configuration //定义配置类
@EnableCaching //驱动缓存管理;在配置类中使用该注解，会触发一个后置处理器，找已经存在注解对应的缓存。如果找到了，就会自动创建一个代理拦截方法调用，使用缓存的bean执行处理。
//CachingConfigurerSupport 使用Redis实现缓存自定义缓存读写机制
public class RedisConfig extends CachingConfigurerSupport {

    @Bean  //初始化Spring容器 -- 定义redis“模板”
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    //RedisConnectionFactory:Redis连接的线程安全工厂
   		//RedisSerializer:对象到字节数组(二进制数据)的基本接口序列化和反序列化。建议实现的目的是在序列化和反序列化方面处理空对象/空数组。请注意Redis不接受空键或值，但可以返回空应答(对于不存在的键)。
        RedisSerializer<Object> redisSerializer = redisSerializer();
        //String类型序列化。注意：这种String序列化的value值只能是String字符串形式，其他形式会无法保存 
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //RedisTemplate:简化Redis数据访问代码的Helper类
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);//连接工厂
         //下面几种序列化都是类似的.另:如果不做序列化处理，在这些值之前会出现一些乱码
        redisTemplate.setKeySerializer(stringRedisSerializer );
        redisTemplate.setValueSerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(redisSerializer);
        //afterPropertiesSet:作用--初始化工作
        redisTemplate.afterPropertiesSet();//如果不加，这里如果不是spring注入使用RedisTemplate，会有异常
        return redisTemplate;
    }

    @Bean //初始化Spring容器--自定义序列化器
    public RedisSerializer<Object> redisSerializer() {
        //替换默认序列化(默认采用的是JDK序列化)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer= new Jackson2JsonRedisSerializer<>(Object.class);
        //ObjectMapper:提供读取和写入JSON的功能往返于基本pojo(普通的旧Java对象)或往返于一个通用的JSON树模型,以及执行转换的相关功能.它还具有高度的可定制性,可以同时使用不同风格的JSON内容,并支持更高级的对象概念,如多态性和对象标识.有兴趣的童鞋可以去ObjectMapper源码去瞅眼---
        ObjectMapper objectMapper = new ObjectMapper();
        //更改配置。PropertyAccessor:"属性访问器"/ALL-此伪类型表示所有访问器都受到影响
        //JsonAutoDetect.Visibility.ANY:表示所有的访问修饰符都可以接受
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //用于启用自动包含类型信息的方法，需要对于多态类型的正确反序列化
        //ObjectMapper.DefaultTyping.NON_FINAL:非最终类型
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //设置序列化
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        return jackson2JsonRedisSerializer;
    }

    @Bean //初始化Spring容器--redis缓存管理
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        //RedisCacheWriter:用于提供对Redis命令
        //nonLockingRedisCacheWriter():创建新的RedisCacheWriter而不锁定行为。
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
        //设置Redis缓存有效期为1天
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(Duration.ofDays(1));
        return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
    }
}

• redis的同一管理

这里只介绍它的实现，service层略

package com.pt.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis操作实现类
 * Created by pt on 2020/6/10.
 */
@Service
public class RedisServiceImpl {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;//会调用我们工程里面定义的redisTemplate

	/***************************opsForValue*****************************/
    public void set(String key, Object value) {
    	//基本的新增一个字符串类型的值，key是键，value是值
        redisTemplate.opsForValue().set(key, value);
    }

    public Object get(String key) {
    	//获取key键对应的值
        return redisTemplate.opsForValue().get(key);
    }
 
    public Object getAndSet(String key, String value) {
    	//获取原来key键对应的值并重新赋新值
        return redisTemplate.opsForValue().getAndSet(String key, String value);
    }
    
    public Object get(String key, long start, long end) {
    	//截取key键对应值得字符串
        return redisTemplate.opsForValue().get(String key, long start, long end);
    }
    
    public Object size(String key) {
    	//获取key键对应字符串长度
        return redisTemplate.opsForValue().size(String key);
    }
    
    public Object append(String key, String value) {
    	//对应的key值，在value值基础上新增字符串到末尾
        return redisTemplate.opsForValue().append(String key, String value);
    }

    public void set(String key, Object value, long time) {
    	//设置变量值的过期时间  TimeUnit.SECONDS:表示一秒的时间单位
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }

    public Object setIfAbsent(String key, String value) {
    	//首先判断键值是否存在，不存在，就新建;若不存在。就不改变key以及value
        return redisTemplate.opsForValue().setIfAbsent(String key, String value);
    }

    public Long incrementIncr(String key, long delta) {
    	//按delta递增 以增量的方式将long值存储在变量中
        return redisTemplate.opsForValue().increment(key, delta);
    }

    public Long incrementDecr(String key, long delta) {
    	//按delta递增
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    
    public Long multiSet(Map<Object> map) {
    	//设置map集合到redis,提供的键值对将多个键设置为多个值
        return redisTemplate.opsForValue().multiSet(map);
    }
    
    public Long multiGet(Collection<Object> collection) {
    	//值按请求的键的顺序返回
        return redisTemplate.opsForValue().multiGet(collection);
    }
	/****************************************************************/
    public Boolean del(String key) {
    	//通过字面就可以看出，这个是通过key键来删除的，单个
        return redisTemplate.delete(key);
    }

    public Long del(List<String> keys) {
    	//这个是通过一个list集合(key值的集合)，来进行同一的删除的，注意返回值
        return redisTemplate.delete(keys);
    }

    public Boolean expire(String key, long time) {
    	//重新设置过期时间为30分钟，刷新时间
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    public Long getExpire(String key) {
   		 //通过key值获取过期时间
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    public Boolean hasKey(String key) {
    	//判断是否有key所对应的值，有则返回true，没有则返回false
        return redisTemplate.hasKey(key);
    }
    
	/***************************opsForHash*****************************/
    public Object hashGet(String key, Object hashKey) {
    	//获取变量中的指定键是否有值,如果存在该键则获取值，没有则返回null.注意这里的hashKey是Object类型的，也就是说，Map,List,,,,都是可以的
        return redisTemplate.opsForHash().get(key, hashKey);
    }
    
    public void hashPut(String key, String hashKey, Object value) {
    	//新增Object类型数据,和上面的是一起用的,这里是新增
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    public Map<Object, Object> hashEntries(String key) {
    	//通过键来获取变量中的键和值
        return redisTemplate.opsForHash().entries(key);
    }

    public void hSetAll(String key, Map<String, Object> map) {
    	//使用提供的数据将多个哈希字段设置为多个值，也就是说以map的形式来进行新增key,value，同时新增多条
        redisTemplate.opsForHash().putAll(key, map);
    }

    public void hashDelete(String key, Object... hashKey) {
    	//删除变量中的键值对，可以传入多个参数，删除多个键值对。	
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    public Boolean hHasKey(String key, Object hashKey) {
    	//判断变量中是否有指定的键 
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    public Long hashIncr(String key, String hashKey, Long delta) {
    	//使变量中的键以long值的大小进行自增长.这里还有一种以double的形式，有兴趣的小伙伴可以去看下
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }

	/***************************opsForSet*****************************/
    public Set<Object> forSetMembers(String key) {
    	//获取变量中的值.
        return redisTemplate.opsForSet().members(key);
    }

    public Long forSetAdd(String key, Object... values) {
    	//向变量中批量添加值
        return redisTemplate.opsForSet().add(key, values);
    }

    public Boolean forSetIsMember(String key, Object value) {
    	//检查给定的元素是否在变量中(单元素是否于多元素里面)
        return redisTemplate.opsForSet().isMember(key, value);
    }

    public Long forSetSize(String key) {
    	//返回变量中值的长度
        return redisTemplate.opsForSet().size(key);
    }

    public Long forSetRemove(String key, Object... values) {
    	//移除key值中对应的values元素值
        return redisTemplate.opsForSet().remove(key, values);
    }

	/***************************opsForList*****************************/
    public List<Object> forListRange(String key, long start, long end) {
    	//获取指定区间的值
        return redisTemplate.opsForList().range(key, start, end);
    }

    public Long forListSize(String key) {
    	//获取集合长度
        return redisTemplate.opsForList().size(key);
    }

    public Object forListIndex(String key, long index) {
    	//获取集合指定位置的值
        return redisTemplate.opsForList().index(key, index);
    }

    public Long lPush(String key, Object value) {
    	//向value最右边添加元素
        return redisTemplate.opsForList().rightPush(key, value);
    }

    public Long forListPushAll(String key, Object... values) {
    	//向右边批量添加元素
        return redisTemplate.opsForList().rightPushAll(key, values);
    }

    public Long forListRemove(String key, long count, Object value) {
    	//从存储在键中的列表中删除等于值的元素的第一个计数事件.count> 0:删除等于从左到右移动的值的第一个元素;count< 0：删除等于从右到左移动的值的第一个元素;count = 0:删除等于value的所有元素。
        return redisTemplate.opsForList().remove(key, count, value);
    }
}

上边这个类都是项目中常用的方法，redisTemplate中还有其他的方法没有写到，有兴趣的童鞋可以去研究下

-------------------------------------------------这是一条分割线----------------------------------------------------------------

redis的切面 —TODO待补充

/**
 * Redis缓存切面，防止Redis宕机影响正常业务逻辑
 * Created by pt on 2020/6/10.
 */
@Aspect     //切面
@Component  //此类放在Spring容器里
@Order(2)   //单个方法被多个Aspect方法拦截的顺序问题，order注解可以解决，值越小，优先级越高
public class RedisAspect {

	//调用controller包下的任意类的任意方法时均会调用此方法
    @Around("execution(* com.pt.controller.*.*(..))") 
    public Object runAspect(ProceedingJoinPoint joinPoint) throws Throwable {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        Object result = joinPoint.proceed();
    }
}