jedis

程序员文章站 2022-07-04 17:01:56

...

public interface JRedisService {
	/**
	 * 
	 * @Description （删除键）
	 * @param key
	 * @date 2017年12月26日
	 */
	public void deleteKey(String... key);

	/**
	 * 
	 * @Description （判断key是否存在）
	 * @param key
	 * @return
	 * @date 2017年12月26日
	 */
	public boolean exists(String key);

	/**
	 * 
	 * @Description （设置key和value）
	 * @param key
	 * @param value
	 * @date 2017年12月26日
	 */
	public void set(String key, Object value);

	/**
	 * 
	 * @Description （设置key和value）
	 * @param key
	 * @param value
	 * @param isExpire
	 *            是否缓存
	 * @date 2018年10月20日
	 */
	public void set(String key, Object value, boolean isExpire);

	/**
	 * 
	 * @Description （设置key和value）
	 * @param key
	 * @param value
	 * @param seconds
	 *            缓存时间，单位秒
	 * @date 2018年10月20日
	 */
	public void set(String key, Object value, int seconds);

	/**
	 * 
	 * @Description （获取值）
	 * @param key
	 * @return
	 * @date 2017年12月26日
	 */
	public <T> T getBykey(String key);

	/**
	 * 
	 * @Description （设置String类型：key和value）
	 * @param key
	 * @param value
	 * @date 2018年11月15日
	 */
	public void setString(String key, String value);

	/**
	 * 
	 * @Description （设置String类型：key和value，是否缓存）
	 * @param key
	 * @param value
	 * @param isExpire
	 * @date 2018年11月15日
	 */
	public void setString(String key, String value, boolean isExpire);

	/**
	 * 
	 * @Description （设置String类型：key和value，设置时间）
	 * @param key
	 * @param value
	 * @param seconds
	 * @date 2018年11月15日
	 */
	public void setString(String key, String value, int seconds);

	/**
	 * 
	 * @Description （获取String值）
	 * @param key
	 * @return
	 * @date 2018年11月15日
	 */
	public String getSring(String key);

	/**
	 * 
	 * @Description （删除String值）
	 * @param key
	 * @date 2018年11月15日
	 */
	public void delString(String key);

}

import org.springframework.stereotype.Service;

import com.hesc.sifa.service.JRedisService;
import com.hesc.sifa.utils.JRedisUtils;
import com.hesc.sifa.utils.SerializeUtils;
import com.hesc.sifa.utils.StrToolUtils;
import com.hesc.trundle.message.Message;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;

@Service("jRedisService")
public class JRedisServiceImpl implements JRedisService {

	// 单位是秒，默认10分钟
	private final static int EXPIRE = Integer.parseInt(Message.getMessage("redis.expire"));

