来自文章集合：一文带你搞懂redis使用过程（持续更新中）

java可通过jedis包来对redis进行交互。

Jedis是一个用于java语言的简单且强大的Redis客户端库。他提供了许多操作Redis数据库的方法和函数，使Java开发人员能够轻松地与Redis数据库进行交互。Jedis库的目的是让Java应用程序能够通过简单而直接的方式与Redis服务器通信，从而实现数据的存储、检索、更新和删除等操作。

下面是maven导入命令，也可以直接下载jar包导入项目

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.0.1</version>
</dependency>

思路

通过使用Jedis，Java开发人员可以方便地连接到Redis数据库，并使用各种命令和操作来处理键值数据。Jedis提供了与String、Hash、List、Set、Sorted Set等数据结构交互的方法，使得开发人员能够通过Java代码来操作这些数据结构，而无需了解复杂的Redis协议细节。

为了避免创建大量与redis的socket连接，减少创建和断开连接的开销，提高操作的效率，我们还需要引入JedisPool(连接池)。JedisPool使用JedisConfig来配置连接池的一些属性，比如：最大连接数、最大空闲连接数等。

• 创建一个GlobalRedisMgr管理类，启动时加载相关配置到JedisPoolConfig并创建JedisPool实例，JedisPool用于从池子中获取jedis实例

• 创建一个RedisSession类，类中含有一个jedis对象，通过jedis对象操作redis

public class GlobalRedisMgr implements AutoCloseable {

    private JedisPool jedisPool;

    public RedisSession getSession(){
        return new RedisSession(jedisPool.getResource());
    }

    public void onServerStart(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(128);     //连接池中连接的最大数量。当所有连接都被使用时，新的请求将等待直到有连接可用。
        poolConfig.setMaxIdle(128);     //连接池中空闲连接最大数目。如果空闲连接超过这个数量，多余的空间连接奖杯关闭。
        poolConfig.setMinIdle(1);       //连接池中保持的最小空闲连接数。如果空闲连接少于这个数量，连接池将创建更多的连接以保持这个数量

        /**
        网络不稳定或连接中断：
         当网络不稳定或连接中断时，连接池中的连接可能会变得无效。通过设置testOnBorrow和testOnReturn，可以在获取连接和归还连接时验证连接的有效性，确保连接处于可用状态。

        连接超时：
         某些情况下，连接可能因为长时间的闲置而超时，或者因为某些网络原因导致连接长时间没有响应。
         在这种情况下，使用testOnBorrow和testOnReturn可以帮助你检测这些超时连接，并且确保从连接池中获取的连接都是有效的。
         */
        poolConfig.setTestOnBorrow(false);  //当你从连接池中获取连接时，该选项会决定是否验证连接的有效性。如果设置为true，那么在获取连接时，连接池会先验证连接是否仍然有效。如果连接无效，则连接池会丢弃该连接并尝试重新获取一个新的连接。
        poolConfig.setTestWhileIdle(true);  //如果设置为true，连接池将定期验证空闲连接是否仍然有效
        poolConfig.setTestOnReturn(false);   //类似于testOnBorrow，不过在归还连接到连接池时进行验证，检查不通过，销毁连接

        poolConfig.setMaxWait(Duration.ofMillis(50));   //它代表从连接池中获取连接时最大的等待时间。当连接池没有可用连接时，新的请求可能需要等待其他连接释放，以便获取可用的连接。maxWait 参数规定了在这种等待情况下的最长等待时间。


        jedisPool = new JedisPool(poolConfig,"127.0.0.1",6379,3000,"root");
    }

    @Override
    public void close() throws Exception {
        try{
            jedisPool.close();
        }catch (Exception e){
            Debug.err("close jedis pool is err",e);
        }
    }
}

public class RedisSession implements AutoCloseable{
	private Jedis jedis;

	public RedisSession () {
	}

	public RedisSession (Jedis jedis) {
		this.jedis = jedis;
	}

	public void setJedis(Jedis jedis) {
		this.jedis = jedis;
	}
	
