Redis

空山新雨后~

已于 2022-03-30 15:49:39 修改

阅读量1.8k

点赞数 5

分类专栏： JavaWeb java学习之路文章标签： mvc java 开发语言 Redis jedis

于 2022-03-30 15:44:02 首次发布

本文链接：https://blog.csdn.net/ww166955/article/details/123842172

版权

java学习之路同时被 2 个专栏收录

62 篇文章 11 订阅

订阅专栏

JavaWeb

17 篇文章 0 订阅

订阅专栏

前言
🎄：CSDN的小伙伴们大家好，今天跟大家分享一个非关系型数据库——Redis。如果这篇文章对你有用，麻烦给我点个小赞以示鼓励吧🎄
🏡：博客主页：空山新雨后的java知识图书馆
☀️：今天天气晴朗，春天的温度。
📝:勇敢地闯过一切艰难险阻，在崎岖的山道上攀行；如果这条道路要通过死亡之谷，那也要把死亡当作欢乐的源泉来欢迎。
——《泰戈尔评传》📝
📖上一篇文章：Ajax和JSON📖
👏欢迎大家一起学习，进步。加油👊

文章目录

一、Redis简介
二、下载安装Redis
三、Redis的相关命令操作
四、Redis的持久化
- 4.1、Redis持久化机制一：1. RDB：
- 4.2、Redis持久化机制二：2. AOF：
五、Redis的java版本客户端jedis
六、案例：使用Redis完成下拉列表的缓存
- 案例源码：源码我放在仓库中了，需要的可自行提取。

一、Redis简介

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
redis是一款高性能的NOSQL系列的非关系型数据库

NOSQL和关系型数据库的优缺点
优点：
1）成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。
2）查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。
3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。
4）扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。
缺点：
1）维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。
2）不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。
3）不提供关系型数据库对事务的处理。

非关系型数据库和关系型数据的优势区别
非关系型数据库的优势
1）性能NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。
2）可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。
关系型数据库的优势：
1）复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。
2）事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。

总结

关系型数据库与NoSQL数据库并非对立而是互补的关系，即通常情况下使用关系型数据库，在适合使用NoSQL的时候使用NoSQL数据库，让NoSQL数据库对关系型数据库的不足进行弥补。
一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据

目前Redis支持的键值数据类型：

字符串类型 string
哈希类型 hash
列表类型 list
集合类型 set
有序集合类型 sortedse

redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容等等）
• 聊天室的在线好友列表
• 任务队列。（秒杀、抢购、12306等等）
• 应用排行榜 • 网站访问统计
• 数据过期处理（可以精确到毫秒
• 分布式集群架构中的session分离

二、下载安装Redis

官网：https://redis.io
中文网：http://www.redis.net.cn/
解压直接可以使用：
- redis.windows.conf：配置文件
- redis-cli.exe：redis的客户端：服务器点开之后就可以点开客户端了
- redis-server.exe：redis服务器端：先点开服务器

三、Redis的相关命令操作

根据前面我们介绍的目前Redis支持的数据类型来讲
他的key都是字符串类型的，值分别为以下类型

字符串类型 string
哈希类型 hash ： map格式
列表类型 list ：
linkedlist格式。支持重复元素
集合类型 set ：不允许重复元素
有序集合类型
sortedset：不允许重复元素，且元素有顺序

3.1、字符串类型的命令操作

存储： set key value

127.0.0.1:6379> set username zhangsan
	OK

获取： get key

127.0.0.1:6379> get username
	"zhangsan"

删除： del key

127.0.0.1:6379> del age
	(integer) 1

3.2、hash类型的命令操作

存储： hset key field value

127.0.0.1:6379> hset myhash username lisi
(integer) 1
127.0.0.1:6379> hset myhash password 123
(integer) 1

获取：
- hget key field: 获取指定的field对应的值

127.0.0.1:6379> hget myhash username
		"lisi"

2. hgetall key：获取所有的field和value

127.0.0.1:6379> hgetall myhash
		1) "username"
		2) "lisi"
		3) "password"
		4) "123"

删除： hdel key field

127.0.0.1:6379> hdel myhash username
	(integer) 1

