Redis应用（三）——在非框架中的应用

IOTool类：

package com.lq.tool;

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

/**
 * IO流工具类
 * 
 * @author GaoHuanjie
 */
public class IOTool {

	/**
	 * 将对象转换为二进制数据，即序列化对象
	 * 
	 * @author GaoHuanjie
	 */
	public static byte[] toByteArray(Object obj) {
		byte[] bytes = null;
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		try {
			ObjectOutputStream oos = new ObjectOutputStream(bos);
			oos.writeObject(obj);
			oos.flush();
			bytes = bos.toByteArray();
			oos.close();
			bos.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		return bytes;
	}
	
	/**
	 * 将二进制数据转为对象，即反序列化对象
	 * 
	 * @author GaoHuanjie
	 */
	public static Object toObject(byte[] bytes) {
		Object obj = null;
		try {
			ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bis);
			obj = ois.readObject();
			ois.close();
			bis.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		} catch (ClassNotFoundException ex) {
			ex.printStackTrace();
		}
		return obj;
	}
}

RedisTool类：

package com.lq.tool;

import java.net.SocketTimeoutException;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * RedisTool工具类
 * 
 * @author GaoHuanjie
 */
public class RedisTool {

	private static Logger logger = LoggerFactory.getLogger(RedisTool.class);

	private static JedisPool pool = null;

	{
		if (pool == null) {
			JedisPoolConfig config = new JedisPoolConfig();
			// 控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
			// 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
			// config.setMaxActive(500);
			config.setMaxTotal(40);
			// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
			config.setMaxIdle(20);
			// 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
			config.setMaxWaitMillis(1000 * 2);
			// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
			config.setTestOnBorrow(true);
			// 10000为timeout，由于没有为redis设置密码，所以这里调用该构造函数
			pool = new JedisPool(config, "127.0.0.1", 6379, 10000);
		}
	}

	/**
	 * 获取Jedis对象，一个对象代表一次Java代码与Redis的连接
	 * 
	 * @author GaoHuanjie
	 */
	private Jedis getJedis() {
		int timeoutCount = 0;
		while (true) {// 如果是网络超时则多试几次
			try {
				return pool.getResource();
			} catch (Exception e) {
				// 底层原因是SocketTimeoutException，不过redis已经捕捉且抛出JedisConnectionException，不继承于前者 e.printStackTrace();
				if (e instanceof JedisConnectionException || e instanceof SocketTimeoutException) {
					timeoutCount++;
					logger.warn("getJedis timeoutCount={}", timeoutCount);
					System.out.println("getJedis timeoutCount={}" + timeoutCount);
					if (timeoutCount > 3) {
						break;
					}
				} else {
					logger.warn("jedisInfo。NumActive=" + pool.getNumActive() + ", NumIdle=" + pool.getNumIdle()
							+ ", NumWaiters=" + pool.getNumWaiters() + ", isClosed=" + pool.isClosed());
					logger.error("getJedis error", e);
					System.out.println("jedisInfo。NumActive=" + pool.getNumActive() + ", NumIdle=" + pool.getNumIdle()
							+ ", NumWaiters=" + pool.getNumWaiters() + ", isClosed=" + pool.isClosed());
					break;
				}
			}
		}
		return null;
	}
	
	/**
	 * 释放连接资源
	 * 
	 * @param pool
	 * @param redis
	 */
	private void close(Jedis jedis) {
		if (jedis != null) {
			jedis.quit();
			jedis.close();
		}
	}
	
	/**
	 * 添加数据
	 * 
	 * @author GaoHuanjie
	 */
	public boolean save(String key, Object obj) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			final String result = jedis.set(IOTool.toByteArray(key), IOTool.toByteArray(obj));
			return StringUtils.equals(result, "OK");
		} catch (Exception e) {
			return false;
		} finally {
			close(jedis);
		}
	}
	
	/**
	 * 删除数据
	 * 
	 * @author GaoHuanjie
	 */
	public boolean delete(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.del(IOTool.toByteArray(key));
			return true; // 暂时未知判断成功与否
		} finally {
			close(jedis);
		}
	}

	/**
	 * 获取对象
	 * 
	 * @author GaoHuanjie
	 */
	public Object get(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			if (!jedis.exists(IOTool.toByteArray(key))) {
				return null;
			}
			return IOTool.toObject(jedis.get(IOTool.toByteArray(key)));
		} catch (Exception e) {
			return null;
		} finally {
			close(jedis);
		}
	}
}

Test类：

package com.lq.test;

import java.io.Serializable;

import com.lq.tool.RedisTool;

public class Test {

	public static void main(String[] args) {
		RedisTool redisTool = new RedisTool();
		redisTool.save("name", "gaohuanjie");
		System.out.println("删除前："+redisTool.get("name"));
		redisTool.delete("name");
		System.out.println("删除后："+redisTool.get("name"));
		
		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~操作自定义对象~~~~~~~~~~~~~~~~~~~~~~~~~~~");
		Student student = new Student();
		redisTool.save("student", student);//此时Student类必须实现Serializable接口
		student = (Student)redisTool.get("student");
		student.say();
	}
}

class Student implements Serializable{

	private static final long serialVersionUID = -2093251712448621079L;

	public void say() {
		System.out.println("Hello Redis");
	}
}

效果：

Redis应用（三）——在非框架中的应用

猜你喜欢