	//######################################################################
	//保存储存对象 利用fastjson
	//######################################################################
	public <T> T setObject (String key, T value, int expireTimeSecs){
		if (expireTimeSecs < 0) {
			throw new IllegalArgumentException("expire time sec  <= 0 ");
		}
		String code;
		if (expireTimeSecs == 0) {
			code = jedis.set(key, JSON.toJSONString(value));
		} else {
			code = jedis.setex(key, expireTimeSecs, JSON.toJSONString(value));
		}
		if (!"OK".equalsIgnoreCase(code)) {
			Debug.error("[REDIS] put redis error key :"+key);
		}
		return value;
	}
	
	public <T extends Serializable> T setObject (String key, T value){
		return setObject(key, value, 0);
	}
	
	public <T> T getObject(String key, Class<T> clazz) {
		String val = jedis.get( key );
		if(val == null){
			return null;
		}
		
		return JSON.parseObject(val, clazz);
	}
	
	public Object getObject(String key) {
		return JSON.parse(jedis.get(key));
	}
	
	public String getString(String key) {
		return jedis.get(key);
	}
	
	public Jedis getJedis() {
		return jedis;
	}

	public Pipeline pipelined() {
		return jedis.pipelined();
	}

	public String set(String key, String value) {
		return jedis.set(key, value);
	}
	
	public String set(String key, String value, int expireSec) {
		if(expireSec == 0){
			return jedis.set( key,  value );
		}
		else {
			return jedis.setex( key, expireSec, value );
		}
	}

	public String set(String key, String value, String nxxx, String expx, long time) {
		return jedis.set(key, value, nxxx, expx, time);
	}

	public String get(String key) {
		return jedis.get(key);
	}

	public Long exists(String... keys) {
		return jedis.exists(keys);
	}

	public Boolean exists(String key) {
		return jedis.exists(key);
	}

	public Long delMulti (String... keys) {
		if(keys.length == 0){
			return 0L;
		}
		return jedis.del(keys);
	}

	public Long del(String key) {
		return jedis.del(key);
	}

	public Set<String> keys(String pattern) {
		return jedis.keys(pattern);
	}

	public Long expire(String key, int seconds) {
		return jedis.expire(key, seconds);
	}

	public Long expireAt(String key, long unixTime) {
		return jedis.expireAt(key, unixTime);
	}

	public List<String> mget(String... keys) {
		return jedis.mget(keys);
	}

	public Map<String, String> mget(Collection<String> keys) {
		return mget(keys, true, "", false);
	}

	public Map<String, String> mget(Collection<String> keys, String keyPrefix) {
		return mget(keys, true, keyPrefix, false);
	}

	/**
	 * @param keys
	 * @param skipNull
	 * @param keyPrefix
	 * @param keepPrefix
	 * @return
	 */
	public Map<String, String> mget(Collection<String> keys, boolean skipNull, String keyPrefix, boolean keepPrefix) {
		if (keys == null || keys.size() == 0) {
			return Collections.EMPTY_MAP;
		}
		String[] keyArr = new String[keys.size()];
		keys.toArray(keyArr);
		return mget(keyArr, skipNull, keyPrefix, keepPrefix);
	}

	public Map<String, String> mgetMap(String... keys) {
		return mget(keys, true, "", true);
	}

	/**
	 * 批量获取keys的值，返回一个map
	 *
	 * @param keys       需要获取的key数组
	 * @param skipNull   是否忽略掉null值的key
	 * @param keyPrefix  所有key需要增加的prefix
	 * @param keepPrefix 返回的map中，key是否包含prefix的值
	 * @return
	 */
	public Map<String, String> mget(String[] keys, boolean skipNull, String keyPrefix, boolean keepPrefix) {
		if (keys == null || keys.length == 0) {
			return Collections.EMPTY_MAP;
		}
		String[] keysWithPrefix = getKeysWithPrefix(keys, keyPrefix);
		return multiGet(keys, skipNull, keysWithPrefix, keepPrefix);
	}