3.3、列表类型list，该类型可以存储重复元素

添加：
1. lpush key value: 将元素加入列表左表
2. rpush key value：将元素加入列表右边

127.0.0.1:6379> lpush myList a
		(integer) 1
		127.0.0.1:6379> lpush myList b
		(integer) 2
		127.0.0.1:6379> rpush myList c
		(integer) 3

获取：
- lrange key start end ：范围获取

127.0.0.1:6379> lrange myList 0 -1
	1) "b"
	2) "a"
	3) "c"

删除：
- lpop key：删除列表最左边的元素，并将元素返回
- rpop key：删除列表最右边的元素，并将元素返回

3.4、set集合类型，该类型不允许重复元素的存在，而且存取顺序不一致

存储：sadd key value

127.0.0.1:6379> sadd myset a
(integer) 1
127.0.0.1:6379> sadd myset a
(integer) 0

获取：smembers key:获取set集合中所有元素

127.0.0.1:6379> smembers myset
	1) "a"

删除：srem key value:删除set集合中的某个元素

127.0.0.1:6379> srem myset a
	(integer) 1

3.5、有序集合类型sortedset：该类型不允许重复元素的存在，而且是存取顺序根据score来从小到大排序

存储：zadd key score value

127.0.0.1:6379> zadd mysort 60 zhangsan
(integer) 1
127.0.0.1:6379> zadd mysort 50 lisi
(integer) 1
127.0.0.1:6379> zadd mysort 80 wangwu
(integer) 1

获取：zrange key start end [withscores]

127.0.0.1:6379> zrange mysort 0 -1
1) "lisi"
2) "zhangsan"
3) "wangwu"

127.0.0.1:6379> zrange mysort 0 -1 withscores
	1) "zhangsan"
	2) "60"
	3) "wangwu"
	4) "80"
	5) "lisi"
	6) "500"

删除：zrem key value

127.0.0.1:6379> zrem mysort lisi
(integer) 1

3.6、Redis的通用命令

keys * : 查询所有的键
type key ：获取键对应的value的类型
del key：删除指定的key value

四、Redis的持久化

Redis作为一个内存数据库，他的数据是存储在内存中的，如果Redis服务器重启，或者电脑重启，也就意味着无法永久的存储，而有的时候我们又需要他有永久存储的能力，以供下一次调用。

4.1、Redis持久化机制一：1. RDB：

默认方式，不需要进行配置，默认就使用这种机制
* 在一定的间隔时间中，检测key的变化情况，然后持久化数据
1. 编辑redis.windwos.conf文件

#   after 900 sec (15 min) if at least 1 key changed
				save 900 1
				#   after 300 sec (5 min) if at least 10 keys changed
				save 300 10
				#   after 60 sec if at least 10000 keys changed
				save 60 10000

4.2、Redis持久化机制二：2. AOF：

日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据
1. 编辑redis.windwos.conf文件

appendonly no（关闭aof） --> appendonly yes （开启aof）
		# appendfsync always ： 每一次操作都进行持久化
		appendfsync everysec ： 每隔一秒进行一次持久化
		# appendfsync no	 ： 不进行持久化

五、Redis的java版本客户端jedis

jedis使我们在java中操作Redis数据库的一个客户端工具，要想使用这个工具，也是需要导入jar包的，该入门包有两个，自行百度下载即可。

5.1、jedis的使用实例

  /**
     * @Date 2022/3/28 10:41
     * @Param
     * @Return void
     * @MetodName test1
     * @Author wang
     * @Description jedis的快速入门
     */
    @Test
    public void test1() {
        //获取连接，参数为主机地址，Redis服务器的端口号
        Jedis jedis = new Jedis("localhost", 6379);
        //进行操作，例如添加数据
        jedis.set("username", "zhangsan");
        //关闭连接
        jedis.close();
        String username = jedis.get("username");
        System.out.println(username);
        //zhangsan 记住一定要开Redis服务器哦 
    }

5.2、jedis中操作各种Redis中数据结构的操作

