原创

    Redis 进阶教程【二】

    第一章:Jedis 快速入门

    一、Jedis 简介

    Jedis 是一款 Redis 官方推荐的 Java 操作 Redis 数据库的工具,与 JDBC 很类似 。具体使用步骤如下:

    # Jedis 的使用步骤:
    
    第一步:下载 Jedis 的 jar 包                   # 下面会有下载链接提示
    第二步:新建 JavaEE 项目,然后添加 Jedis 的 jar 包
    第三步:启动 Redis 服务器 redis-server.exe
    第四步:编写 Java 程序对 Redis 进行操作
    第五步:启动 Redis 的客户端 redis-cli.exe 进行结果查看
    
    # 以下是 Jedis 的 jar 包的几种下载方式
    

    1、官方下载: https://mvnrepository.com/artifact/redis.clients/jedis
    2、Maven 依赖导入: https://mvnrepository.com/search?q=jedis
    3、本博客下载: http://47.113.85.135:8888/images/gallery/BLOG-Resources/jedis.zip

    二、Jedis 的基本使用

    第一步: 新建一个 JavaEE 项目【如果新建 Maven 项目会更简单,只要导入依赖即可】。如下图:

    第二步: 启动 Redis 服务器。找到自己 Redis 安装目录,双击 redis-server.exe 即可启动。 如下图:

    第三步: 编写 Java 程序对 Redis 进行操作。 相关代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 14:15
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisTest() {
            // 1、获取连接。如果使用空参构造,那么默认值就是 ==> "localhost", 6379
            Jedis jedis = new Jedis("localhost", 6379);
            // 2、进行操作
            jedis.set("username", "guoshizhan");
            // 3、关闭连接
            jedis.close();
        }
    
    }
    

    第四步: 启动 Redis 的客户端 redis-cli.exe 进行结果查看。 如下图:

    TIPS: 到此为止,Jedis 的最基本使用就学废啦,哈哈~~~

    三、Jedis 的各种操作

    温馨小提示:

    1、Jedis 里面的各种方法和 Redis 里面的各种命令是 相互对应 的,所以操作起来相对简单。
    2、Jedis 里面也会 有一些特殊的方法, 这些方法都将在代码里体现。

    1、操作字符串类型

    第一种操作: Jedis 操作 Redis 中的字符串类型 。代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 14:24
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisTest() {
            // 1、获取连接
            Jedis jedis = new Jedis("localhost", 6379);
    
            // 2、进行操作
            jedis.set("username", "guoshizhan");
            jedis.set("age", "22");
            String str = jedis.get("age");
            System.out.println(str);
    
            // setex() 方法存储可以指定时间过期的 key-value
            // 以下代码表示把 activeCode:039752 键值对存入 Redis ,30 秒之后过期
            jedis.setex("activeCode", 30, "039752");
    
            // 3、关闭连接
            jedis.close();
        }
    
    }
    

    上述代码的执行结果如下图:

    2、操作哈希类型

    第二种操作: Jedis 操作 Redis 中的哈希类型 。代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 14:35
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisTest() {
            // 1、获取连接
            Jedis jedis = new Jedis("localhost", 6379);
    
            // 2、进行操作:存储 hash
            jedis.hset("user", "username", "guoshizhan");
            jedis.hset("user", "address", "HangZhou");
            jedis.hset("user", "gender", "male");
    
            // 3、获取 hash
            String username = jedis.hget("user", "username");
            System.out.println(username);
    
            Map<String, String> stringMap = jedis.hgetAll("user");
            Set<String> keySet = stringMap.keySet();
            for (String key : keySet) {
                String value = stringMap.get(key);
                System.out.println(key + "---" + value);
            }
    
            // 4、关闭连接
            jedis.close();
        }
    
    }
    

    上述代码的执行结果如下图:

    3、操作列表类型

    第三种操作: Jedis 操作 Redis 中的列表类型 。代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    
    import java.util.List;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 14:43
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisTest() {
            // 1、获取连接
            Jedis jedis = new Jedis("localhost", 6379);
    
            // 2、进行操作:存储 list
            jedis.lpush("myList", "a", "b", "c");
            jedis.rpush("myList", "a", "b", "c");
    
            // 3、范围获取
            List<String> myList = jedis.lrange("myList", 0, -1);
            System.out.println(myList);
    
            // 4、删除操作
            String eleLeft = jedis.lpop("myList");    // 从左边删除
            System.out.println(eleLeft);
            String eleright = jedis.rpop("myList");   // 从右边删除
            System.out.println(eleright);
            System.out.println(jedis.lrange("myList", 0, -1));
    
            // 5、关闭连接
            jedis.close();
        }
    
    }
    

    上述代码的执行结果如下图:

    4、操作集合类型

    第四种操作: Jedis 操作 Redis 中的集合类型 。代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    
    import java.util.Set;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 14:52
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisTest() {
            // 1、获取连接
            Jedis jedis = new Jedis("localhost", 6379);
    
            // 2、进行添加操作:该操作的底层是 set 集合,所以不重复存储且无序
            jedis.sadd("mySet", "Java", "C++", "HTML", "Java");
            Set<String> mySet = jedis.smembers("mySet");
            System.out.println(mySet);
    
            // 3、关闭连接
            jedis.close();
        }
    
    }
    

    上述代码的执行结果如下图:

    5、操作有序集合类型

    第五种操作: Jedis 操作 Redis 中的有序集合类型 。代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    
    import java.util.Set;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 14:59
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisTest() {
            // 1、获取连接
            Jedis jedis = new Jedis("localhost", 6379);
    
            // 2、进行添加操作:底层使用 zset 集合,所以不重复存储且会按照 score 来排序
            jedis.zadd("sortedSet", 9, "典韦");
            jedis.zadd("sortedSet", 7, "亚瑟");
            jedis.zadd("sortedSet", 5, "白起");
    
            Set<String> sortedSet = jedis.zrange("sortedSet", 0, -1);
            System.out.println(sortedSet);
    
            // 3、关闭连接
            jedis.close();
        }
    
    }
    

    上述代码的执行结果如下图:

    TIPS: Jedis 的各种操作到此结束,接下来介绍 Jedis 连接池

    四、Jedis 连接池

    Jedis 有直连方式,所谓直连指的是 Jedis 每次都会新建 TCP 连接,使用后再断开连接,对于频繁访问 Redis 的场景显然不是高效的使用方式。因此, Jedis 连接池 JedisPool 诞生了。 当我们需要连接 Redis 时,只需要向 JedisPool 池子中借,用完了再归还给 JedisPool 池子即可。具体使用步骤如下:

    # JedisPool 连接池使用步骤:
    
    第一步:下载 Jedis 的 jar 包 ,把 commons-pool2-2.3.jar 加入到项目的 lib 文件夹中
    第二步:编写相关代码:1、创建 JedisPool 连接池对象;2、调用方法 getResource() 方法获取 Jedis 连接
    第三步:查看操作结果
    
    # commons-pool2-2.3.jar 包下载地址如下:
    

    jar 包下载: 本博客站点下载

    第一步 的操作如下图:

    第二步 的具体代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 16:12
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisPoolTest() {
            // 1、创建 Jedis 连接池对象
            JedisPool jedisPool = new JedisPool();
    
            // 2、获取连接
            Jedis jedis = jedisPool.getResource();
    
            // 3、进行使用
            jedis.set("jedisPool", "jedisPool");
    
            // 4、关闭,就是把 jedis 对象归还到 jedisPool 连接池中
            jedis.close();
        }
    
    }
    

    上述代码的执行结果如下图:

    五、Jedis 连接池工具类

    感觉使用 Jedis 连接池创建对象比较麻烦, 那我们就来写一个 Jedis 连接池工具类吧!开始撸码 ing ……


    第一步:src 目录 下新建 utils 包 和 Jedis 配置文件 jedis.properties 。如下图:

    第二步: 编写 Jedis 配置文件 jedis.properties 和 Jedis 连接池工具类 JedisPoolUtils 。配置文件代码如下:

    # 主机地址,可以是服务器地址,也可以是本地
    host=127.0.0.1
    
    # 端口号
    port=6379
    
    # 最大连接数
    maxTotal=50
    
    # 最大空闲连接数
    maxIdle=10
    

    第三步: 编写 Jedis 连接池工具类。代码如下:

    package 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: guoshizhan
     * @Create: 2021/8/10 16:17
     * @Description: Jedis 连接池工具类,用于加载连接池的配置文件,降低程序的耦合性
     */
    public class JedisPoolUtils {
    
        private static JedisPool jedisPool;
    
        /**
         * 定义静态代码块,当这个类一加载,它就去读取连接池的配置文件
         */
        static {
            // 1、读取配置文件
            InputStream inputStream = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
    
            // 2、创建 properties 对象
            Properties properties = new Properties();
    
            // 3、关联连接池配置文件
            try {
                properties.load(inputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // 4、获取数据,设置到 JedisPoolConfig 中
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
            config.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));
    
            // 5、初始化 jedisPool
            jedisPool = new JedisPool(config, properties.getProperty("host"), Integer.parseInt(properties.getProperty("port")));
        }
    
        /**
         * 获取连接的方法
         */
        public static Jedis getJedis() {
            return jedisPool.getResource();
        }
    
    }
    

    第四步: 编写测试类代码。代码如下:

    package jedis;
    
    import org.junit.Test;
    import redis.clients.jedis.Jedis;
    import utils.JedisPoolUtils;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 16:24
     * @Description: Jedis 测试类
     */
    public class JedisTest {
    
        @Test
        public void jedisPoolTest() {
            // 1、jedis 连接池工具类的使用
            Jedis jedis = JedisPoolUtils.getJedis();
    
            // 2、进行操作
            jedis.set("jedisPoolUtils", "jedisPoolUtils");
    
            // 3、关闭,就是把 jedis 对象归还到连接池中
            jedis.close();
        }
    
    }
    

    第五步: 查看测试结果。如下图:

    附赠: Jedis 中更多的详细配置如下:

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

    第二章:Redis 综合案例

    一、案例说明与准备

    案例需求: 提供了一个 index.html 页面 ,页面中有一个省份的【下拉列表】。当页面加载完成后,发送 ajax 请求,加载所有省份。 本案例所用资源下载: 案例资源下载(包含了代码部分)

    1、创建数据库

    第一步: 新建数据库和数据表。代码如下:

    CREATE DATABASE RedisTest;    -- 创建数据库
    USE RedisTest;                -- 使用数据库
    
    CREATE TABLE province(        -- 创建表
        id INT PRIMARY KEY AUTO_INCREMENT,
        NAME VARCHAR(20) NOT NULL
    );
    
    -- 插入 4 条数据
    INSERT INTO province VALUES(NULL,'北京');
    INSERT INTO province VALUES(NULL,'上海');
    INSERT INTO province VALUES(NULL,'广州');
    INSERT INTO province VALUES(NULL,'陕西');
    

    2、添加 jar 包依赖

    第二步: 添加各种 jar 包到 lib 文件夹下 【案例资源在上面已提供了下载链接】 。添加之后如下图:

    3、创建配置文件

    第三步: 添加数据库配置文件 druid.properties 到 src 目录下,并完善包结构。如下图:

    4、导入静态资源

    第四步: 导入 js 文件到 web 目录下。如图所示:

    5、编写工具类

    第五步:utils 包 下新建 JDBCUtilsJedisPoolUtils 两个工具类。对应代码如下:

    package utils;
    
    import com.alibaba.druid.pool.DruidDataSourceFactory;
    
    import javax.sql.DataSource;
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Properties;
    
    /**
     * JDBC工具类:使用 Durid 连接池
     */
    public class JDBCUtils {
    
        private static DataSource ds ;
    
        static {
            try {
                // 1、加载配置文件
                Properties properties = new Properties();
                // 使用 ClassLoader 加载配置文件,获取字节输入流
                InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
                properties.load(is);
    
                // 2、初始化连接池对象
                ds = DruidDataSourceFactory.createDataSource(properties);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 获取连接池对象
         */
        public static DataSource getDataSource(){
            return ds;
        }
    
        /**
         * 获取连接 Connection 对象
         */
        public static Connection getConnection() throws SQLException {
            return  ds.getConnection();
        }
    
    }
    
    package 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: guoshizhan
     * @Create: 2021/8/10 16:53
     * @Description: Jedis 连接池工具类,用于加载连接池的配置文件,降低程序的耦合性
     */
    public class JedisPoolUtils {
    
        private static JedisPool jedisPool;
    
        /**
         * 定义静态代码块,当这个类一加载,它就去读取连接池的配置文件
         */
        static {
            // 1、读取配置文件
            InputStream inputStream = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
    
            // 2、创建 properties 对象
            Properties properties = new Properties();
    
            // 3、关联连接池配置文件
            try {
                properties.load(inputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // 4、获取数据,设置到 JedisPoolConfig 中
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
            config.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));
    
            // 5、初始化 jedisPool
            jedisPool = new JedisPool(config, properties.getProperty("host"), Integer.parseInt(properties.getProperty("port")));
        }
    
        /**
         * 获取连接的方法
         */
        public static Jedis getJedis() {
            return jedisPool.getResource();
        }
    
    }
    

    TIPS: 综合案例的 准备工作 到此结束了 ~ ~ ~

    二、案例代码编写

    1、新建 Province 类

    第一步:domain 包 下新建一个 Province 类 ,和数据库 province 表相对应。代码如下:

    package domain;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 16:59
     * @Description: Province实体类
     */
    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;
        }
    
    }
    

    2、dao 层代码编写

    第二步:dao 包 下新建一个 ProvinceDao 接口 ,定义相关操作方法。代码如下:

    package dao;
    
    import domain.Province;
    
    import java.util.List;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 17:03
     * @Description: ProvinceDao 接口
     */
    public interface ProvinceDao {
    
        // 查询所有省份
        public List<Province> findAll();
    
    }
    

    然后在 dao/impl 包 下新建 ProvinceDaoImpl 实现类 ,用于实现 ProvinceDao 接口 。代码如下:

    package dao.impl;
    
    import dao.ProvinceDao;
    import domain.Province;
    import org.springframework.jdbc.core.BeanPropertyRowMapper;
    import org.springframework.jdbc.core.JdbcTemplate;
    import utils.JDBCUtils;
    
    import java.util.List;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 16:05
     * @Description: ProvinceDao 的实现类
     */
    public class ProvinceDaoImpl implements ProvinceDao {
    
        private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    
        @Override
        public List<Province> findAll() {
            // 1、定义查询所有的 sql
            String sql = "select * from province";
    
            // 2、执行 sql
            List<Province> list = template.query(sql, new BeanPropertyRowMapper<>(Province.class));
    
            // 3、返回 list 集合
            return list;
        }
    
    }
    

    3、service 层代码编写

    第三步:service 包 下新建一个 ProvinceService 接口 ,定义相关操作方法。代码如下:

    package service;
    
    import domain.Province;
    
    import java.util.List;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 17:10
     * @Description: ProvinceService
     */
    public interface ProvinceService {
    
        // 查询所有,与 Redis 无关
        public List<Province> findAll();
        
        // 使用 Redis 会用到这个方法
        public String findAllJson();
    
    }
    

    然后在 service/impl 包 下新建 ProvinceServiceImpl 实现类 ,用于实现 ProvinceService 接口 。代码如下:

    package service.impl;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import dao.ProvinceDao;
    import dao.impl.ProvinceDaoImpl;
    import domain.Province;
    import redis.clients.jedis.Jedis;
    import service.ProvinceService;
    import utils.JedisPoolUtils;
    
    import java.util.List;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 17:13
     * @Description: ProvinceService 实现类
     */
    public class ProvinceServiceImpl implements ProvinceService {
    
        private ProvinceDao dao = new ProvinceDaoImpl();
    
        @Override
        public List<Province> findAll() {
            return dao.findAll();
        }
    
        /**
         * 使用 Redis 作为缓存
         * @return 返回字符串类型
         */
        @Override
        public String findAllJson() {
            // 1、获取连接
            Jedis jedis = JedisPoolUtils.getJedis();
            String province_json = jedis.get("province");
    
            // 2、判断 province_json 是否为 null
            if (province_json == null || province_json.length() == 0) {
                System.out.println("Redis 中没有数据,正在查询数据库……");
    
                List<Province> list = dao.findAll();
                ObjectMapper mapper = new ObjectMapper();
                try {
                    province_json = mapper.writeValueAsString(list);
                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }
    
                jedis.set("province", province_json);
                jedis.close();
            } else {
                System.out.println("Redis 中有数据,正在查询缓存……");
            }
    
            // 3、返回数据
            return province_json;
        }
    
    }
    

    4、编写 Servlet 控制器

    第四步:web/servlet 包 下新建一个 ProvinceServlet 类 ,用于 Ajax 请求和页面数据展示 。代码如下:

    package web.servlet;
    
    import com.fasterxml.jackson.databind.ObjectMapper;
    import domain.Province;
    import service.ProvinceService;
    import 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: guoshizhan
     * @Create: 2021/8/10 17:25
     * @Description: Servlet
     */
    @WebServlet("/provinceServlet")
    public class ProvinceServlet extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            // 1、调用 service 查询
            ProvinceService service = new ProvinceServiceImpl();
            List<Province> list = service.findAll();
    
            // 2、序列化 list 为 json 数据
            ObjectMapper mapper = new ObjectMapper();
            String json = mapper.writeValueAsString(list);
    
            // 3、响应结果
            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 {
            this.doPost(request, response);
        }
    }
    

    5、web 页面编写

    接着在 web 目录 下新建 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) {
                        // 1、获取 select
                        var province = $("#province");
                        // 2、遍历 json 数组
                        $(data).each(function () {
                            // 3、创建 <option>
                            var option = "<option name='" + this.id + "'>" + this.name + "</option>";
                            // 4、调用 select 的 append 追加 option
                            province.append(option);
                        });
                    });
                });
            </script>
        </head>
        <body>
            <select id="province">
                <option>---请选择省份---</option>
            </select>
        </body>
    </html>
    

    6、启动 Tomcat 查看结果

    第五步: 启动 Tomcat 查看结果。如下图:

    三、使用 Redis 作为缓存

    使用 Redis 可以减少数据库的交互,从而提高了效率。 那么该如何操作呢?


    第一步: 使用以下代码覆盖原先的 ProvinceServlet 类 。代码如下:

    package web.servlet;
    
    import service.ProvinceService;
    import 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;
    
    /**
     * @Author: guoshizhan
     * @Create: 2021/8/10 17:55
     * @Description: Servlet
     */
    @WebServlet("/provinceServlet")
    public class ProvinceServlet extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            // 1、调用 service 查询,这部分是与 Redis 相关的代码
            ProvinceService service = new ProvinceServiceImpl();
            String json = service.findAllJson();
    
            // 2、响应结果
            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 {
            this.doPost(request, response);
        }
    }
    

    第二步: 启动 Tomcat ,查看测试结果。如下图:

    小提示: 进入上述页面后,多刷新几次页面,方便在 IDEA 控制台明显地看到输出结果 ^_^

    TIPS: Redis 综合案例 到此结束 ~ ~ ~

    第三章:在 Linux 中安装 Redis

    一、Redis 在 Linux 下的安装

    Redis 官方 更推荐我们在 Linux 下使用 Redis ,而不是在 windows 系统下,这样才更符合企业级的开发。现在就来介绍 Redis 在 Linux 下的安装。

    1、下载 Redis

    第一步: 下载 Redis 的 Linux 版本。 下载地址 如下图:

    当然,也可以 使用命令下载 。如下:

    # 01-如果没有安装 wget ,那就使用下列命令安装。如果安装了,可跳过这一步
    yum install wget
    
    # 02-下载 redis-6.0.6.tar.gz 压缩包。下面的这条命令官方有
    wget http://download.redis.io/releases/redis-6.0.6.tar.gz
    
    # 03-解压压缩包
    tar -zxf redis-6.0.6.tar.gz
    

    2、解压 Redis

    第二步: 解压 Redis 压缩包。【如果下载在 windows 系统了,还需要把压缩包上传到 Liunx 云服务器或者是虚拟机,这个自行解决,不难】解压缩的命令和结果如下图:

    3、编译 Redis

    第三步: 编译 Redis 。 需要用到如下命令:

    # 01-安装 gcc 环境,如果安装过,可跳到 03 步骤【凡是涉及到安装的,都需要网络,没网络就完成不了了】
    yum  install -y gcc-c++
    
    # 02-检查 gcc 是否安装成功以及查看版本
    gcc -v
    
    # 03-进入到刚刚解压出来的目录
    cd redis-5.0.4
    
    # 04-使用 make 命令编译。需要点时间,大概 1~2 分钟
    make
    
    # 05-进入到 src 目录
    cd src
    
    # 06-执行安装
    make install
    

    上述命令的具体操作如下图:

    TIPS: 在 make 命令执行完后 , redis-5.0.4 目录下会出现编译后的 redis 服务程序 redis-server 和用于测试的客户端程序 redis-cli ,两个程序位于 redis-5.0.4/src 目录下。

    4、启动 Redis

    第四步: 启动 Redis【不是后台启动,需要使用 CTRL + C 才能停止服务】。 需要用到如下命令:

    # 01-进入到 src 目录
    cd src
    
    # 02-启动 Redis 服务端
    ./redis-server ../redis.conf
    

    5、配置后台启动

    第五步: 配置后台启动,并存一个数据。 需要用到如下命令:

    # 01-编辑配置文件
    vi redis.conf
    
    # 02-找到 daemonize ,把它的值改为 yes ,然后保存退出
    daemonize yes
    
    # 03-启动 Redis 服务端
    ./redis-server ../redis.conf
    
    # 04-启动 Redis 客户端
    ./redis-cli -p 6379
    

    对应的操作截图如下:

    6、查看和关闭 Redis 进程

    第六步: 查看 Redis 进程和关闭 Redis 。 需要用到如下命令:

    # 01-查看 Redis 进程
    ps -ef|grep redis
    
    # 02-关闭 Redis 进程,不明白就看下列图片
    shutdown
    
    # 03-退出 Redis ,不明白就看下列图片
    exit
    

    二、Redis 性能测试

    redis-benchmark 是一个官方自带的 性能测试工具 ,与 redis-server 一样,都位于 Redis 的安装目录下的 src 目录下 。如下图:

    这个性能测试工具有一些可选参数 【来源于:菜鸟教程 ,如下图:

    那么我们如何使用这个测试工具呢?我们又该如何使用这些可选参数呢?使用命令如下:

    # 01-进入到 Redis-server 所在目录,启动 Redis 服务端
    ./redis-server ../redis.conf
    
    # 02-使用 redis-benchmark 测试 100 个并发连接 10 万个请求
    ./redis-benchmark -h localhost -p 6379 -c 100 -n 100000
    
    # 03-如果还需要测试其他参数,请自行按照上述样式进行测试即可,这里就不作过多的测试了
    

    测试结果以及对结果的分析如下图:

    测试结果 对部分结果进行分析

    Redis
    • 文章作者:GuoShiZhan
    • 创建时间:2021-08-10 16:54:59
    • 更新时间:2021-08-11 15:11:48
    • 版权声明:本文为博主原创文章,未经博主允许不得转载!
    请 在 评 论 区 留 言 哦 ~~~
    1024