Redis相关操作

Redis相关参数简述

该参数放在config.properties

###redis库连接地址 真实用###
redisUrl=
###redis库连接默认端口###
redisPort=
###redis库最大连接数###
maxTotal=20
###redis库最大空闲连接数###
maxIdle=5
###redis库获取连接时的最大等待毫秒数###
maxWaitMillis=-1
###redis库在获取连接的时候检查有效性###
testOnBorrow=true
###redis库在获取返回结果的时候检查有效性###
testOnReturn=true
###redis库下标 1号库###
indexDatabase=1
###redis库队列名###
queueName=UserOperateQ

引入jar包

 

Jar包下载地址

http://mvnrepository.com/artifact/redis.clients/jedis

http://mvnrepository.com/artifact/org.apache.commons/commons-pool2

下载操作图解：

       链接进去如图，在红色框内找到所需版本jar包

 

如图找到点击红框内进去

 

进入如图，点击红框内链接即可下载

 

以上两个地址jar包下载操作一样。

Redis库连接

       Redis连接分为切片池连接与非切片池连接，其区别在于一般项目基本都使用非切片池，切片池主要用于分布式项目，可以设置主从Redis库。

       此处是非切片池连接

       该连接类几个注意点：

1. 使用了单例模式创建对象
2. 获取配置文件中redis相关参数放在内存中
3. 单独提出open连接与close连接方法

public class InitRedisClient {
    public Jedis jedis;//非切片的客户端连接
    public JedisPool jedisPool;//非切片连接池
    private static String redisUrl; //redis库连接地址
    private static int redisPort; //redis库连接端口
    private static int maxTotal; //最大连接数
    private static int maxIdle; //最大空闲连接数
    private static int maxWaitMillis; //获取连接时的最大等待毫秒数
    private static boolean testOnBorrow; //在获取连接的时候检查有效性
    private static boolean testOnReturn; //在获取返回结果的时候检查有效性
    private static int indexDatabase; //rdis库下标
    //该类实例
    private static volatile InitRedisClient instance;

    static {
        //todo 获取redis库的相关配置信息
        redisUrl = ReadConfig.getProperty("redisUrl");
        redisPort = Integer.parseInt(ReadConfig.getProperty("redisPort"));
        maxTotal = Integer.parseInt(ReadConfig.getProperty("maxTotal"));
        maxIdle = Integer.parseInt(ReadConfig.getProperty("maxIdle"));
        maxWaitMillis = Integer.parseInt(ReadConfig.getProperty("maxWaitMillis"));
        testOnBorrow = Boolean.parseBoolean(ReadConfig.getProperty("testOnBorrow"));
        testOnReturn = Boolean.parseBoolean(ReadConfig.getProperty("testOnReturn"));
        indexDatabase = Integer.parseInt(ReadConfig.getProperty("indexDatabase"));
    }
    //私有化
    private InitRedisClient() {
    }

    /**
     * 单例模式创建对象
     * @return
     */
    public static InitRedisClient getInstance() {
        if (instance == null) {
            synchronized (InitRedisClient.class) {
                if (instance == null) {
                    instance = new InitRedisClient();
                }
            }
        }
        return instance;
    }

    /**
     * 打开redis连接
     */
    public void open() {
        initialPool();
        jedis = jedisPool.getResource();
        //设置数据操作服务器上第几个redis库
        jedis.select(indexDatabase);
    }

    /**
     * 初始化非切片池
     */
    private void initialPool() {
        // 池基本配置
        JedisPoolConfig config = getConfig();
        jedisPool = new JedisPool(config, redisUrl, redisPort, 30000);
    }

    /**
     * 设置redis库中相关配置信息
     *
     * @return
     */
    private JedisPoolConfig getConfig() {
        // 池基本配置
        JedisPoolConfig config = new JedisPoolConfig();
        //最大连接数
        config.setMaxTotal(maxTotal);
        //最大空闲连接数
        config.setMaxIdle(maxIdle);
        //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        config.setMaxWaitMillis(maxWaitMillis);
        //在获取连接的时候检查有效性, 默认false
        config.setTestOnBorrow(testOnBorrow);
        //在获取返回结果的时候检查有效性, 默认false
        config.setTestOnReturn(testOnReturn);
        return config;
    }