1、 string类型
方法：
set()
get()
代码演示

 /**
     * @Date 2022/3/28 11:14
     * @Param
     * @Return void
     * @MetodName test2
     * @Author wang
     * @Description 字符串类型的操作
     */
    @Test
    public void test2() {
        //获取连接，参数为主机地址，Redis服务器的端口号,参数如果是空参构造，默认就是本机地址和6379端口号
        Jedis jedis = new Jedis("localhost", 6379);
        //进行操作，例如添加数据
//        jedis.set("username","zhangsan");

        //设置指定时间的过期时间的key value
        jedis.setex("activeCode", 10, "张三");

        //关闭连接
        jedis.close();
        String username = jedis.get("username");
        System.out.println(username);
        //zhangsan
    }

2、哈希类型 hash ： map格式
方法：
hset
hget
hgetAll
代码演示

    /**
     * @Date 2022/3/28 11:26
     * @Param
     * @Return void
     * @MetodName test3
     * @Author wang
     * @Description hash数据类型的测试
     */
    @Test
    public void test3() {
        //获取连接，参数为主机地址，Redis服务器的端口号,参数如果是空参构造，默认就是本机地址和6379端口号
        Jedis jedis = new Jedis("localhost", 6379);
        //进行操作，例如添加数据
        jedis.hset("user", "name", "zhangsan");
        jedis.hset("user", "age", "22");
        jedis.hset("user", "gender", "male");

        String name = jedis.hget("user", "name");
        System.out.println(name);

        Map<String, String> user = jedis.hgetAll("user");
        Set<String> keySet = user.keySet();
        for (String key : keySet) {
            String value = user.get(key);
            System.out.println(key + ":" + value);
        }
        //关闭资源
        jedis.close();

        //zhangsan
        //gender:male
        //name:zhangsan
        //age:22
    }

3、列表类型 list ： linkedlist格式。支持重复元素
lpush / rpush
lpop / rpop
lrange start end : 范围获取
代码演示

/**
     * @Date 2022/3/28 11:39
     * @Param
     * @Return void
     * @MetodName test3
     * @Author wang
     * @Description list集合类型的操作
     */
    @Test
    public void test4() {
        //获取连接，参数为主机地址，Redis服务器的端口号,参数如果是空参构造，默认就是本机地址和6379端口号
        Jedis jedis = new Jedis("localhost", 6379);
        //进行操作，例如添加数据
        jedis.lpush("list", "a", "b", "c");
        jedis.rpush("list", "a", "b", "c");

        //获取jedis,0, -1代表取出所有的值
        List<String> list = jedis.lrange("list", 0, -1);
        System.out.println(list);//[c, b, a, a, b, c]
        //弹出左边第一个元素
        String list1 = jedis.lpop("list");
        System.out.println(list1);//c
        //弹出右边第一个元素
        String list2 = jedis.rpop("list");
        System.out.println(list2);//c

        //重新获取list集合
        List<String> lists = jedis.lrange("list", 0, -1);

        System.out.println(lists);//[b, a, a, b]
        //关闭资源
        jedis.close();
/*
[c, b, a, a, b, c]
c
c
[b, a, a, b]
 */
    }

4、集合类型 set ：不允许重复元素
方法：
sadd
smembers:获取所有元素
代码演示

 /**
     * @Date 2022/3/28 14:43
     * @Param
     * @Return void
     * @MetodName test5
     * @Author wang
     * @Description set集合的测试
     */
    @Test
    public void test5() {
        //获取连接，参数为主机地址，Redis服务器的端口号,参数如果是空参构造，默认就是本机地址和6379端口号
        Jedis jedis = new Jedis("localhost", 6379);
        //进行操作，例如添加数据
        jedis.sadd("user", "zhangsan", "lisi", "wangwu");

        Set<String> user = jedis.smembers("user");
        System.out.println(user);

        //[lisi, zhangsan, wangwu]
        //关闭资源
        jedis.close();
    }