	private Map<String, String> multiGet(String[] keys, boolean skipNull, String[] keysWithPrefix, boolean keepPrefix) {
		Map<String, String> ret;
		List<String> value = jedis.mget(keysWithPrefix);
		ret = new HashMap<>(value.size());
		String val;
		for (int i = 0; i < keys.length; ++i) {
			val = value.get(i);
			if (skipNull && val == null) {
				continue;
			}
			if (keepPrefix) {
				ret.put(keysWithPrefix[i], val);
			} else {
				ret.put(keys[i], val);
			}
		}
		return ret;
	}

	private String[] getKeysWithPrefix(String[] keys, String keyPrefix) {
		String[] prefKeys;
		// 这里用blank判断，是要求prefix不能是空格
		if (StringUtils.isNotBlank(keyPrefix)) {
			prefKeys = new String[keys.length];
			for (int i = 0; i < keys.length; ++i) {
				prefKeys[i] = keyPrefix + keys[i];
			}
		} else {
			prefKeys = keys;
		}
		return prefKeys;
	}
	public Long setnx(String key, String value) {
		return jedis.setnx(key, value);
	}

	public String setex(String key, int seconds, String value) {
		return jedis.setex(key, seconds, value);
	}

	public String mset(String... keysvalues) {
		return jedis.mset(keysvalues);
	}

	public Long msetnx(String... keysvalues) {
		return jedis.msetnx(keysvalues);
	}

	public Long decrBy(String key, long integer) {
		return jedis.decrBy(key, integer);
	}

	public Long decr(String key) {
		return jedis.decr(key);
	}

	public Long incrBy(String key, long integer) {
		return jedis.incrBy(key, integer);
	}

	public Long incr(String key) {
		return jedis.incr(key);
	}

	public Long append(String key, String value) {
		return jedis.append(key, value);
	}

	public Long hset(String key, String field, String value) {
		return jedis.hset(key, field, value);
	}

	public Long hset(String key, String field, byte[] bytes) {
		return jedis.hset(SafeEncoder.encode(key), SafeEncoder.encode(field), bytes);
	}

	public byte[] hgetBin(String key, String field) {
		return jedis.hget(SafeEncoder.encode(key), SafeEncoder.encode(field));
	}

	public String hget(String key, String field) {
		return jedis.hget(key, field);
	}

	public Long hsetnx(String key, String field, String value) {
		return jedis.hsetnx(key, field, value);
	}

	public String hmset(String key, Map<String, String> hash) {
		return jedis.hmset(key, hash);
	}

	public List<String> hmget(String key, String... fields) {
		return jedis.hmget(key, fields);
	}

	public Long hincrBy(String key, String field, long value) {
		return jedis.hincrBy(key, field, value);
	}

	public Boolean hexists(String key, String field) {
		return jedis.hexists(key, field);
	}

	public Long hdel(String key, String... fields) {
		return jedis.hdel(key, fields);
	}

	public Map<String, String> hgetAll(String key) {
		return jedis.hgetAll(key);
	}

	public Long rpush(String key, String... strings) {
		return jedis.rpush(key, strings);
	}

	public Long lpush(String key, String... strings) {
		return jedis.lpush(key, strings);
	}

	public Long llen(String key) {
		return jedis.llen(key);
	}

	public List<String> lrange(String key, long start, long end) {
		return jedis.lrange(key, start, end);
	}

	public String ltrim(String key, long start, long end) {
		return jedis.ltrim(key, start, end);
	}

	public String lpop(String key) {
		return jedis.lpop(key);
	}

	public String blpop(String key, int timeout) {
		List<String> strings = jedis.blpop(timeout, key);
		if (strings == null || strings.size() < 2) {
			return null;
		}
		return strings.get(1);
	}

	public byte[] lpopBin(String key) {
		return jedis.lpop(SafeEncoder.encode(key));
	}
	
	public String rpop(String key) {
		return jedis.rpop(key);
	}

	public String rpoplpush(String srckey, String dstkey) {
		return jedis.rpoplpush(srckey, dstkey);
	}

	public Long sadd(String key, String... members) {
		return jedis.sadd(key, members);
	}

	public List<String> srandom(String key,int count){
		return jedis.srandmember(key,count);
	}

