Springboot工程整合Redis以及Redis的使用手册【精】

最新推荐文章于 2024-06-14 23:41:47 发布

ADAMs.

最新推荐文章于 2024-06-14 23:41:47 发布

阅读量444

点赞数 2

分类专栏： SpringBoot Redis 文章标签： redis

本文链接：https://blog.csdn.net/qq_43097201/article/details/105377273

版权

SpringBoot 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

Redis

2 篇文章 0 订阅

订阅专栏

本文主要介绍的内容有：

1、Redis的基本语法
2、Springboot整合Jedis的操作
3、Springboot整合RedisTemplate

Redis的基本类型有五种：

string 字符串类型 (最常用)
hash 哈希类型（map格式）
set 集合类型（不允许重复）
zset 有序集合类型（不允许重复）
list 列表类型（允许重复）

注意：与关系型数据库存储在硬盘文件上不同，Redis非关系数据库是存储在内存中的。

Redis操作命令

1、字符串类型：

存储：set key value（注意，如果重复的话是会直接覆盖的）
获取：get key（如果返回 nil 的话意思是没有获取到）
删除：del key
在这里插入图片描述

2、hash类型：

存储：hset key field（字段） value
获取：hget key field（字段）
删除：hdel key field
获取所有：hgetall key
在这里插入图片描述

3、list列表类型（可以添加一个元素到列表的头部 - 左边/右边，是允许重复的）：

从列表左边添加元素：lpush key value → lpush mylist a
从列表右边添加元素：rpush key value → rpush mylist a
获取：lrange key start end → lrange mylist 0 -1就可以获取key为mylist的所有元素了
（范围的获取，如果想获取所有的话start end分别对应0 -1）
删除：
lpop key（从左边弹出一个元素，也就是删除列表最左边的元素并将元素返回）
rpop key（删除列表最右边的一个元素并将其值返回）
在这里插入图片描述

4、list列表类型集合类型（是不允许重复的）

存储：sadd key value
获取：smembers key（获取set集合中所有元素）
删除：srem key value（删除set集合中的某个元素）
在这里插入图片描述

5、有序集合（不允许重复并且有序，是通过加一个score分数来进行排序的，如果key和value一致的话是可以直接覆盖的）

存储：zadd key score value
获取：zrange key start end （withscores）
删除：zrem key value

在这里插入图片描述

通用命令：

1、keys *：查询所有的键
2、type key：获取某个键对应的类型
3、del key：删除该键

Redis持久化

PS：Redis是一个内存的数据库（也就是说redis是临时存储的，不是长期存在的，当redis重启或者电脑重启了的话，数据就会丢失，我们可以将redis持久化保存到硬盘文件中）：

Redis的持久化机制：

1、RDB：默认方式，不需要进行配置，默认就使用这种机制

（RDB的实现原理是：在一定的间隔时间中，检测key的变化情况，然后去持久化数据（对性能影响低））
操作步骤：
编辑redis.windows.config文件，找到
在这里插入图片描述
注意
这里意思分别是 :
    第一，900后内如果有一个key发生变化的话就执行一次持久化操作;
    第二，300秒内如果有10个key发生变化的话就执行一次持久化操作;
    第三，60秒内如果有10000个key发生变化的话就执行持久化操作.
最后重启redis并指定redis配置文件的名称即可，配置成功后的RDB可以看到一个这样的文件存储在文件夹中。
在这里插入图片描述

2、AOF：不太推荐使用，对性能影响很大。日志记录的方式，可以记录每一条命令的操作。

appendonly no(关闭AOF) → 改为 appendonly yes(开启AOF)
appendfsync always : 每一次操作都执行持久化,性能很低
appendfsync everysec : 每隔一秒执行一次持久化操作,性能也很低
appendfsync no : 不进行持久化
(注意,在打开的时候要指定配置文件打开.)

Jedis的使用，整合到Springboot工程环境中

首先在pom.xml文件中导入坐标依赖：

        <!-- Springboot整合jedis  start -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</dependency>
		<!-- Springboot整合jedis  end -->

其实Jedis的基本操作相当于Redis的基本操作，测试用例的参考代码如下：

package com.ysw.jedis;

import org.junit.Test;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

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

/**
 * jedis的demo案例
 */
public class JedisTest {

    /**
     * string字符串的操作
     */
    @Test
    public void test1(){

        //获取链接
        Jedis jedis = new Jedis("xxxxxxxx",6379);
        jedis.auth("123456");	//登录Redis的密码

        //进行操作
        jedis.set("namesss","wwwwww");
        System.out.println(jedis.get("namesss"));

        //这个意思是将我们当前的currentTime存入redis，并且在20s之后这个数据就会消失
        jedis.setex("currentTime",20,"1");

        //关闭资源
        jedis.close();

    }

    /**
     * hash操作
     */
    @Test
    public void test2(){

        //获取链接
        Jedis jedis = new Jedis("xxxxxxxx",6379);
        jedis.auth("123456");

        //设置
        jedis.hset("user","username","adams");
        jedis.hset("user","password","123456");
        jedis.hset("user","age","22");

        //获取
        String username = jedis.hget("user","username");
        String password = jedis.hget("user","password");
        String age = jedis.hget("user","age");

        //获取hash所有map中的操作
        Map<String, String> user = jedis.hgetAll("user");

        //使用keyset遍历
        Set<String> keySet = user.keySet();
        for (String key : keySet) {

            //获取value
            String value = user.get(key);
            //输出键值对
            System.out.println(key + ":" + value);

        }
        System.out.println();
        System.out.println(username + "-" + password + "-" + age);

        //关闭连接
        jedis.close();

    }

