玖叶教程网

前言：

本节内容包含：与Redis服务建立redis连接，通过数据库连接池建立redis连接、数据库连接池配置说明、操作Reids的五大数据类型、存储KEY设置生存时间（TTL）、Reids通过序列化存储Java对象、通过FastJSON方式存储Java对象。 实现一切皆可复制~

服务器配置（redis.conf）：

#是否为守护进程
daemonize yes
#服务端口
port 6379
#日志文件
logfile "6379.log"
#存储路径
dir /usr/local/redis/redis4/data
#保护模式
protected-mode no
#密码
requirepass 123456

开发环境（pom.xml）：

<!-- Jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>
<!-- FastJson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>

案例源码内容：

jedis_config.properties==>配置项，位置为：src/main/resources/jedis_config.properties

#======================================================================#
#服务地址
redis.host=192.168.1.11
#服务端口
redis.port=6379
#服务密码
redis.passwd=123456
#连接超时时间
redis.timeout=10000
#======================================================================#
#控制一个pool可分配多少个jedis实例
redis.pool.maxActive=50
#最多有多少个状态为idle(空闲)的jedis实例
redis.pool.maxIdle=20
#最少有多少个状态为idle(空闲)的jedis实例
redis.pool.minIdle=1
#创建jedis实例时检查连接可用性（ping()）
redis.pool.testOnCreate=true
#获取jedis实例时检查连接可用性（ping()）
redis.pool.testOnBorrow=true
#返回jedis实例时检查连接可用性（ping()）
redis.pool.testOnReturn=true
#测试空闲，表示有一个idle object evitor线程对idle object进行扫描
#如果validate失败，此object会被从pool中drop掉
#只有在timeBetweenEvictionRunsMillis大于0时才有意义
redis.pool.testWhileIdle=true
#表示idle object evitor两次扫描之间要sleep的毫秒数
redis.pool.timeBetweenEvictionRunsMillis=60000
#表示idle object evitor每次扫描的最多的对象数；
redis.pool.numTestsPerEvictionRun=10
#表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐
#只有在timeBetweenEvictionRunsMillis大于0时才有意义；
redis.pool.minEvictableIdleTimeMillis=-1
#在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了
#如果为-1，evicted不会根据idle time驱逐任何对象。
#如果minEvictableIdleTimeMillis>0，则此项设置无意义，
#且只有在timeBetweenEvictionRunsMillis大于0时才有意义
redis.pool.softMinEvictableIdleTimeMillis=-1
#当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛JedisConnectionException
redis.pool.maxWaitMillis=3000
#当pool中的jedis实例都被allocated完时，pool要采取的操作，默认有三种
#WHEN_EXHAUSTED_FAIL --> 表示无jedis实例时，直接抛出NoSuchElementException
#WHEN_EXHAUSTED_BLOCK --> 则表示阻塞住，或者达到maxWait时抛出JedisConnectionException
#WHEN_EXHAUSTED_GROW --> 则表示新建一个jedis实例，也就说设置的maxActive无用
redis.pool.whenExhaustedAction=WHEN_EXHAUSTED_BLOCK
#======================================================================#

JedisManager.java==>Jedis连接池管理类

package com.what21.assembly.apply.jedis;

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

import java.util.ResourceBundle;

public final class JedisManager {

    private static JedisPool pool;

    static {
        //====================================================================//
        //读取配置文件
        //====================================================================//
        ResourceBundle resourceBundle = ResourceBundle.getBundle("jedis_config");
        String host = resourceBundle.getString("redis.host");
        int port = Integer.parseInt(resourceBundle.getString("redis.port"));
        String passwd = resourceBundle.getString("redis.passwd");
        int timeout = Integer.parseInt(resourceBundle.getString("redis.timeout"));
        int maxActive = Integer.parseInt(resourceBundle.getString("redis.pool.maxActive"));
        int maxIdle = Integer.parseInt(resourceBundle.getString("redis.pool.maxIdle"));
        int minIdle = Integer.parseInt(resourceBundle.getString("redis.pool.minIdle"));
        boolean testOnCreate = Boolean.parseBoolean(resourceBundle.getString("redis.pool.testOnCreate"));
        boolean testOnBorrow = Boolean.parseBoolean(resourceBundle.getString("redis.pool.testOnBorrow"));
        boolean testOnReturn = Boolean.parseBoolean(resourceBundle.getString("redis.pool.testOnReturn"));
        boolean testWhileIdle = Boolean.parseBoolean(resourceBundle.getString("redis.pool.testWhileIdle"));
        int timeBetweenEvictionRunsMillis = Integer.parseInt(resourceBundle.getString("redis.pool.timeBetweenEvictionRunsMillis"));
        int numTestsPerEvictionRun = Integer.parseInt(resourceBundle.getString("redis.pool.numTestsPerEvictionRun"));
        int minEvictableIdleTimeMillis = Integer.parseInt(resourceBundle.getString("redis.pool.minEvictableIdleTimeMillis"));
        int softMinEvictableIdleTimeMillis = Integer.parseInt(resourceBundle.getString("redis.pool.softMinEvictableIdleTimeMillis"));
        int maxWaitMillis = Integer.parseInt(resourceBundle.getString("redis.pool.maxWaitMillis"));
        //====================================================================//
        //创建连接池配置对象
        //====================================================================//
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(maxActive);
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMinIdle(minIdle);
        jedisPoolConfig.setTestOnCreate(testOnCreate);
        jedisPoolConfig.setTestOnBorrow(testOnBorrow);
        jedisPoolConfig.setTestOnReturn(testOnReturn);
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        jedisPoolConfig.setTestWhileIdle(testWhileIdle);
        jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
        jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(softMinEvictableIdleTimeMillis);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        //====================================================================//
        //创建连接池对象
        //====================================================================//
        if (passwd == null || "".equals(passwd)) {
            pool = new JedisPool(jedisPoolConfig, host, port, timeout);
        } else {
            pool = new JedisPool(jedisPoolConfig, host, port, timeout, passwd);
        }
        //====================================================================//
        //The end
        //====================================================================//
    }

