Redis学习笔记

  概念

Redis是一款高性能的NOSQL系列的非关系型数据库。

关系型数据库：例如MySQL，数据之间有关联关系，数据存储在硬盘文件上（操作耗时）。

非关系型数据库：存储键值对，数据直接无关联，数据存储在内存中（缓存思想）。

缓存：常用于查询一些不太经常发生变化的数据。

我们优先从缓存中获取数据，若缓存中已经存在我们所需要的数据，就可直接返回。

若缓存中不存在我们需要的数据，就去数据库中查询，然后将数据放入缓存，最后返回数据。

关系型数据库与NOSQL数据库并非对立，而是互补的关系。一般将数据寸尺在关系型数据库中，在NOSQL数据库中进行备份。

Redis是用C语言开发的一个开源的高性能键值对数据库。应用于缓存，消息队列（解决秒杀项目高并发问题）等。

 

  Redis下载

中文官网

下载完成后，解压即可。

关注3个文件：

redis.windows.conf：配置文件

redis-server.exe：服务器端执行文件

redis-cli.exe：客户端端执行文件

首先我们打开服务器端，默认运行在6379端口。不要关闭服务器端，我们打开客户端，输入命令set name zhangsan，页面显示OK，这样我们就存入了一个键值对。再次输入命令get name，页面显示“zhangsan”，这样就读取到了刚刚存入的数据。

 使用Redis的两种方式：命令，或Java代码（Jedis)。

 

  Redis数据结构

redis存储键值对（相当于一个大map），key的类型必须为字符串，value可以为5种数据结构，下面分别介绍：

1.字符串类型：最普通的类型，没啥好介绍的

2.哈希类型hash：相当于Java中的map格式。也就是说，value也是一个键值对的形式。

3.列表类型list：相当于Java中的linkedlist格式。列表格式，有序，可以重复。

4.集合类型set：相当于Java中的set类型。列表格式，无序，不可重复。

5.有序集合类型sortedset：列表格式，有序，不可重复。

 

  命令操作

1.字符串类型

存储：set key value

获取value值：get key

删除：del key

2.哈希类型

存储：hset key field value

获取：hget key field或hgetall key（获取所有的filed和value）

删除：hdel key field

  3.列表类型

这里的列表是一个左右两端均开放的“队列”，可以添加到列表的头部（左边）或尾部（右边）。

允许重复元素。

存储：lpush key value 将元素加入列表最左边，rpush key value 将元素加入列表最右边

获取：lrange key start end：返回获取，获取全部时为lrange key 0 -1

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

 4.集合类型

不允许重复元素。且存入的value没有顺序。

存储：saad key value

获取所有元素：smembers key 

删除：srem key value

 5.有序集合类型

不允许重复元素，且元素有顺序。

存储：zaad key score value

按score升序排列

获取：zrange key start end

删除：zrem key value

 6.通用命令

查询所有的键：keys *

查询指定key的类型：type key

删除指定的键值对：del key

 

  持久化

redis是一个内存数据库，当redis重启，或者电脑重启，数据就会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。

redis有两种持久化机制：

1.RDB：默认方式。在一定的间隔时间中，检测key变化情况，然后持久化数据

查看配置文件，找到如下三行：

 这三行的意思是：如果900秒内有1个key值被改动，就持久化一次。如果300秒内有10个key值被改动，就持久化一次。如果60秒内有10000个key值被改动，就持久化一次。

若改动了配置文件，就不能直接打开服务器和客户端使用redis。

我们需要在cmd中输入：redis-server.exe redis.windows.conf来手动启动服务器，然后再打开客户端，输入命令。持久化后，目录下会生成一个后缀为rdb的文件，用来存储持久化的数据。

 2.AOF：日志记录的方式，可以记录每一条命令的操作。每一次命令操作后，都持久化一次数据。

在配置文件中找到这一行，把no改为yes，就表示使用AOF持久化方式。

 开启AOF后，可以继续指定如下的配置：

 第一行表示，每次操作都进行持久化。第二行表示，每隔1秒进行一次持久化（默认）。第三行表示，不进行持久化。