    /**
     * list列表的操作
     */
    @Test
    public void test3(){

        //获取链接
        Jedis jedis = new Jedis("xxxxxxxx",6379);
        jedis.auth("123456");

        //操作
        //list存储，从左边存
        jedis.lpush("mylist","a","b","c");

        //list存储，从右边存
        jedis.rpush("mylist","e","f","g");

        //范围获取list集合
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist);

        //list的弹出左边的第一个元素
        String element1 = jedis.lpop("mylist");
        System.out.println(element1);

        //list的弹出右边的第一个元素
        String element2 = jedis.rpop("mylist");
        System.out.println(element2);

        //关闭连接
        jedis.close();

    }

    /**
     * set 数据结构的操作
     */
    @Test
    public void test4(){

        //获取链接
        Jedis jedis = new Jedis("xxxxxxxx",6379);
        jedis.auth("123456");

        //set存储
        jedis.sadd("myset","adams1","adams2","adams3");
        Set<String> myset = jedis.smembers("myset");
        System.out.println(myset);

        //关闭连接
        jedis.close();

    }

    /**
     * sortedset 数据结构的操作
     */
    @Test
    public void test5(){

        //获取链接
        Jedis jedis = new Jedis("xxxxxxxx",6379);
        jedis.auth("123456");

        //sortedset存储，这个可以做出场率排行，或者热门度排行,按分数从小到大进行排序的，这里的score是可以覆盖的
        jedis.zadd("sortedset",80,"adams");
        jedis.zadd("sortedset",100,"yxl");
        jedis.zadd("sortedset",110,"adamsss");

        //sortedset的获取
        Set<String> sortedset = jedis.zrange("sortedset", 0, -1);
        System.out.println(sortedset);

        //关闭连接
        jedis.close();

    }

    /**
     * Jedis连接池对象
     */
    @Test
    public void test6(){

//        //创建一个配置对象
//        JedisPoolConfig config = new JedisPoolConfig();
//        //最大允许连接数
//        config.setMaxTotal(50);
//        //最大的空闲连接数
//        config.setMaxIdle(10);
//
//        //获取Jedis连接池对象,并放入配置config对象
//        JedisPool jedisPool = new JedisPool(config,"xxxxxxxx",6379);

        //获取链接，记得设置auth密码
        Jedis jedis = JedisPoolUtils.getJedis();
        jedis.auth("123456");

        //使用
        jedis.set("hehe","wwwwww");
        System.out.println(jedis.get("hehe"));

        //关闭 - 归还到连接池中
        jedis.close();

    }
    
}

这里的JedisPoolUtils.java代码如下，这个是用于创建Jedis连接池用的：

package com.ysw.jedis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * JedisPool连接池工具类
 *      加载配置文件，配置连接池的参数
 *      提供获取链接的方法
 */
public class JedisPoolUtils {

    private static JedisPool jedisPool;

    static {

        String host = "xxxxx"; //ip地址
        Integer port = 6379;    //端口号
        Integer maxTotal = 50;  //最大连接数
        Integer maxIdle = 10;   //最大空闲数

        //创建一个配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        //最大允许连接数
        config.setMaxTotal(maxTotal);
        //最大的空闲连接数
        config.setMaxIdle(maxIdle);

        //此时给JedisPool连接池进行赋值操作
        jedisPool = new JedisPool(config,host ,6379);
    }

    /**
     * 获取链接的方法
     */
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }

}

Springboot整合Redis，使用RedisTemplate工具：

首先还是在pom.xml中引入maven坐标依赖：

		<!-- 引入redis坐标依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<version>2.2.5.RELEASE</version>
		</dependency>

在`application.yml`文件中配置redis进行连接：

spring:
  # 整合redis
  redis:
    database: 0
    # 主机号
    host: xxxxxxx
    # 密码
    password: 123456
    # 端口号
    port: 6379
    # 什么时候会超时
    timeout: 5000
    # 连接池的最大连接数
    jedis:
      pool:
        max-active: 1000
        max-wait: -1
        max-idle: 10
        min-idle: 2

Controller层的示例代码如下：

package com.ysw.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ysw.domain.JsonResult;
import com.ysw.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/redis")
public class RedisController {

    //redis所有的操作都已经封装到RedisTemplate里面了，添加好组件后会自动注进来的
    @Autowired
    RedisTemplate<String, String> redisTemplate;

    //这个是用于将对象转为JSON格式的
    @Autowired
    private ObjectMapper objectMapper;

    @GetMapping("/get")
    public JsonResult getRedis() throws JsonProcessingException {
        //这样就可以将字符串转为json形式的对象
        return JsonResult.isOk(objectMapper.readValue(redisTemplate.opsForValue().get("user:2"), User.class));
    }

    @GetMapping("/add")
    public JsonResult addRedis() {

        try {
            User user = new User(2, "adams", "123456", "世");

            //这是redis封装好的api，这里相当于set user:主键 k-v,这里使用String存
            redisTemplate.opsForValue().set("user:" + user.getId(), objectMapper.writeValueAsString(user));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        return JsonResult.isOk(null);
    }

    /**
     * 测试redis的set和get的字符串操作用的
     *
     * @return
     */
    @GetMapping("/getDemo")
    public JsonResult testDemo(){
        redisTemplate.opsForValue().set("names","adams");
        return JsonResult.isOk(redisTemplate.opsForValue().get("names"));
    }
}

ADAMs.

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Springboot工程整合Redis以及Redis的使用手册【精】

本文主要介绍的内容有：1、Redis的基本语法2、Springboot整合Jedis的操作3、Springboot整合RedisTemplateRedis的基本类型有五种：string 字符串类型 (最常用)hash 哈希类型（map格式）set 集合类型（不允许重复）zset 有序集合类型（不允许重复）list 列表类型（允许重复）注意：与关系型数据库存储在硬盘文件上...
复制链接

扫一扫