    /**
     * 从连接池中获取Jedis
     *
     * @return
     */
    public static Jedis getJedis() {
        return pool.getResource();
    }

    /**
     * 关闭Jedis，释放连接
     *
     * @param jedis
     */
    public static void close(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }

    /**
     * 关闭连接池
     *
     * @param pool
     */
    public static void close(JedisPool pool) {
        if (pool != null) {
            pool.close();
        }
    }

}

JavaSerializeUtils.java==>Java序列化反序列化工具类

package com.what21.assembly.apply.jedis;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class JavaSerializeUtils {

    /**
     * 序列化
     *
     * @param object
     * @return
     */
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            // 序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {

        }
        return null;
    }

    /**
     * 反序列化
     *
     * @param bytes
     * @return
     */
    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            // 反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {

        }
        return null;
    }

}

JedisUseDemo.java==>代码案例

package com.what21.assembly.apply.jedis;

import com.alibaba.fastjson.JSON;
import redis.clients.jedis.Jedis;

import java.io.Serializable;
import java.util.*;

/**
 * Jedis使用案例
 */
public class JedisUseDemo {

    // String(字符串)
    private static void operateStringType(Jedis jedis) {
        // 向key-->name中放入了value-->小奋斗
        jedis.set("name", "小奋斗");
        System.out.println("name=" + jedis.get("name"));
        // 追加字符串
        jedis.append("name", "就是小奋斗");
        System.out.println("name=" + jedis.get("name"));
        // 设置多个键值
        jedis.mset("name", "小奋斗", "age", "34", "work", "IT");
        // 加1操作
        jedis.incr("age");
        System.out.println("age=" + jedis.get("age"));
        // 加5操作
        jedis.incrBy("age", 5);
        System.out.println("age=" + jedis.get("age"));
        // mget取值
        System.out.println(jedis.mget("name", "age", "work"));
        // 删除
        jedis.del("name");
        jedis.del("age");
        jedis.del("work");
        System.out.println(">>>>>>" + jedis.mget("name", "age", "work"));
    }

