文档章节

SpringBoot学习(七)—— springboot快速整合Redis

l
 lgx211
发布于 12/03 18:35
字数 2782
阅读 18
收藏 0

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>>

Redis缓存

@[toc]

简介

redis是一个高性能的key-value数据库

优势
  • 性能强,适合高度的读写操作(读的速度是110000次/s,写的速度是81000次/s )。

  • 支持较为丰富的数据类型(如二进制的Strings, Lists, Hashes, Sets ,Ordered Sets)

  • 一定的事物能力(要么执行成功要么完全不执行)。

劣势
  • 内存数据库访问快,但也消耗硬件内存资源

注:redis的单线程仅仅是说在网络请求这一模块上用一个请求处理客户端的请求,但比如说持久化它就会重开一个线程/进程去进行处理。

引入redis缓存

点击链接 下载 redis 的 window 版,下载好后,放入你平时放软件的位置,解压出来即安装完成。(需要注意的是放入的文件目录,当前用户要是可读可写的权限,比如window下的C:\Program Files (x86),这个目录默认只有管理员权限才能读写,redis运行时要在该目录下实时写入日志文件的,若无权限读写,则会操作不成功)

在这里插入图片描述

解压出来的目录如下所示,因为是Windows端的,可双击exe文件开启客户端,服务端。

在这里插入图片描述

因为这是 springboot 整合 redis 系列,所以双击打开服务端即可,别关闭打开的 cmd 窗口。 在这里插入图片描述

在pom.xml中加入

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

在application.properties中添加

# Redis
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码(默认为空)
spring.redis.password=
#Redis数据库索引(默认为0)
spring.redis.database=0  
#连接池最大连接数(使用负值表示没有限制)
spring.redis.jedis.pool.max-active=50
#连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.jedis.pool.max-wait=3000
#连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=20
#连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=5
#连接超时时间(毫秒)
spring.redis.timeout=4000

代码实战

新增代码后的目录如下所示

在这里插入图片描述

这里先说明一下主要类的作用,Springboot 提供了 RedisTemplate 类来操作 Redis,但是该类既无注释解释,命名规律也不够 “望文生义” 。 所以写了个 RedisUtil 来封装一些常用的方法, RedisConfig 主要是将默认的自动注入改为手动注入并加入序列化,避免一些中文乱码问题。

这里特别说一说 RedisUtil 类,搜索 springboot 和 redis 的文章,这个需要自己封装的类网上大多写的非常混乱,而且前后的封装逻辑不一致, 我估计是某位博主从至少三个人那里复制粘贴糅合起来的,然后大家都跟着这位博主复制粘贴,反而成了热门文章。我猜测大家看它是个工具类,而且六百行左右,大多没有仔细琢磨,能简单测试通过即可,但是稍加思考,发现问题真的不少,很容易误导那些喜欢 “拿来主义” 的 “萌新” 。

虽然我这个系列也是快速上手系列,但我理解的快速上手,就是把让人云里雾里的概念讲直白,然后先暂时跳过那些需要深入的,避免刚入手的畏难情绪,把整个操作流程写的清楚明白,给别人讲一千遍道一万句,不如让他对着现成的程序跑一遍,我一直认为:对着一片空白的屏幕学习程序,只会让人愈加焦虑,最好的办法是一边运行,一边深入。

所以我选取了 redis 五大类型中的String,Hash,Set,List,几乎覆盖每个类型,而 SortedSet 没有选取是因为这是有序的Set,可以自己类比。工具类我统一提供的是取值,添加值,删除值,命名规律绝对可以让你 “望文生义” ,其实还有很多方法,这里我不全写出来,是因为五大数据类型都有一堆方法,你不一定用得上,而且很占篇幅,在这里,授人以鱼不如授人以渔,你仔细看看 RedisUtil 的工具类,就会发现规律,比如操作String,大多是先调用opsForValue()方法,操作Hash,大多先调用opsForHash()方法,把项目源码下载到本地,idea里面点进去,就能看到相关的一堆方法。工具类只是重新调用了,换了个名字,加了些逻辑处理。

别看是热门文章就盲从,我举几个刚才说的问题,

在这里插入图片描述

在这里插入图片描述 还有这个的注释说明风格也不统一,给人的感觉看着容易云里雾里的,网上的工具类还用的都是这一个,真的是哭笑不得,大家抄来抄去,都是方案整合商,就不要……

下面开始代码示范

RedisController.java

package com.example.controller;

import com.example.service.IRedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("redis")
public class RedisController {