	public Set<String> smembers(String key) {
		return jedis.smembers(key);
	}

	public Long scard(String key) {
		return jedis.scard(key);
	}

	public Boolean sismember(String key, String member) {
		return jedis.sismember(key, member);
	}

	public Long srem(String key, String... members) {
		return jedis.srem(key, members);
	}

	public String spop(String key) {
		return jedis.spop(key);
	}

	public Set<String> spop(String key, long count) {
		return jedis.spop(key, count);
	}

	public Long zadd(String key, double score, String member) {
		return jedis.zadd(key, score, member);
	}
	
	public Long multiZadd(String key,Map<String,Double> map) {
		return jedis.zadd( key, map );
	}

	public Long zadd(String key, double score, String member, ZAddParams params) {
		return jedis.zadd(key, score, member, params);
	}

	public Long zadd(String key, Map<String,Double> map) {
		return jedis.zadd(key,map);
	}

	public Set<String> zrange(String key, long start, long end) {
		return jedis.zrange(key, start, end);
	}
	public Set<String> zrangeByScore(String key, double min,double max,int offset,int count) {
        return jedis.zrangeByScore(key, min, max, offset, count);
    }
	public Long zrank(String key, String member) {
		return jedis.zrank(key, member);
	}

	public Long zrevrank(String key, String member) {
		return jedis.zrevrank(key, member);
	}

	public Set<String> zrevrange(String key, long start, long end) {
		return jedis.zrevrange(key, start, end);
	}
	
	public Set<Tuple> zrevrangeWithScores(String key, long start, long end) {
        return jedis.zrevrangeWithScores(key, start, end);
    }

	public Object eval(String script, int keyCount, String... params) {
		return jedis.eval(script, keyCount, params);
	}

	public Object eval(String script, List<String> keys, List<String> args) {
		return jedis.eval(script, keys, args);
	}

	public Object eval(String script) {
		return jedis.eval(script);
	}

	public Object evalsha(String script) {
		return jedis.evalsha(script);
	}

	public Object evalsha(String sha1, List<String> keys, List<String> args) {
		return jedis.evalsha(sha1, keys, args);
	}

	public Object evalsha(String sha1, int keyCount, String... params) {
		return jedis.evalsha(sha1, keyCount, params);
	}

	public Boolean scriptExists(String sha1) {
		return jedis.scriptExists(sha1);
	}

	public List<Boolean> scriptExists(String... sha1) {
		return jedis.scriptExists(sha1);
	}

	public String scriptLoad(String script) {
		return jedis.scriptLoad(script);
	}

	public Long zcard(String key) {
		return jedis.zcard(key);
	}

	public Double zscore(String key, String member) {
		return jedis.zscore(key, member);
	}
	
	public Long zrem(String key, String member) {
        return jedis.zrem(key, member);
    }
	public Long zrem(String key, String... members) {
        return jedis.zrem(key, members);
    }
	public void subscribe(JedisPubSub listener, Set<String> channels) {
		if (!channels.isEmpty()) {
			jedis.subscribe(listener, channels.toArray(new String[]{}));
		}
	}

	public void subscribe(JedisPubSub jedisPubSub, String... channels) {
		jedis.subscribe(jedisPubSub, channels);
	}

	public Long publish(String channel, String message) {
		return jedis.publish(channel, message);
	}

	public Long zunionstore(String dstkey, ZParams params, String... sets) {
		return jedis.zunionstore(dstkey, params, sets);
	}

	public Long zremrangeByScore(String key, double start, double end) {
		return jedis.zremrangeByScore(key, start, end);
	}

	public Double zincrby(String key, double score, String member){return jedis.zincrby(key,score,member);}
	
	
	

	@Override
	public void close(){
		if (jedis != null){
			jedis.close();
			jedis = null;
		}
	}

具体使用根据实际业务需求可在进行增减。

最后

希望对大家有所帮助，以上内容就到这里，感谢各位看官老爷们的观看，后续我会写数据库转换工具和配表转换工具包，如果觉得写得好，给个赞支持一下哈！！！