Java操作Redis数据（java项目中redis使用实例）

上一篇文章介绍了Redis的安装配置，本文主要介绍Redis数据结构和命令，以及在Java中操作Redis数据。

一、Redis数据结构

Redis可以存储键与5中不同数据结构之间的映射关系，这5中数据结构分别是STRING（字符串）、LIST（列表）、SET（集合）、HASH（散列）、ZSET（有序集合）。

1、字符串命令

2、Hash命令

3、列表命令

4、集合命令

5、有序集合命令

二、Java操作Redis

在开发过程中Redis数据操作主要是代码中操作，Java调用Redis主要用到jedis，支持事务、管道等实现。首先启动Redis服务，使用Java代码作为客户端进行连接和数据操作。

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

public class RedisUtil {
    private static JedisPool jedisPool = null;

    /**
     * 初始化Redis连接池
     */
    private static void initialPool(){
        try {
            //redis连接池配置对象
            JedisPoolConfig config = new JedisPoolConfig();
            //在指定时刻通过pool能够获取到的最大的连接的jedis个数,默认8
            config.setMaxTotal(8);
            // 最大能够保持idle的数量，控制一个pool最多有多少个状态为idle的jedis实例，默认8
            config.setMaxIdle(8);
            // 在容器中的最小的闲置连接数，默认0
            config.setMinIdle(0);
            // 当连接池内的连接耗尽时，getBlockWhenExhausted为true时，连接会阻塞，
            // 超过了阻塞的时间（设定的maxWaitMillis，单位毫秒）时会报错
            //默认-1
            config.setMaxWaitMillis(1000);
            //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；默认是false
            config.setTestOnBorrow(true);
            //testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，
            // 如果validate失败，此object会被从pool中drop掉；
            // 这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；默认是false
            config.setTestWhileIdle(false);
            //timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数，逐出扫描的时间间隔（毫秒），
            // 如果为负数，则不运行逐出线程，默认为-1
            config.setTimeBetweenEvictionRunsMillis(-1);
            //通过连接池获取redis对象,并设置ip 端口 过期时间 密码 默认库的实例
            JedisPool jdpool = new JedisPool(config, "127.0.0.1", 6379, 10000, null, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 在多线程环境同步初始化
     */
    private static synchronized void poolInit() {
        if (jedisPool == null) {
            initialPool();
        }
    }


    /**
     * 同步获取Jedis实例
     * @return Jedis
     */
    public synchronized static Jedis getJedis() {
        if (jedisPool == null) {
            poolInit();
        }
        Jedis jedis = null;
        try {
            if (jedisPool != null) {
                jedis = jedisPool.getResource();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            returnResource(jedis);
        }
        return jedis;
    }


    /**
     * 释放jedis资源
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null && jedisPool !=null) {
            jedisPool.returnResource(jedis);
        }
    }


    /**
     * 设置 String
     * @param key
     * @param value
     */
    public static void setString(String key ,String value){
        try {
            value = value.equals("") ? "" : value;
            getJedis().set(key,value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 设置 过期时间
     * @param key
     * @param seconds 以秒为单位
     * @param value
     */
    public static void setString(String key ,int seconds,String value){
        try {
            value = value.equals("") ? "" : value;
            getJedis().setex(key, seconds, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取String值
     * @param key
     * @return value
     */
    public static String getString(String key){
        if(getJedis() == null || !getJedis().exists(key)){
            return null;
        }
        return getJedis().get(key);
    }
}

如果是分布式项目，设置有主从Redis或者集群，需要使用ShardedJedis和ShardedJedisPool。

import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

import java.util.ArrayList;
import java.util.List;

public class RedisUtils {

    private static ShardedJedisPool jedisPool = null;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

        //设置最大对象数
        jedisPoolConfig.setMaxTotal(20);

        //设置最大能够保持空闲状态的对象数
        jedisPoolConfig.setMaxIdle(10);

        //超出时间
        jedisPoolConfig.setMaxWaitMillis(10000);

        //设置获取连接的时候检查有效性，默认false
        jedisPoolConfig.setTestOnBorrow(true);

        //在返回object时，对返回的connection进行validateObject校验
        jedisPoolConfig.setTestOnReturn(true);

        //如果是集群，全部加入到list中
        List<JedisShardInfo> list = new ArrayList<JedisShardInfo>();
        JedisShardInfo jedisShardInfo = new JedisShardInfo("127.0.0.1","6379");
        jedisShardInfo.setPassword("redis123.");

        list.add(jedisShardInfo);

        jedisPool = new ShardedJedisPool(jedisPoolConfig,list);
    }

    /**
     * 从连接池中获取一个ShardedJedis对象
     */
    public static ShardedJedis getJedis() {
        return jedisPool.getResource();
    }

    /**
     * 关闭ShardedJedis,放回池中
     */
    public static void closeJedis(ShardedJedis shardedJedis) {
        shardedJedis.close();
    }

    /**
     * 通过key获取String类型value
     * @param key
     * @return
     */
    public static String get(String key) {
        ShardedJedis jedis = jedisPool.getResource();
        return jedis.get(key);
    }

    /**
     * 设置String类型的key和value
     * @param key
     * @param value
     * @return
     */
    public static String set(String key,String value) {
        ShardedJedis jedis = jedisPool.getResource();
        return jedis.set(key,value);
    }

    /**
     * 删除指定key
     * @param key
     * @return
     */
    public static Long del(String key) {
        ShardedJedis jedis = jedisPool.getResource();
        return jedis.del(key);
    }

    /**
     * 左侧放入集合
     * @param key
     * @param values
     * @return
     */
    public static Long lpush(String key,String... values){
        ShardedJedis jedis = jedisPool.getResource();
        return jedis.lpush(key,values);
    }

    /**
     * 左侧弹出一个元素
     * @param key
     * @return
     */
    public static String lpop(String key) {
        ShardedJedis jedis = jedisPool.getResource();
        return jedis.lpop(key);
    }

    /**
     * 右侧放入集合
     * @param key
     * @param values
     * @return
     */
    public static Long rpush(String key,String... values) {
        ShardedJedis jedis = jedisPool.getResource();
        return jedis.rpush(key,values);
    }

    /**
     * 右侧弹出一个元素
     * @param key
     * @return
     */
    public static String rpop(String key) {
        ShardedJedis jedis = jedisPool.getResource();
        return jedis.rpop(key);
    }

    public static void main(String[] args) {
       RedisUtils.set("name","dgy");
    }
}