    @Autowired
    private IRedisService redisService;

    @RequestMapping("/redisString")
    public void redisString() {
        this.redisService.redisString();
    }

    @RequestMapping("/redisHash")
    public void redisHash() {
        this.redisService.redisHash();
    }

    @RequestMapping("/redisSet")
    public void redisSet() {
        this.redisService.redisSet();
    }

    @RequestMapping("/redisList")
    public void redisList() {
        this.redisService.redisList();
    }

    @RequestMapping("/redisSortedSet")
    public void redisSortedSet() {
        //有序的set,故而省略
    }

}

IRedisService.java

package com.example.service;

public interface IRedisService {

    void redisString();

    void redisHash();

    void redisSet();

    void redisList();

    void redisSortedSet();
    
}

RedisServiceIml.java

package com.example.service;

import com.example.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Set;

@Service("redisService")
public class RedisServiceIml implements IRedisService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private RedisUtil redisUtil;

    public void redisString() {
        //添加值
        redisUtil.stringSet("AAA", "这是一个String类型的值");
        //取值
        Object value = redisUtil.stringGet("AAA");
        System.out.println(value);
    }

    public void redisHash() {
        //添加值
        redisUtil.hashSet("BBB", "test1", "原hash值1");
        redisUtil.hashSet("BBB", "test2", "新hash值1");
        redisUtil.hashSet("BBB", "test1", "原hash值2");
        redisUtil.hashSet("BBB", "test2", "新hash值2");
        //取值
        Object value1 = redisUtil.hashGet("BBB", "test1");
        Object value2 = redisUtil.hashGet("BBB", "test2");
        System.out.println(value1);
        System.out.println(value2);
    }

    public void redisSet() {
        //添值
        redisUtil.setSet("CCC", "这是一组Set集合的第一个");
        redisUtil.setSet("CCC", "这是一组Set集合的第二个");
        redisUtil.setSet("CCC", "这是一组Set集合的第三个");
        //取值
        Set vaule = redisUtil.setGet("CCC");
        System.out.println(vaule);
    }

    public void redisList() {
        //添加值
        redisUtil.listSet("DDD", "这是一组List集合的第一个");
        redisUtil.listSet("DDD", "这是一组List集合的第二个");
        redisUtil.listSet("DDD", "这是一组List集合的第三个");
        //取值
        List list = redisUtil.listGet("DDD", 0, -1);
        System.out.println(list);
    }

    public void redisSortedSet() {
        //有序的set,故而省略
    }

}

RedisConfig.java

package com.example.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.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //序列化和反序列化redis中的值
        Jackson2JsonRedisSerializer jackson = new Jackson2JsonRedisSerializer(Object.class);
        //Java对象转换成JSON结构
        ObjectMapper objectMapper = new ObjectMapper();
        // 指定要序列化的域
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson.setObjectMapper(objectMapper);

        // 值采用json序列化
        template.setValueSerializer(jackson);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jackson);
        template.afterPropertiesSet();

        return template;
    }

}

RedisUtil.java

package com.example.util;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@Component
public class RedisUtil {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    //===============缓存相关方法===============

    //指定缓存失效时间
    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获取过期时间,返回0代表为永久有效
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    //===============数据类型为String的相关方法===============

