通过内存和文件来对对象进行缓存。 可以存储非常多的数据,但是比内存要慢,好处是不会产生内存不足的问题(理论上应该是)。 package org.sl.cache;import java.io.File;import java.io.Serializable;import java.util.LinkedList;import java.util.List;import org.apache.log4j.Logger;import org.sl.util.SerializeUtil;/** * 对象缓存 * @author shanl * * @param <T> 任何可序列的对象 */public class ObjectCache<T extends Serializable> {private static Logger logger = Logger.getLogger(ObjectCache.class);//当前的对象队列private List<T> objQueue = null;//用于临时交换对象的暂存区private List<T> swap = null;//缓存文件队列private List<File> cacheFileQueue = null;//缓存允许的最大数private int cacheMaxSize = 0;/** * 可设置缓存容量的缓存器 * @param cacheMaxSize */public ObjectCache(int cacheMaxSize){this.setCacheMaxSize(cacheMaxSize);this.objQueue = new LinkedList<T>();this.cacheFileQueue = new LinkedList<File>();}/** * 用默认缓存容量初始化的缓存器 */public ObjectCache(){this(500);}/** * 压入一条日志 * @param obj */public void push(T obj){if(null != obj){objQueue.add(obj);if(objQueue.size() > cacheMaxSize){serialize();}// }else{// try {// Thread.sleep(1);// } catch (Exception e) {// }// }}}/** * 弹出一条日志 * @return 如果返回null,则表示缓存中已没有日志 */public T pop(){File file = null;synchronized(this){if(null == swap || swap.isEmpty()){if(cacheFileQueue.isEmpty()){if(objQueue.isEmpty()){return null;}else{swap = objQueue;return pop();}}else{file = cacheFileQueue.remove(0);swap = deserialize(file);return pop();}}else{return swap.remove(0);}}}/** * 设置最大缓存数 * @param cacheMaxSize 不能小于200或大于10000 */private void setCacheMaxSize(int cacheMaxSize){if(200 > cacheMaxSize || 10000 < cacheMaxSize){throw new IllegalArgumentException("200 > cacheMaxSize || 10000 < cacheMaxSize");}this.cacheMaxSize = cacheMaxSize;}/** * 将文件中的对象反序化 * @param file * @return */private List<T> deserialize(File file){logger.debug("反序列化文件:" + file.getName());List<T> ls = null;try {ls = (List<T>) SerializeUtil.deserialize(file);file.delete();} catch (Exception ex) {logger.error(ex.getMessage(), ex);ls = new LinkedList<T>();throw new RuntimeException(ex);}return ls;}/** * 将一个对象序列化到文件 */private void serialize(){List<T> seriQueue = null;File cacheFile = null;try{synchronized(this){if(!objQueue.isEmpty()){seriQueue = new LinkedList<T>(objQueue.subList(0, objQueue.size()));cacheFile = File.createTempFile("objCache_", null);SerializeUtil.serialize(cacheFile, seriQueue);logger.debug("创建缓存文件:" + cacheFile.getName());objQueue.clear();cacheFileQueue.add(cacheFile);cacheFile.deleteOnExit();}}}catch(Exception ex){logger.error(ex.getMessage(), ex);if(null != cacheFile){cacheFile.delete();cacheFileQueue.remove(cacheFile);}throw new RuntimeException(ex);}}} package org.sl.util;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;/** * 序列化工具类 * @author shanl * */public class SerializeUtil {/** * 将一个对象序列化到文件 * @param file * @param obj * @throws Exception */public static void serialize(File file, Object obj) throws Exception{FileOutputStream fileOut = null;ObjectOutputStream objOut = null;// file = File.createTempFile("logCache", null);fileOut = new FileOutputStream(file);objOut = new ObjectOutputStream(fileOut);objOut.writeObject(obj);objOut.flush();if(null != objOut) objOut.close();if(null != fileOut) objOut.close();}/** * 将一个对象序列化到临时文件 * @param obj * @return 保存序列化对象的文件 * @throws Exception */public static File serialize(Object obj) throws Exception{File file = null;file = File.createTempFile("logCache", null);serialize(file, obj);return file;}/** * 将一个文件中的数据反序列化,并删除文件 * @param file * @return */public static Object deserialize(File file) throws Exception{Object obj = null;FileInputStream fileIn = null;ObjectInputStream objIn = null;fileIn = new FileInputStream(file);objIn = new ObjectInputStream(fileIn);obj = objIn.readObject();if(null != objIn) objIn.close();if(null != fileIn) fileIn.close();return obj;}}