	/**
	 * 
	 * @Description （删除键）
	 * @param key
	 * @date 2017年12月26日
	 */
	public void deleteKey(String... key) {
		Jedis jedis = JRedisUtils.getJedis();
		if (jedis != null) {
			try {
				jedis.del(key);
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
		}
	}

	/**
	 * 
	 * @Description （判断key是否存在）
	 * @param key
	 * @return
	 * @date 2017年12月26日
	 */
	public boolean exists(String key) {
		Jedis jedis = JRedisUtils.getJedis();
		boolean flag = false;
		if (jedis != null) {
			try {
				flag = jedis.exists(key);
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
		}
		return flag;
	}

	/**
	 * 
	 * @Description （设置key和value）
	 * @param key
	 * @param value
	 * @date 2017年12月26日
	 */
	public void set(String key, Object value) {
		set(key, value, true, EXPIRE);
	}

	public void set(String key, Object value, boolean isExpire) {
		set(key, value, isExpire, EXPIRE);
	}

	public void set(String key, Object value, int seconds) {
		set(key, value, true, seconds);
	}

	public void set(String key, Object value, boolean isExpire, int seconds) {
		Jedis jedis = JRedisUtils.getJedis();
		if (jedis != null) {
			try {
				jedis.set(key.getBytes(), SerializeUtils.serialize(value));
				if (isExpire) {
					jedis.expire(key.getBytes(), seconds);
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
		}
	}

	/**
	 * 
	 * @Description （获取值）
	 * @param key
	 * @return
	 * @date 2017年12月26日
	 */
	@SuppressWarnings("unchecked")
	public <T> T getBykey(String key) {
		Jedis jedis = JRedisUtils.getJedis();
		byte[] byt = null;
		if (jedis != null) {
			try {
				byt = jedis.get(key.getBytes());
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
			if (null == byt) {
				return null;
			} else {
				return (T) SerializeUtils.unserialize(byt);
			}
		}
		return null;
	}

	/**
	 * 
	 * @Description （设置key和value）
	 * @param key
	 * @param value
	 * @date 2017年12月26日
	 */
	public void setString(String key, String value) {
		setString(key, value, true, EXPIRE);
	}

	public void setString(String key, String value, boolean isExpire) {
		setString(key, value, isExpire, 0);
	}

	public void setString(String key, String value, int seconds) {
		setString(key, value, true, seconds);
	}

	public void setString(String key, String value, boolean isExpire, int seconds) {
		Jedis jedis = JRedisUtils.getJedis();
		if (jedis != null) {
			try {
				Pipeline pipeline = jedis.pipelined();
				jedis.set(key, value);
				if (isExpire) {
					jedis.expire(key, seconds);
				}
				pipeline.sync();
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
		}
	}

	/**
	 * 
	 * @Description （获取值）
	 * @param key
	 * @return
	 * @date 2017年12月26日
	 */
	public String getSring(String key) {
		Jedis jedis = JRedisUtils.getJedis();
		String value = "";
		if (jedis != null) {
			try {
				value = jedis.get(key);
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
			return StrToolUtils.isEmptyDefault(value);
		}
		return value;
	}

	/**
	 * 
	 * @Description （删除key）
	 * @param key
	 * @date 2018年11月15日
	 */
	public void delString(String key) {
		Jedis jedis = JRedisUtils.getJedis();
		if (jedis != null) {
			try {
				jedis.del(key);
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
		}
	}
}

import org.apache.log4j.Logger;

import com.hesc.trundle.message.Message;

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

public class JRedisUtils {
	private static final Logger log = Logger.getLogger(JRedisUtils.class);
	private static JedisPool jedisPool = null;
	// Redis服务器IP
	private static String ADDR = Message.getMessage("redis.addr");
	// Redis的端口号
	private static int PORT = Integer.parseInt(Message.getMessage("redis.port"));
	private static int MaxTotal = Integer.parseInt(Message.getMessage("redis.maxTotal"));
	private static int MaxWait = Integer.parseInt(Message.getMessage("redis.maxWait"));
	private static int MaxIdle = Integer.parseInt(Message.getMessage("redis.maxIdle"));

	static {
		initPool();
	}

	/**
	 * 
	 * @Description （初始化Redis连接池）
	 * @date 2017年12月26日
	 */
	private static synchronized void initPool() {
		try {
			if (jedisPool == null) {
				// 初始化非切片池
				jedisPool = new JedisPool(getJedisPoolConfig(), ADDR, PORT, MaxWait);
			}
		} catch (Exception e) {
			log.error(e);
		}
	}

	/**
	 * 
	 * @Description （获取配置）
	 * @return
	 * @date 2017年12月26日
	 */
	private static JedisPoolConfig getJedisPoolConfig() {
		JedisPoolConfig config = new JedisPoolConfig();
		// 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
		config.setBlockWhenExhausted(true);
		// 设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
		config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
		// 是否启用pool的jmx管理功能, 默认true
		config.setJmxEnabled(true);
		// 是否启用后今后出
		config.setLifo(true);
		// 最大连接数, 默认8个，为负数的时候没有限制。
		config.setMaxTotal(MaxTotal);
		// 最大空闲连接数, 默认8个，为负数的时候没有限制。
		config.setMaxIdle(MaxIdle);
		// 最小空闲连接数, 默认0
		// config.setMinIdle(0);
		// 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
		config.setMaxWaitMillis(MaxWait);
		// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
		config.setTestOnBorrow(false);
		// 在还会给pool时，是否提前进行validate操作
		config.setTestOnReturn(false);
		// 自动测试池中的空闲连接是否都是可用连接
		config.setTestWhileIdle(true);
		// 逐出连接的最小空闲时间
		// config.setMinEvictableIdleTimeMillis(500);
		// 对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出
		// config.setSoftMinEvictableIdleTimeMillis(500);
		// config.setTimeBetweenEvictionRunsMillis(30000);
		// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
		// config.setNumTestsPerEvictionRun(100);
		return config;
	}

	/**
	 * 获取Jedis实例
	 * 
	 * @return
	 */
	public synchronized static Jedis getJedis() {
		if (jedisPool == null) {
			initPool();
		}
		log.info("Redis活跃数=" + jedisPool.getNumActive() + "  空闲数=" + jedisPool.getNumIdle() + "  等待数="
				+ jedisPool.getNumWaiters() + "   jedisPool状态=" + jedisPool.isClosed());
		try {
			if (jedisPool.isClosed() || jedisPool.getNumActive() < 0) {
				log.info("*** 重新新建线程池jedisPool ***");
				jedisPool = null;
				initPool();
			}
			if (jedisPool != null) {
				log.info("+++ 获取Redis实例 +++");
				return jedisPool.getResource();
			} else {
				return null;
			}
		} catch (Exception e) {
			e.printStackTrace();
			log.error(e);
			return null;
		}
	}

	/**
	 * 释放jedis资源
	 * 
	 * @param jedis
	 */
	public synchronized static void close(final Jedis jedis) {
		try {
			if (jedis != null) {
				// 高版本采用close来归还
				log.info("jedis状态：" + jedis.isConnected());
				if (jedis.isConnected()) {
					log.info("--- 释放Redis实例 ---");
					jedis.close();
				}
			}

			// 活跃数超过一定的数量时，进行关闭重新创造线程池
			if (jedisPool.getNumActive() > MaxTotal - 100) {
				log.info("*** jedisPool.close() ***");
				jedisPool.close();
				jedisPool.destroy();
			}
		} catch (Exception e) {
			e.printStackTrace();
			log.error(e);
			/*
			 * if (jedis.isConnected()) { jedis.quit(); jedis.disconnect(); }
			 */
			if (jedis != null) {
				// 高版本采用close来归还
				log.info("jedis状态：" + jedis.isConnected());
				if (jedis.isConnected()) {
					log.info("--- 释放Redis实例 ---");
					jedis.close();
				}
			}
			// jedisPool.close();
			// jedisPool.destroy();
		}

	}

	/**
	 * 
	 * @Description （清空库中所有数据，谨慎操作）
	 * @date 2017年12月26日
	 */
	public static void flushDatabase() {
		Jedis jedis = getJedis();
		if (jedis != null) {
			try {
				log.info("*** 清空Redis库中所有数据 ***");
				jedis.flushDB();
			} catch (Exception e) {
				e.printStackTrace();
				log.error(e);
			} finally {
				close(jedis);
			}
		}
	}

	

	public static void main(String[] args) {
		Jedis jedis = JRedisUtils.getJedis();
		if (jedis != null) {
			try {
				//jedis.set("pxc", "pxc");
				//jedis.expire("pxc", 10);
				System.out.println(jedis.get("pxc"));
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JRedisUtils.close(jedis);
			}
		}
	}
}

jedis

增强jedis连接池功能

java客户端Jedis操作Redis Sentinel实现连接池的代码分享

Spring集成jedis的配置与使用简单实例

Spring整合redis（jedis）实现Session共享的过程

Jedis对redis的五大类型操作代码详解

Redis 订阅发布_Jedis实现方法

Spring整合redis（jedis）实现Session共享的过程

Redis 订阅发布_Jedis实现方法

Java客户端利用Jedis操作redis缓存示例代码

Jedis操作Redis数据库的方法