    /**
     * 关闭连接
     *
     * @param jedis
     */
    public void close(Jedis jedis) {
        if (jedis != null) {
            try {
                jedisPool.returnResource(jedis);
                if (jedis.isConnected()) {
                    jedis.quit();
                    jedis.disconnect();
                }
            } catch (Exception e) {
                jedisPool.returnBrokenResource(jedis);
                if (jedis.isConnected()) {
                    jedis.quit();
                    jedis.disconnect();
                }
            }
        }
    }
}

关于redis相关参数是写在配置文件config.properties

读取该配置文件类

public class ReadConfig {
    private static Properties prop = null;

    private static void loadProperties() {
        prop = new Properties();
        try {
            InputStream input = ReadConfig.class.getResourceAsStream("/config.properties");
            prop.load(input);
        } catch (IOException e) {
            System.out.println("读取配置文件异常！");
        }
    }

    public static String getProperty(String key) {
        loadProperties();
        String value = prop.getProperty(key);
        if (value == null) return null;
        try {
            value = new String(value.getBytes("ISO-8859-1"), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            System.out.println("读取配置文件异常！");
        }
        return value;
    }
}

Redis数据类型的基本操作

在做redis库相关操作之前肯定是需要先获取连接，操作之后需要关闭连接，基于以上连接类操作。

Key功能：

Private void keyOperate(){
    Try{
    //获取连接类实例
    InitRedisClient initRedis = InitRedisClient.getInstance();
    //打开redis连接
    initRedis.open();
    Jedis jedis = initRedis.jedis;
    //删除选择数据库中的所有key
    jedis.flushDB()
    //判断key值是否存在，返回值为TRUE或FALSE
    jedis.exists("key")
    //输出系统中所有key
    Set<String> keys = jedis.keys("*"); 
        Iterator<String> it=keys.iterator() ;   
        while(it.hasNext()){   
            String key = it.next();   
            System.out.println(key);   
        }
    //删除某个key
    jedis.del("key")
    //设置key活动时间5秒
    jedis.expire("key", 5)
    //获取key活动时间
    jedis.ttl("key")
    //查看key所存储的值的类型
    jedis.type("key")
    //将key由oldname重命名为newname，若newname存在则删除newname表示的key
    rename(oldname, newname)
    //将当前数据库中的key转移到有dbindex索引的数据库
    rename(oldname, newname)
    }catch (Exception e) {
        //释放redis对象
    initRedis.jedisPool.returnBrokenResource(jedis);
    e.printStackTrace();
}finally {
    //返还到连接池
    initRedis.close(jedis);
}
}

String功能

Public void stringOperate(){
    Try{
    //获取连接类实例
    InitRedisClient initRedis = InitRedisClient.getInstance();
    //打开redis连接
    initRedis.open();
    Jedis jedis = initRedis.jedis;
    //增加值，有key则会覆盖其value值
    jedis.set("key","value");
    //删除key值键值对
    jedis.del("key")
    //获取key值的value值
    jedis.get("key")
    //追加value值
    jedis.append("key","appendString")
    //同时给多个key值赋值
    jedis.mset(key1, value1, key2, value2,…key N, value N)：
    //获取多个key值的value值
    jedis.mget(key1, key2,…, key N)：
    //删除多个key
    jedis.del(new String[]{"key201", "key202"})
    //如果不存在名称为key的string，则向库中添加string，存在不加
    jedis.setnx(key, value)：
    //向库中添加（名称为key，值为value）同时，设定过期时间time
    jedis.setex(key, time, value)：
        }catch (Exception e) {
        //释放redis对象
    initRedis.jedisPool.returnBrokenResource(jedis);
    e.printStackTrace();
}finally {
    //返还到连接池
    initRedis.close(jedis);
}
}

List功能(即队列)

Public void stringOperate(){
    Try{
    //获取连接类实例
    InitRedisClient initRedis = InitRedisClient.getInstance();
    //打开redis连接
    initRedis.open();
    Jedis jedis = initRedis.jedis;
//清空库里所有数据
jedis.flushDB()
//在名称为key的list头添加一个值为value的 元素
jedis.lpush(key,value);
    //在名称为key的list尾添加一个值为value的元素
    jedis.rpush(key,value);
    //返回名称为key的list的长度
    jedis.llen(key)：
    //返回名称为key的list中start至end之间的元素（下标从0开始）
    jedis.lrange(key, start, end)：
    //截取名称为key的list，保留start至end之间的元素
    jedis.ltrim(key, start, end)：
    //返回名称为key的list中index位置的元素
    jedis.lindex(key, index)：
    //给名称为key的list中index位置的元素赋值为value
    jedis.lset(key, index, value)：
    //删除count个名称为key的list中值为value的元素。count为0，删除所有值为value的元素，count>0      从头至尾删除count个值为value的元素，count<0从尾到头删除|count|个值为value的元素。
    jedis.lrem(key, count, value)：
    //返回并删除名称为key的list中的首元素
    jedis.lpop(key)：
    //返回并删除名称为key的list中的尾元素
    jedis.rpop(key)：
    //返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部
Jedis.rpoplpush(srckey, dstkey)：
}catch (Exception e) {
        //释放redis对象
    initRedis.jedisPool.returnBrokenResource(jedis);
    e.printStackTrace();
}finally {
    //返还到连接池
    initRedis.close(jedis);
}
}

Set功能

Public void stringOperate(){
    Try{
    //获取连接类实例
    InitRedisClient initRedis = InitRedisClient.getInstance();
    //打开redis连接
    initRedis.open();
    Jedis jedis = initRedis.jedis;
    //向名称为key的set中添加元素member
    Jedis.sadd(key, member)
    //删除名称为key的set中的元素member
    Jedis.srem(key, member)
    //随机返回并删除名称为key的set中一个元素
    Jedis.spop(key)
    //将member元素从名称为srckey的集合移到名称为dstkey的集合
    Jedis.smove(srckey, dstkey, member)
    //返回名称为key的set的基数
    Jedis.scard(key)
    //测试member是否是名称为key的set的元素
    Jedis.sismember(key, member)
    //返回名称为key的set的所有元素
    Jedis.smembers(key)
    //随机返回名称为key的set的一个元素
    Jedis.srandmember(key) 
}catch (Exception e) {
        //释放redis对象
    initRedis.jedisPool.returnBrokenResource(jedis);
    e.printStackTrace();
}finally {
    //返还到连接池
    initRedis.close(jedis);
}
}

Hash功能

Public void stringOperate(){
    Try{
    //获取连接类实例
    InitRedisClient initRedis = InitRedisClient.getInstance();
    //打开redis连接
    initRedis.open();
    Jedis jedis = initRedis.jedis;
    //向名称为key的hash中添加元素field<—>value
    Jedis.hset(key, field, value)
    //返回名称为key的hash中field对应的value
    Jedis.hget(key, field)
    //返回名称为key的hash中field i对应的value
    Jedis.hmget(key, field1, …,field N)
    //向名称为key的hash中添加元素field i<—>value i
    jedis.hmset(key, field1, value1,…,field N, value N)：
    //将名称为key的hash中field的value增加integer
    Jedis.hincrby(key, field, integer)
    //名称为key的hash中是否存在键为field的域
    Jedis.hexists(key, field)
    //删除名称为key的hash中键为field的域
    Jedis.hdel(key, field)
    //返回名称为key的hash中元素个数
    Jedis.hlen(key)
    //返回名称为key的hash中所有键
    Jedis.hkeys(key)
    //返回名称为key的hash中所有键对应的value
    Jedis.hvals(key)
    //返回名称为key的hash中所有的键（field）及其对应的value
    Jedis.hgetall(key)
}catch (Exception e) {
        //释放redis对象
    initRedis.jedisPool.returnBrokenResource(jedis);
    e.printStackTrace();
}finally {
    //返还到连接池
    initRedis.close(jedis);
}
}