我们需要在cmd中输入：redis-server.exe redis.windows.conf来手动启动服务器，然后再打开客户端，输入命令。持久化后，目录下会生成一个后缀为aof的文件，用来存储持久化的数据。

 

  Java客户端——Jedis

一款Java操作redis数据库的工具。

使用步骤:在project structure中导入两个jar包

 然后进行如下入门操作：

    @Test
    public void test1(){
        //获取连接
        Jedis jedis = new Jedis("localhost",6379);
        //操作
        jedis.set("score","100");
        //关闭连接
        jedis.close();
    }

运行后，使用key *命令，可以看到score已经被创建。

Jedis中的方法名称与命令相同，因此理解上较为简单，下面直接给出一些代码来演示：

 1.操作String

    @Test
    public void test1(){
        //获取连接
        Jedis jedis = new Jedis("localhost",6379);
        //操作
        jedis.set("score","100");
        String score = jedis.get("score");
        System.out.println(score);
        //20秒后自动删除该键值对
        jedis.setex("activecode",20,"60");
        //关闭连接
        jedis.close();
    }

setex（）方法表示存储键值对activecode-60，20秒后自动删除，可以应用于存储一些有时效的验证码/激活码等。

注意：redis无论value是什么数据类型，但其中最后的数据类型都是String，所以activecode和60都要用双引号括起来。

2.操作hash

@Test
    public void test2(){
        //获取连接
        Jedis jedis = new Jedis("localhost",6379);
        //操作
        //存储hash
        jedis.hset("user","name","Lisa");
        jedis.hset("user","age","24");
        jedis.hset("user","sex","female");
        //获取hash
        Map<String,String> user = jedis.hgetAll("user");
        //遍历打印user中存储的键值对
        Set<String> keySet = user.keySet();
        for(String key:keySet){
            String value = user.get(key);
            System.out.println(key + ":" + value);
        }
        //关闭连接
        jedis.close();
    }

运行后打印结果：

 3.操作列表类型

@Test
    public void test3(){
        //获取连接
        Jedis jedis = new Jedis("localhost",6379);
        //操作
        //存储
        jedis.lpush("mylist","a","b","c");
        jedis.rpush("mylist","d","e","f");
        //获取
        List<String> mylist = jedis.lrange("mylist",0,-1);
        System.out.println(mylist);
        //弹出
        String element1 = jedis.lpop("mylist");
        System.out.println(element1);
        String element2 = jedis.rpop("mylist");
        System.out.println(element2);
        //获取
        List<String> newmylist = jedis.lrange("mylist",0,-1);
        System.out.println(newmylist);
        //关闭连接
        jedis.close();
    }

运行后打印结果：

 4.存储集合

    @Test
    public void test4(){
        //获取连接
        Jedis jedis = new Jedis("localhost",6379);
        //操作
        //存储
        jedis.sadd("mySet","java","php","c++");
        //获取
        Set<String> mySet = jedis.smembers("mySet");
        System.out.println(mySet);
        //关闭连接
        jedis.close();
    }

运行后打印结果：（注意是无序的）

 5.操作有序集合

@Test
    public void test5(){
        //获取连接
        Jedis jedis = new Jedis("localhost",6379);
        //操作
        //存储
        jedis.zadd("mySortedSet",10,"鲁班大师");
        jedis.zadd("mySortedSet",30,"杨玉环");
        jedis.zadd("mySortedSet",40,"盾山");
        //获取
        Set<String> mySortedSet = jedis.zrange("mySortedSet",0,-1);
        System.out.println(mySortedSet);
        //关闭连接
        jedis.close();
    }

运行后打印结果：（按照score值升序排列）

 

  Jedis连接池：JedisPool

使用：

1.创建JedisPool连接池对象

