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

ゝ一世哀愁。 2022-06-02 12:41 297阅读 0赞

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");
    	}
    }

效果：

![SouthEast][]

[SouthEast]: /images/20220602/bafdc8c9a270453389921be06def5c96.png