SpringBoot 集成 Redis的demo

SpringBoot 集成 Redis 示例

1.引入依赖

 		<!--    redis     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2.配置文件中添加Redis相关的配置

 	spring:
      #redis 配置
      redis:
        host: 127.0.0.1
        port: 6379
        password:
        #连接超时时间(毫秒)
        timeout: 36000ms
        # Redis默认情况下有16个分片，默认0
        database: 0
        lettuce:
          pool:
            # 连接池最大连接数（使用负值表示没有限制） 默认 8
            max-active: 8
            # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
            max-wait: -1ms
            # 连接池中的最大空闲连接 默认 8
            max-idle: 8
            # 连接池中的最小空闲连接 默认 0
            min-idle: 0

3.redis配置类

@Configuration
public class RedisConfig {

    /**
     * RedisConnectionFactory：Redis的连接工厂，根据配置文件中的Redis的配置做Redis连接和连接池的管理
     * 该对象在项目初始化时被创建,springboot2默认使用实现类LettuceConnectionFactory
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        //创建原生的RedisTemplate对象
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(connectionFactory);
        // 使用Jackson2JsonRedisSerialize替换 默认的JDK序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //创建JSON序列化的对象，value使用JSON序列化方式
        ObjectMapper om = new ObjectMapper();
        //设置序列化的策略
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //启用默认的类型
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //引用JSON序列化
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //创建String序列化，我们的key使用String序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用JSON
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用JSON
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        //使用该配置
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

4.redis工具类

​ 工具类：列举了String类型，其他 set list hash zset 可以百度看一下

@Component
public class RedisUtils {

	@Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public boolean del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                return redisTemplate.delete(key[0]);
            }
            return redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key)) > 0 ? true : false;
        }
        return false;
    }

    /**
     * 匹配所有的key
     *
     * @param pettern
     * @return
     */
    public Set<String> keys(String pettern) {
        if (pettern.trim() != "" && pettern != null) {
            return redisTemplate.keys(pettern);
        }
        return null;
    }
// ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key      键
     * @param value    值
     * @param time     时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @param timeUnit 过期时间单位
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, timeUnit);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
}

5.测试springBoot 是否连接上Redis

@SpringBootTest
class LoveApplicationTests {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    @Test
    public void testString(){
        //操作String类型的数据
        ValueOperations<String, String> valueStr = redisTemplate.opsForValue();
        //存储一条数据
        valueStr.set("goodsProdu","长安");
        //获取一条数据并输出
        String goodsName = valueStr.get("goodsProdu");
        System.out.println(goodsName);
        //存储多条数据
        Map<String,String> map = new HashMap<>();
        map.put("goodsName","福特汽车");
        map.put("goodsPrice","88888");
        map.put("goodsId","88");

        valueStr.multiSet(map);
        //获取多条数据
        System.out.println("========================================");
        List<String> list = new ArrayList<>();
        list.add("goodsName");
        list.add("goodsPrice");
        list.add("goodsId");
        list.add("goodsProdu");

        List<String> listKeys = valueStr.multiGet(list);
        for (String key : listKeys) {
            System.out.println(key);
        }

    }
}

客户端查看

6.业务逻辑使用

​ 登录业务

public Result login(UserDto userDto) {
        //判断空
        String uname = userDto.getUname();
        String upassword = userDto.getUpassword();
        if(StringUtils.isBlank(uname) || StringUtils.isBlank(upassword)){
            return Result.error("300","参数错误");
        }
        //获取用户信息
        User one = getControllerInfo(userDto);
        if(!Objects.equals(one,null)){
            BeanUtil.copyProperties(one,userDto,true);
            String token = TokenUtils.genToken(one.getUid().toString(), one.getUpassword());
            //存入到redis中  直接存token值到Redis中
          //redisUtils.set(GlobalConstant.REDIS_KEY_TOKEN+one.getUid(),token);
            //设置过期时间对应时间单位     
            redisUtils.set(GlobalConstant.REDIS_KEY_TOKEN+one.getUid(),token,GlobalConstant.REDIS_KEY_TOKEN_TIME, TimeUnit.HOURS);
            userDto.setToken(token);
            //设置动态菜单
            String role = one.getRole();
            List<Menu> menuList=getMenuListByRole(role);

            userDto.setMenuList(menuList);
            return Result.success(userDto);
        }
        return Result.error("300","用户名或者密码错误");

    }

​ 修改密码，删除用户，退出登录进行删除对应的token

//删除Redis中token值
redisUtils.del(GlobalConstant.REDIS_KEY_TOKEN+cid);