2.调用方法getResource（）方法获取Jedis连接

    @Test
    public void testJedisPool(){
        //创建配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(50);//允许最多连接数
        config.setMaxIdle(10);//允许最大空闲连接
        //创建连接池对象
        JedisPool jedisPool = new JedisPool(config,"localhost",6379);
        //获取连接
        Jedis jedis = jedisPool.getResource();
        //使用
        jedis.set("counts","20");
        //关闭，归还到连接池中
        jedis.close();
    }

当然，也可以直接修改配置文件，然后创建连接池对象时，使用默认参数。

常用配置：

 

  连接池工具类的编写与应用

工具类编写：

public class JedisPoolUtils {
    private static JedisPool jedisPool;
    static{
        //读取配置文件
        InputStream is = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
        //创建Properties对象
        Properties pro = new Properties();
        //关联文件
        try {
            pro.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //获取数据，设置到JedisPoolConfig中
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.parseInt(pro.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(pro.getProperty("maxIdle")));
        //初始化JedisPool
        jedisPool = new JedisPool(config,pro.getProperty("host"),Integer.parseInt(pro.getProperty("port")));
    }

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

应用：

    @Test
    public void testJedisUtils(){
        //通过连接池工具了获取
        Jedis jedis = JedisPoolUtils.getJedis();
        //操作
        jedis.set("Name","Lily");
        //关闭，归还到连接池中
        jedis.close();
    }

 注意：jedis.properties要放到jedis包下，与utils包，test包平行，才能被读取到。

 

  Redis案例

案例需求：

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

步骤1：创建MySQL数据库表格

  步骤2：环境搭建

导入相应jar包，web中导入js目录。

 导入druid配置文件。

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///jedis
username=root
password=0322
initialSize=5
maxActive=10
maxWait=3000

 步骤3：3层架构代码编写

domain

public class Province {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

dao接口

public interface ProvinceDao {
    public List<Province> findAll();
}

daoImpl实现

public class ProvinceDaoImpl implements ProvinceDao {
    //声明成员变量
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    @Override
    public List<Province> findAll() {
        //定义sql
        String sql = "select * from province";
        //执行sql
        List<Province> list = template.query(sql, new BeanPropertyRowMapper<Province>(Province.class));
        return list;
    }
}

service接口

public interface ProvinceService {
    public List<Province> findAll();
}

serviceImpl实现

public class ProvinceServiceImpl implements ProvinceService {
    //声明dao
    private ProvinceDao dao = new ProvinceDaoImpl();

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

ProvinceServet

@WebServlet(name = "provinceServlet")
public class ProvinceServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //调用service查询
        ProvinceService service = new ProvinceServiceImpl();
        List<Province> list = service.findAll();
        //序列化list为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);

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}

index.html

<!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>>";
                        //调用select的append追加option
                        province.append(option);

                        });


                });
            });
    </script>

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

</body>

步骤4：加入redis，实现缓存优化

在service接口中添加一个方法

public String findAllJson();

serviceImpl中重写该方法，实现缓存操作：

    @Override
    public String findAllJson() {
        //1.先从redis中查询数据
        //1.1获取redis客户端连接
        Jedis jedis = JedisPoolUtils.getJedis();
        String province_json = jedis.get("province");

        //2判断 province_json 数据是否为null
        if(province_json == null || province_json.length() == 0){
            //redis中没有数据
            System.out.println("redis中没数据，查询数据库...");
            //2.1从数据中查询
            List<Province> ps = dao.findAll();
            //2.2将list序列化为json
            ObjectMapper mapper = new ObjectMapper();
            try {
                province_json = mapper.writeValueAsString(ps);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }

            //2.3 将json数据存入redis
            jedis.set("province",province_json);
            //归还连接
            jedis.close();

        }else{
            System.out.println("redis中有数据，查询缓存...");
        }

        return province_json;
    }

 但是，一旦数据改变，就需要更新缓存。

添加redis缓存后，第一次读取数据需要访问mysql，然后数据就会缓存在redis中，下一次读取时，直接从缓存中读取即可。