    // Hash(哈希)
    private static void operateHashType(Jedis jedis) {
        Map<String, String> dataMap = new HashMap<String, String>();
        dataMap.put("name", "小奋斗");
        dataMap.put("age", "34");
        dataMap.put("work", "IT");
        jedis.hmset("user", dataMap);
        // 获取map
        List<String> rsmap = jedis.hmget("user", "name", "age", "work");
        System.out.println(rsmap);
        // 删除map中的某个值
        jedis.hdel("user", "age");
        // 再次获取map
        System.out.println(jedis.hmget("user", "age"));
        // 获取map长度
        System.out.println(jedis.hlen("user"));
        // 是否存在user
        System.out.println(jedis.exists("user"));
        // 返回所有key值
        Set<String> keySet = jedis.hkeys("user");
        System.out.println(keySet);
        // 获取所有值
        List<String> valueList = jedis.hvals("user");
        System.out.println(valueList);
        // 遍历map
        Iterator<String> iter = jedis.hkeys("user").iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            System.out.println(key + ":" + jedis.hmget("user", key));
        }
        // 删除user
        jedis.del("user");
        System.out.println(">>>>>>" + jedis.mget("user"));
    }

    // List(列表)
    private static void operateListType(Jedis jedis) {
        //  -1 表示列表的最后一个元素，
        //  -2 表示列表的倒数第二个元素
        List<String> list = jedis.lrange("framework", 0, -1);
        System.out.println(list);
        // 从左边放入
        jedis.lpush("framework", "spring");
        jedis.lpush("framework", "spring boot");
        jedis.lpush("framework", "mybatis");
        List<String> list2 = jedis.lrange("framework", 0, -1);
        System.out.println(list2);
        // 删除操作
        jedis.del("framework");
        // 从右边放入
        jedis.rpush("language", "java");
        jedis.rpush("language", "c++");
        jedis.rpush("language", "python");
        jedis.rpush("language", "go");
        List<String> list3 = jedis.lrange("language", 0, -1);
        System.out.println(list3);
        jedis.del("language");
    }

    // Set(集合)==>不能添加重复元素
    private static void operateSetType(Jedis jedis) {
        jedis.sadd("key:user", "张柏芝");
        jedis.sadd("key:user", "刘若英");
        jedis.sadd("key:user", "刘德华");
        jedis.sadd("key:user", "任贤齐");
        Set<String> data = jedis.smembers("key:user");
        System.out.println(data);
        // 随机获取一个
        System.out.println("随机：" + jedis.srandmember("key:user"));
        // 返回集合的元素个数
        System.out.println(jedis.scard("key:user"));
        // 是否是集合的元素
        System.out.println(jedis.sismember("key:user", "任贤齐"));
        jedis.srem("key:user", "刘若英");
        System.out.println(jedis.smembers("key:user"));
        // 删除操作
        jedis.del("key:user");
        System.out.println(jedis.smembers("key:user"));
    }

    // sorted set:有序集合
    private static void operateZsetType(Jedis jedis) {
        jedis.rpush("a", "1");
        jedis.lpush("a", "7");
        jedis.lpush("a", "3");
        jedis.lpush("a", "5");
        // 获取数据
        List<String> data = jedis.lrange("a", 0, -1);
        System.out.println(data);
        // 获取排序后的结构
        List<String> data2 = jedis.sort("a");
        System.out.println(data2);
        // 再次输出并无排序
        System.out.println(jedis.lrange("a", 0, -1));
        // 删除操作
        jedis.del("a");
        System.out.println(jedis.lrange("a", 0, -1));
    }

    // 设置TTL(生存时间)
    private static void operateSetTTL(Jedis jedis) {
        int expireSecond = 30;
        boolean keyExist = jedis.exists("ttl_name");
        if (keyExist) {
            jedis.del("ttl_name");
        }
        // NX是不存在时才set， XX是存在时才set， EX是秒，PX是毫秒
        jedis.set("ttl_name", "测试生存时间", "NX", "EX", expireSecond);
        System.out.println("ttl_name=" + jedis.get("ttl_name"));
        //try {
        //    Thread.sleep(40 * 1000);
        //} catch (InterruptedException e) {
        //    e.printStackTrace();
        //}
        System.out.println("ttl_name=" + jedis.get("ttl_name"));
    }

    static class User implements Serializable {

        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;
        }
    }

    // 存储对象（对象序列化）
    private static void operateJavaSerialize(Jedis jedis) {
        User user100 = new User();
        user100.setId(100);
        user100.setName("张三");
        // 序列化操作
        jedis.set("user:100".getBytes(), JavaSerializeUtils.serialize(user100));
        // 反序列化操作
        byte[] data100 = jedis.get(("user:100").getBytes());
        User newUser100 = (User) JavaSerializeUtils.unserialize(data100);
        System.out.println("user:100=" + newUser100.getId() + "," + newUser100.getName());
        jedis.del("user:100");
    }

    // 存储对象（对象转JSON）
    private static void operateSaveObject(Jedis jedis) {
        User user100 = new User();
        user100.setId(100);
        user100.setName("李四");
        // 对象转JSON存储
        jedis.set("user:100", JSON.toJSONString(user100));
        // JSON转对象
        String data100 = jedis.get("user:100");
        User newUser100 = JSON.parseObject(data100, User.class);
        System.out.println("user:100=" + newUser100.getId() + "," + newUser100.getName());
        jedis.del("user:100");
    }

    public static void main(String[] args) throws InterruptedException {
        Jedis jedis = JedisManager.getJedis();
        // 切换数据库
        jedis.select(1);
        System.out.println("当前数据库：" + jedis.getDB());
        //查看服务是否运行
        System.out.println("服务正在运行: " + jedis.ping());
        //String(字符串)
        operateStringType(jedis);
        // Hash(哈希)
        operateHashType(jedis);
        //List(列表)
        operateListType(jedis);
        // Set(集合)
        operateSetType(jedis);
        // sorted set:有序集合
        operateZsetType(jedis);
        // 设置TTL
        operateSetTTL(jedis);
        // 存储对象（对象序列化）
        operateJavaSerialize(jedis);
        // 存储对象（对象转JSON）
        operateSaveObject(jedis);
        // 关闭连接
        JedisManager.close(jedis);
    }
}