5、有序集合类型 sortedset：不允许重复元素，且元素有顺序
方法：
zadd
zrange
代码演示

    /**
     * @Date 2022/3/28 14:46
     * @Param
     * @Return void
     * @MetodName test6
     * @Author wang
     * @Description sortedSet集合的测试
     */
    @Test
    public void test6() {
        //获取连接，参数为主机地址，Redis服务器的端口号,参数如果是空参构造，默认就是本机地址和6379端口号
        Jedis jedis = new Jedis("localhost", 6379);
        //进行操作，例如添加数据
        jedis.zadd("user2", 10, "成龙");
        jedis.zadd("user2", 25, "李小龙");
        jedis.zadd("user2", 18, "叶问");

        //[成龙, 叶问, 李小龙]
        Set<String> user = jedis.zrange("user2", 0, -1);
        System.out.println(user);
        //关闭资源
        jedis.close();
        //[成龙, 叶问, 李小龙]
    }

5.3、jedis连接池工具类的配置

首先我们来测试一下jedis连接池对象

 /**
     * @Date 2022/3/28 15:24
     * @Param
     * @Return void
     * @MetodName test7
     * @Author wang
     * @Description jedis连接池测试
     */
    @Test
    public void test7() {

        //配置连接池对象
        JedisPoolConfig con = new JedisPoolConfig();
        con.setMaxTotal(50);
        con.setMaxIdle(10);


        //创建Jedis连接池对象,可以不用传参，默认的即可
        JedisPool jedisPool = new JedisPool(con, "localhost", 6379);

        //获取连接
        Jedis jedis = jedisPool.getResource();

        //使用
        jedis.set("name", "zhangsan");

        String name = jedis.get("name");
        System.out.println(name);
        //zhangsan
        //归还到连接池中
        jedis.close();

    }

jedis配置文件，jedis.properties

host=127.0.0.1
port=6379
maxTotal=50
maxIdle=10

配置文件看不懂？下面给你解释清楚

#最大活动对象数     
redis.pool.maxTotal=1000    
#最大能够保持idel状态的对象数      
redis.pool.maxIdle=100  
#最小能够保持idel状态的对象数   
redis.pool.minIdle=50    
#当池内没有返回对象时，最大等待时间    
redis.pool.maxWaitMillis=10000    
#当调用borrow Object方法时，是否进行有效性检查    
redis.pool.testOnBorrow=true    
#当调用return Object方法时，是否进行有效性检查    
redis.pool.testOnReturn=true  
#“空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1.  
redis.pool.timeBetweenEvictionRunsMillis=30000  
#向调用者输出“链接”对象时，是否检测它的空闲超时；  
redis.pool.testWhileIdle=true  
# 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3.  
redis.pool.numTestsPerEvictionRun=50  
#redis服务器的IP    
redis.ip=xxxxxx  
#redis服务器的Port    
redis1.port=6379

为了简化操作，我们可以将jedis连接池对象封装到一个工具类当中，需要的时候调用即可
jedisutils

package com.study.jedis.utils;

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

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @author wang
 * @version 1.0
 * @packageName com.study.jedis.utils
 * @className JedisPoolUtils
 * @date 2022/3/28 15:44
 * @Description Jedis连接池工具类
 */
public class JedisPoolUtils {
    //提供连接池对象
    private static JedisPool jedisPool;