    //根据key值获取缓存值
    public Object stringGet(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    //根据key值存入数据类型为String的缓存值
    public boolean stringSet(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //根据key值存入数据类型为String的缓存值并设置时间
    public boolean stringSetWithTime(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //删除缓存
    public void stringDelete(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //===============数据类型为Hash的相关方法===============

    //根据key和item获取缓存值
    public Object hashGet(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    //根据key和item存入数据类型为Hash的缓存值
    public boolean hashSet(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //根据key和item存入数据类型为Hash的缓存值并设置时间
    public boolean hashSetWithTime(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //删除缓存
    public void hashDelete(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    //===============数据类型为SET的相关方法===============

    //根据key值获取缓存值
    public Set<Object> setGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    //根据key值存入数据类型为SET的缓存值
    public long setSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    //根据key值存入数据类型为SET的缓存值并设置时间
    public long setSetWithTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    //删除缓存
    public long setDelete(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    //===============数据类型为LIST的相关方法===============
    //获取List缓存的内容,从start到end,若从0到-1代表所有值
    public List<Object> listGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    //根据key值存入数据类型为List的缓存值
    public boolean listSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //根据key值存入数据类型为List的缓存值并设置时间
    public boolean listSetWithTime(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //删除缓存
    public long listDelete(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


}

启动项目后,浏览器输入 http://localhost:8080/redis/redisString ,(前台会报错,是因为这个请求只是触发后台的业务逻辑,没有前台页面展示)操作 String 类型的效果图如下所示;

在这里插入图片描述

启动项目后,浏览器输入 http://localhost:8080/redis/redisHash ,操作 Hash 类型的效果图如下所示;(注意一下,我之前代码写的是插入了四个值,只打印出来两个,是因为如果key值和item值一样,新来的值会覆盖原来的值,对比图和代码,你品,你细品。)

在这里插入图片描述

启动项目后,浏览器输入 http://localhost:8080/redis/redisSet ,操作 Set 类型的效果图如下所示;(Set是无序的)

在这里插入图片描述

启动项目后,浏览器输入 http://localhost:8080/redis/redisList ,操作 List 类型的效果图如下所示;

在这里插入图片描述

注:如果是根据本文系列文章来的,因为一开始就配置好了spring security,所以记得将该地址配给所登录的用户。或者开一个超级管理员账号,可以访问项目的任意目录,使用该管理员账号访问这些地址。

这是该学习系列的所有源码,如果有不明白的,想自己实操丰富其中内容的,可以下载到本地,

GitHub码云

© 著作权归作者所有

l
粉丝 2
博文 14
码字总数 25350
作品 0
浦东
程序员
私信 提问
Spring Boot学习笔记

多模块开发 [SpringBoot学习]-IDEA创建Gradle多Module结构的SpringBoot项目 RabbitMQ RabbitMQ 安装 linux安装RabbitMQ详细教程 Ubuntu 16.04 RabbitMq 安装与运行(安装篇) ubantu安装...

OSC_fly
2018/07/26
0
0
SpringBoot 学习二:操作数据库

本文将从以下几个方面介绍: 前言 配置数据源 SpringBoot 整合 Mybatis SpringBoot 整合 JdbcTemplate SpringBoot 整合 Redis 前言 在上篇文章 SpringBoot 学习一 中已经学习了 SpringBoot的...

tsmyk0715
2018/09/26
849
0
恒宇少年/spring-boot-chapter

简书整套文档以及源码解析 专题 专题名称 专题描述 001 Spring Boot 核心技术 讲解SpringBoot一些企业级层面的核心组件 002 Spring Cloud 核心技术 对Spring Cloud核心技术全面讲解 003 Quer...

恒宇少年
2018/04/19
0
0
springboot 详解 (六)servlet & scheduled & listener

---------------------------------------------------------------------------------------------------------------- springboot 详解 (一) helloworld 下载demo springboot 详解 (二)......

curiousby
2016/11/17
0
0
学习 Spring Boot 知识看这一篇就够了

从2016年因为工作原因开始研究 Spring Boot ,先后写了很多关于 Spring Boot 的文章,发表在技术社区、我的博客和我的公号内。粗略的统计了一下总共的文章加起来大概有六十多篇了,其中一部分...

ityouknow
2018/05/28
0
0

没有更多内容

加载失败,请刷新页面

加载更多

交换机switch 的shutdown 与 no shutdown

shutdown是关闭接口(端口),接口状态会变为DOWN,no shutdown是激活接口(端口),状态变为UP,一般在给vlan或者端口配置管理ip或者端口ip后使用。 有时候我们配置某个端口前会需要把端口关闭到...

刘日辉
37分钟前
5
0
AOP底层源码分析

思维导图 AOP AOP: 面向切面编程[底层就是动态代理] 指程序在运行期间动态的将某段代码切入到指定方法位置进行运行的编程方式。 AOP通知方式 前置通知: logStart(),在目标方法(div)运行之前运...

volc1612
50分钟前
5
0
OSChina 周六乱弹 —— 别听他们的,你不胖你只是毛茸茸的

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @且无需多言 :分享Rise Against的单曲《Audience Of One (Ghost Note Symphonies)》: 硬核朋克不插电版本,隐藏在喧嚣下的柔情! 《Audienc...

小小编辑
今天
34
2
apache httpClient实现代理发送Post请求

CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials( new AuthScope("host", port), new UsernamePasswordCredentials(username, password......

huangkejie
今天
6
0
SpringCloud

单体应用存在的问题 ● 随着业务的发展,开发变得越来越复杂。 ● 修改、新增某个功能,需要对整个系统进行测试,重新部署。 ● 一个模块出现问题,很可能导致整个系统崩溃。 ● 多个开发团队...

Star永恒
今天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部