    //静态代码块加载连接池
    static {
        //加载配置文件
        InputStream is = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
        //创建properties对象
        Properties prop = new Properties();
        //关联文件
        try {
            prop.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //设置数据，初始化到jedisConfig中
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.parseInt(prop.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(prop.getProperty("maxIdle")));

        //初始化jedisPool对象
        jedisPool = new JedisPool(config, prop.getProperty("host"), Integer.parseInt(prop.getProperty("port")));

    }

    public static Jedis getJedis() {
        return jedisPool.getResource();
    }

}

测试连接池工具类

/**
     * @Date 2022/3/28 15:54
     * @Param
     * @Return void
     * @MetodName test7
     * @Author wang
     * @Description jedisPoolUtils 工具类测试
     */
    @Test
    public void test8() {
        Jedis jedis = JedisPoolUtils.getJedis();
        //使用
        jedis.set("name", "wangwu");
        String name = jedis.get("name");
        System.out.println(name);

        //wangwu
        //归还到连接池中
        jedis.close();
    }

六、案例：使用Redis完成下拉列表的缓存

案例需求：
1. 提供index.html页面，页面中有一个省份下拉列表
2. 当页面加载完成后发送ajax请求，加载所有省份

注意：使用redis缓存一些不经常发生变化的数据。
- 数据库的数据一旦发生改变，则需要更新缓存。
  - 数据库的表执行增删改的相关操作，需要将redis缓存数据情况，再次存入
  - 在service对应的增删改方法中，将redis数据删除。

这个小案例仅仅演示了如何通过Redis来完成避免重复进入数据库查询的操作，也就是缓存，来减少资源的占用。

思路：
1、在HTML页面中使用Ajax获取请求的数据，
2、在Servlet中调用service的方法，service中应该有两个操作，一是首先从Redis中获取数据，判断Redis中存储的数据是否为空，如果为空则证明没有数据，就从数据库中取出，再存入Redis返回到Servlet中，再由Servlet将数据序列化为JSON格式返回给HTML。
3、如果不为空则直接返回Redis中的数据即可。
部分代码演示
HTML：

<!--
*@packageName 
*@className index
*@author wang
*@date 2022/3/28 17:31
*@Description 
-->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="js/jquery-3.3.1.min.js"></script>
    <script>
        $(function () {
            //发送Ajax请求获取数据
            $.get("provinceServlet", {}, function (data) {
                //获取select标签对象
                var province = $("#province");
                //遍历JSON数组
                $(data).each(function () {
                    //创建option
                    var option = "<option name='" + this.id + "'>" + this.name + "</option>";
                    //将option拼接到province后面
                    province.append(option)
                })
            });
        });
    </script>

</head>
<body>
<select id="province">
    <option>----请选择省份----</option>
</select>
</body>
</html>

Servlet

package com.study.jedis.web.servlet;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.study.jedis.domain.Province;
import com.study.jedis.service.ProvinceService;
import com.study.jedis.service.impl.ProvinceServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

/**
 * @author wang
 * @version 1.0
 * @packageName ${PACKAGE_NAME}
 * @className ${NAME}
 * @date 2022/3/28 16:44
 * @Description ${description}
 */
@WebServlet("/provinceServlet")
public class ProvinceServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1、调用service查询
        ProvinceService service = new ProvinceServiceImpl();
//        List<Province> list = service.findProvince();
        String json = service.findAllProvince();

        //序列化为JSON
//        ObjectMapper mapper = new ObjectMapper();
//        String json = mapper.writeValueAsString(list);
        System.out.println(json);

        //响应结果
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(json);

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

service

package com.study.jedis.service.impl;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.study.jedis.dao.ProvinceDao;
import com.study.jedis.dao.impl.ProvinceDaoImpl;
import com.study.jedis.domain.Province;
import com.study.jedis.service.ProvinceService;
import com.study.jedis.utils.JedisPoolUtils;
import redis.clients.jedis.Jedis;

import java.util.List;

/**
 * @author wang
 * @version 1.0
 * @packageName com.study.jedis.service.impl
 * @className ProvinceServiceImpl
 * @date 2022/3/28 16:39
 * @Description
 */
public class ProvinceServiceImpl implements ProvinceService {
    private ProvinceDao dao = new ProvinceDaoImpl();

    @Override
    public List<Province> findProvince() {
        return dao.findProvince();
    }


    /**
     * @Date 2022/3/28 17:57
     * @Param
     * @Return List<Province>
     * @MetodName findAllProvince
     * @Author wang
     * @Description 通过Redis缓存来获取所有的省份
     */
    @Override
    public String findAllProvince() {
        //获取Redis的连接池
        Jedis jedis = JedisPoolUtils.getJedis();
        //从Redis中获取数据
        String province = jedis.get("province");

        //判断province是否为null，如果为null说明没有数据，就从数据库中存取
        if (province == null || province.length() == 0) {
            //
            System.out.println("Redis中没有数据，查询的数据库");
            //从数据库中查询
            List<Province> list = dao.findProvince();
            //序列化到JSON
            ObjectMapper mapper = new ObjectMapper();
            try {
                province = mapper.writeValueAsString(list);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }

            //将JSON存入Redis
            jedis.set("province", province);
            jedis.close();
        }
//        不为null 的话，就直接返回从Redis拿出来的数据即可。

        return province;
    }
}