redis和mongodb工具类

import java.io.File;
import java.io.InputStream;

import com.mongodb.gridfs.GridFSDBFile;
/**
 * Mongodb存取文件
 *
 */
public interface FileDao {
	/** 
     * 存储文件  
     * @param collectionName 集合名  
     * @param input 文件  
     * @param id 文件id  
     * @param aliases 别名
     * @param filename 文件名称 
	 * @throws Exception 
     */  
    public void saveFile(String collectionName, File input, String id, String aliases, String filename) throws Exception;
    /**
     * 存储文件 
     * @param collectionName 集合名  
     * @param input 文件流
     * @param id 文件id  
     * @param aliases 别名
     * @param filename 文件名称 
     */
    public void saveFile(String collectionName, InputStream input, String id, String aliases, String filename);
    /**
     * 存储文件 
     * @param collectionName 集合名  
     * @param input 文件字节数组
     * @param id 文件id  
     * @param aliases 别名
     * @param filename 文件名称 
     */
    public void saveFile(String collectionName, byte[] input, String id, String aliases, String filename);
    /**
     * 获得一个文件
     * @param collectionName 集合名  
     * @param id 文件id 可为空
     * @param filename 文件名 可为空
     * @return 
     */
    public GridFSDBFile retrieveFileOne(String collectionName, String id, String filename);
    /**
     * 获得一个文件
     * @param collectionName 集合名  
     * @param id 文件名id
     * @return 
     */
    public GridFSDBFile getFileById(String collectionName,String id);
    /**
     * 获得一个文件
     * @param collectionName 集合名  
     * @param filename 文件名
     * @return 
     */
    public GridFSDBFile getFileByFilename(String collectionName,String filename);
    /**	
	 * 删除文件
	 * @param collectionName 集合名
	 * @param id 文件名id
	 */
    public void delectFileById(String collectionName,String id);
    /**
     * 删除文件
     * @param collectionName 集合名
     * @param filename 文件名
     */
    public void delectFileByFilename(String collectionName,String filename);
}

import java.io.File;
import java.io.InputStream;

import javax.annotation.Resource;

import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Repository;

import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.mongodb.gridfs.GridFS;
import com.mongodb.gridfs.GridFSDBFile;
import com.mongodb.gridfs.GridFSInputFile;
import com.trustsaving.CacheMoudle.dao.FileDao;
@Repository
public class FileDaoImpl implements FileDao{
	@Resource
	protected MongoTemplate mongoTemplate;
	
	@Override
	public void saveFile(String collectionName, File input, String id,
			String aliases, String filename) throws Exception{
		if (collectionName==null||collectionName.trim().isEmpty()||input==null) {
			return;
		}
		if (!input.exists()||input.isDirectory()) {
			return;
		}
		delectFileById(collectionName,id);
		GridFS gfs =new GridFS(mongoTemplate.getDb(), collectionName);
		GridFSInputFile gfsFile = gfs.createFile(input);
		gfsFile.setId(id);
		if (filename!=null&&!filename.trim().isEmpty()) {
			gfsFile.setFilename(filename);
			gfsFile.setContentType(filename.substring(filename.lastIndexOf(".")));
		}
		if (aliases!=null&&!aliases.trim().isEmpty()) {
			gfsFile.put("aliases", aliases);  
		}
		gfsFile.save();
	}

	@Override
	public void saveFile(String collectionName, InputStream input, String id,
			String aliases, String filename) {
		if (collectionName==null||collectionName.trim().isEmpty()||input==null) {
			return;
		}
		delectFileById(collectionName,id);
		GridFS gfs =new GridFS(mongoTemplate.getDb(), collectionName);
		GridFSInputFile gfsFile = gfs.createFile(input);
		gfsFile.setId(id);
		if (filename!=null&&!filename.trim().isEmpty()) {
			gfsFile.setFilename(filename);
			gfsFile.setContentType(filename.substring(filename.lastIndexOf(".")));
		}
		if (aliases!=null&&!aliases.trim().isEmpty()) {
			gfsFile.put("aliases", aliases);  
		}
		gfsFile.save();
	}
	@Override
	public void saveFile(String collectionName, byte[] input, String id,
			String aliases, String filename) {
		if (collectionName==null||collectionName.trim().isEmpty()||input==null) {
			return;
		}
		delectFileById(collectionName,id);
		GridFS gfs =new GridFS(mongoTemplate.getDb(), collectionName);
		GridFSInputFile gfsFile = gfs.createFile(input);
		gfsFile.setId(id);
		if (filename!=null&&!filename.trim().isEmpty()) {
			gfsFile.setFilename(filename);
			gfsFile.setContentType(filename.substring(filename.lastIndexOf(".")));
		}
		if (aliases!=null&&!aliases.trim().isEmpty()) {
			gfsFile.put("aliases", aliases);  
		}
		gfsFile.save();
	}
	@Override
	public GridFSDBFile retrieveFileOne(String collectionName, String id,
			String filename) {
		if (collectionName==null||collectionName.trim().isEmpty()||(id==null&&filename==null)) {
			return null;
		}
		if (id!=null&&!id.trim().isEmpty()) {
			return getFileById(collectionName,id);
		}
		if (filename!=null&&!filename.trim().isEmpty()) {
			return getFileByFilename(collectionName,filename);
		}
		return null;
	}

	@Override
	public GridFSDBFile getFileById(String collectionName, String id) {
		if (collectionName==null||collectionName.trim().isEmpty()||id==null||id.trim().isEmpty()) {
			return null;
		}
		GridFS gfs =new GridFS(mongoTemplate.getDb(), collectionName);
		DBObject query  = new BasicDBObject("_id", id);  
		GridFSDBFile gfsFile = gfs.findOne(query);
		return gfsFile;
	}

	@Override
	public GridFSDBFile getFileByFilename(String collectionName, String filename) {
		if (collectionName==null||collectionName.trim().isEmpty()||filename==null||filename.trim().isEmpty()) {
			return null;
		}
		GridFS gfs =new GridFS(mongoTemplate.getDb(), collectionName);
		GridFSDBFile gfsFile = gfs.findOne(filename);
		return gfsFile;
	}

	@Override
	public void delectFileById(String collectionName, String id) {
		if (collectionName==null||collectionName.trim().isEmpty()||id==null||id.trim().isEmpty()) {
			return;
		}
		GridFS gfs =new GridFS(mongoTemplate.getDb(), collectionName);
		DBObject query  = new BasicDBObject("_id", id); 
		gfs.remove(query);
	}

	@Override
	public void delectFileByFilename(String collectionName, String filename) {
		if (collectionName==null||collectionName.trim().isEmpty()||filename==null||filename.trim().isEmpty()) {
			return;
		}
		GridFS gfs =new GridFS(mongoTemplate.getDb(), collectionName);
		gfs.remove(filename);
	}
	
}

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
 * 缓存redis类
 *
 */
public interface CacheRedis {
	/**
	 * 保存对象
	 * @param key 键
	 * @param object 对象 
	 * @param timeout 过期时间
	 * @param unit 时间单位
	 */
	public void setObject(String key,Object object,final long timeout, final TimeUnit unit);
	/**
	 * 保存对象
	 * @param key 键
	 * @param map 对象map
	 * @param timeout 过期时间
	 * @param unit 时间单位
	 */
	public void setObject(String key,Map<String, Object> map,final long timeout, final TimeUnit unit);
	/**
	 * 保存对象
	 * @param key 键
	 * @param list 对象list
	 * @param timeout 过期时间
	 * @param unit 时间单位
	 */
	public void setObject(String key,List<Object> list,final long timeout, final TimeUnit unit);
	/**
	 * 保存对象
	 * @param key 键
	 * @param set 对象set
	 * @param timeout 过期时间
	 * @param unit 时间单位
	 */
	public void setObject(String key,Set<Object> set,final long timeout, final TimeUnit unit);
	/**
	 * 保存对象
	 * @param key 键
	 * @param object 对象 
	 */
	public void setObject(String key,Object object);
	/**
	 * 保存对象
	 * @param key 键
	 * @param map 对象map
	 */
	public void setObject(String key,Map<String, Object> map);
	/**
	 * 保存对象
	 * @param key 键
	 * @param list 对象list
	 */
	public void setObject(String key,List<Object> list);
	/**
	 * 保存对象
	 * @param key 键
	 * @param set 对象set
	 */
	public void setObject(String key,Set<Object> set);
	/**
	 * 获取对象
	 * @param key 键
	 * @return 对象
	 */
	public Object getObject(String key);
	/**
	 * 
	 * @param key 键
	 * @return 对象map
	 */
	public Map<String, Object> getObjectMap(String key);
	/**
	 * 
	 * @param key 键
	 * @return 对象list
	 */
	public List<Object> getObjectList(String key);
	/**
	 * 
	 * @param key 键
	 * @return 对象set
	 */
	public Set<Object> getObjectSet(String key);
	/**
	 * 获取hash中对象
	 * @param key 键
	 * @param hashKey hash键
	 * @return 对象
	 */ 
	public Object getObject(String key,String hashKey);
	/**
	 * 增加list的对象
	 * @param key 键
	 * @param listKey list键
	 * @param object 对象
	 */
	public void addListObject(String key,Object object);
	/**
	 * 增加set的对象
	 * @param key 键
	 * @param setKey set键
	 * @param object 对象
	 */
	public void addSetObject(String key,Object object);
}

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.stereotype.Repository;

import com.trustsaving.CacheMoudle.redis.CacheRedis;
import com.trustsaving.common.base.dao.AbstractBaseRedisDao;
@Repository
public class CacheRedisImpl  extends AbstractBaseRedisDao<String, Object> implements CacheRedis{

	@Override
	public void setObject(String key, Object object, long timeout, TimeUnit unit) {
		if (key==null||object==null) {
			return;
		}
		setObject(key, object);
		redisTemplate.expire(key, timeout, unit);
	}

	@Override
	public void setObject(String key, Map<String, Object> map, long timeout,
			TimeUnit unit) {
		if (key==null||map==null) {
			return;
		}
		setObject(key, map);
		redisTemplate.expire(key, timeout, unit);
	}

	@Override
	public void setObject(String key, List<Object> list, long timeout,
			TimeUnit unit) {
		if (key==null||list==null) {
			return;
		}
		setObject(key, list);
		redisTemplate.expire(key, timeout, unit);
	}

	@Override
	public void setObject(String key, Set<Object> set, long timeout,
			TimeUnit unit) {
		if (key==null||set==null) {
			return;
		}
		setObject(key, set);
		redisTemplate.expire(key, timeout, unit);
	}

	@Override
	public void setObject(String key, Object object) {
		if (key==null||object==null) {
			return;
		}
		redisTemplate.opsForValue().set(key, object);
	}

	@Override
	public void setObject(String key, Map<String, Object> map) {
		if (key==null||map==null||map.size()<=0) {
			return;
		}
		redisTemplate.opsForHash().putAll(key, map);
	}

	@Override
	public void setObject(String key, List<Object> list) {
		if (key==null||list==null||list.size()<=0) {
			return;
		}
		redisTemplate.opsForList().leftPushAll(key, list);
	}

	@Override
	public void setObject(String key, Set<Object> set) {
		if (key==null||set==null||set.size()<=0) {
			return;
		}
		for (Object object : set) {
			redisTemplate.opsForSet().add(key, object);
		}
	}

	@Override
	public Object getObject(String key) {
		if (key==null||key.trim().isEmpty()) {
			return null;
		}
		return redisTemplate.opsForValue().get(key);
	}

	@Override
	public Map<String, Object> getObjectMap(String key) {
		if (key==null||key.trim().isEmpty()) {
			return null;
		}
		BoundHashOperations<String, String, Object> bho= redisTemplate.boundHashOps(key);
		Set<String> keySet= bho.keys();
		if (keySet==null||keySet.size()<=0) {
			return null;
		}
		Map<String, Object> map=new HashMap<String,Object>();
		for (String string : keySet) {
			map.put(string, bho.get(string));
		}
		return map;
	}

	@Override
	public List<Object> getObjectList(String key) {
		if (key==null||key.trim().isEmpty()) {
			return null;
		}
		BoundListOperations<String, Object> blo=redisTemplate.boundListOps(key);
		return blo.range(0, -1);
//		Long size= blo.size();
//		if (size==null||size<=0) {
//			return null;
//		}
//		List<Object> list=new ArrayList<Object>();
//		for (int i = 0; i < size; i++) {
//			list.add(blo.index(i));
//		}
//		return list;
	}

	@Override
	public Set<Object> getObjectSet(String key) {
		if (key==null||key.trim().isEmpty()) {
			return null;
		}
		BoundSetOperations<String, Object> bso=redisTemplate.boundSetOps(key);
		return bso.members();
	}

	@Override
	public Object getObject(String key, String hashKey) {
		if (key==null||key.trim().isEmpty()||hashKey==null||hashKey.trim().isEmpty()) {
			return null;
		}
		BoundHashOperations<String, String, Object> bho=redisTemplate.boundHashOps(key);
		return bho.get(hashKey);
	}

	@Override
	public void addListObject(String key, Object object) {
		if (key==null||key.trim().isEmpty()||object==null) {
			return ;
		}
		redisTemplate.opsForList().leftPush(key, object);
	}

	@Override
	public void addSetObject(String key, Object object) {
		if (key==null||key.trim().isEmpty()||object==null) {
			return ;
		}
		redisTemplate.opsForSet().add(key, object);
	}

}

import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
 * 缓存redis工具类
 *
 */
public interface CacheUtilRedis {
	/**
	 * 删除键
	 * @param key 键
	 */
	public void delete(String key);
	/**
	 * 删除键
	 * @param list 键列表
	 */
	public void delete(List<String> list);
	/**
	 * 删除hash中键
	 * @param key 键
	 * @param hashKey hash键
	 */
	public void delete(String key,String hashKey);
	/**
	 * 删除set中值
	 * @param key 键
	 * @param object set值
	 */
	public void remove(String key,Object object);
	/**
	 * 判断是否为set的成员
	 * @param key 键
	 * @param object set值
	 * @return
	 */
	public Boolean isMember(String key,Object object);
	/**
	 * 是否存在键
	 * @param key 键
	 * @return true存在
	 */
	public Boolean hasKey(String key);
	/**
	 * hash中是否存在键
	 * @param key 键
	 * @param hashKey hash键
	 * @return true存在
	 */
	public Boolean hasKey(String key,String hashKey);
	/**
	 * 设置键过期时间
	 * @param key 键
	 * @param timeout 过期时间
	 * @param unit 时间单位
	 * @return true设置成功
	 */
	public Boolean expire(String key, final long timeout, final TimeUnit unit);
	/**
	 * 设置键过期时间
	 * @param key
	 * @param date 失效日期
	 * @return true设置成功
	 */
	public Boolean expireAt(String key, final Date date);
	/**
	 * 获得键过期时间
	 * @param key 键
	 * @param unit 时间单位
	 * @return 过期时间
	 */
	public Long getExpire(String key, final TimeUnit unit);
	
}

import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

import org.springframework.stereotype.Repository;

import com.trustsaving.CacheMoudle.redis.CacheUtilRedis;
import com.trustsaving.common.base.dao.AbstractBaseRedisDao;

@Repository
public class CacheUtilRedisImpl  extends AbstractBaseRedisDao<String, Object> implements CacheUtilRedis{

	@Override
	public void delete(String key) {
		if (key==null||key.trim().isEmpty()) {
			return;
		}
		redisTemplate.delete(key);
	}

	@Override
	public void delete(List<String> list) {
		if (list==null||list.size()<=0) {
			return;
		}
		redisTemplate.delete(list);
	}

	@Override
	public void delete(String key, String hashKey) {
		if (key==null||key.trim().isEmpty()||hashKey==null||hashKey.trim().isEmpty()) {
			return;
		}
		redisTemplate.opsForHash().delete(key, hashKey);
	}

	@Override
	public void remove(String key, Object object) {
		if (key==null||key.trim().isEmpty()||object==null) {
			return;
		}
		redisTemplate.opsForSet().remove(key, object);
	}
	
	@Override
	public Boolean isMember(String key, Object object) {
		if (key==null||key.trim().isEmpty()||object==null) {
			return false;
		}
		return redisTemplate.opsForSet().isMember(key, object);
	}
	
	@Override
	public Boolean hasKey(String key) {
		if (key==null||key.trim().isEmpty()) {
			return false;
		}
		return redisTemplate.hasKey(key);
	}

	@Override
	public Boolean hasKey(String key, String hashKey) {
		if (key==null||key.trim().isEmpty()||hashKey==null||hashKey.trim().isEmpty()) {
			return false;
		}
		return redisTemplate.opsForHash().hasKey(key, hashKey);
	}

	@Override
	public Boolean expire(String key, long timeout, TimeUnit unit) {
		if (key==null||key.trim().isEmpty()||unit==null) {
			return false;
		}
		return redisTemplate.expire(key, timeout, unit);
	}

	@Override
	public Boolean expireAt(String key, Date date) {
		if (key==null||key.trim().isEmpty()||date==null) {
			return false;
		}
		return redisTemplate.expireAt(key, date);
	}

	@Override
	public Long getExpire(String key, TimeUnit unit) {
		if (key==null||key.trim().isEmpty()||unit==null) {
			return null;
		}
		return redisTemplate.getExpire(key, unit);
	}

	


}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.URL;

import com.trustsaving.CacheMoudle.exception.SerializeException;

/**
 * 对象序列化类
 *
 */
public class SerializeUtil {
	/**
	 * 序列化对象
	 * @param object
	 * @return
	 */
	public static byte[]serialize(Object object) throws SerializeException,Exception{
		if (object==null) {
			throw new SerializeException(SerializeException.PARAM_IS_NULL, "序列化参数为空");
		}
		ObjectOutputStream oos=null;
		ByteArrayOutputStream baos=null;
		try {
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			byte[] bytes = baos.toByteArray();
            return bytes;
		} catch (Exception e) {
			throw e;
		}
	}
	/**
	 * 反序列化对象
	 * @param bytes
	 * @return
	 */
	public static Object unserialize(byte[]bytes)throws SerializeException,Exception{
		if (bytes==null) {
			throw new SerializeException(SerializeException.PARAM_IS_NULL, "反序列化参数为空");
		}
		ByteArrayInputStream bais = null;
		try {
			 bais = new ByteArrayInputStream(bytes);
			 ObjectInputStream ois = new ObjectInputStream(bais);
			 return ois.readObject();
		} catch (Exception e) {
			throw e;
		}
	}
	/**
	 * 文件序列化
	 * @param input 文件地址
	 * @return
	 */
	public static byte[] serializeFile(String input)throws SerializeException,Exception{
		if (input==null) {
			throw new SerializeException(SerializeException.PARAM_IS_NULL, "序列化参数为空");
		}
		File fr = new File(input);
		if (fr==null||fr.exists()==false||fr.isDirectory()) {
			throw new SerializeException(SerializeException.IS_NOT_FILE, "文件不存在或是目录");
		}
		try {
			FileInputStream fis=new FileInputStream(fr);
			return readInputStream(fis);
		} catch (Exception e) {
			throw e;
		}
	}
	/**
	 * 文件序列化
	 * @param input 文件
	 * @return
	 */
	public static byte[] serializeFile(File input)throws SerializeException,Exception{
		if (input==null) {
			throw new SerializeException(SerializeException.PARAM_IS_NULL, "序列化参数为空");
		}
		if (input.exists()==false||input.isDirectory()) {
			throw new SerializeException(SerializeException.IS_NOT_FILE, "文件不存在或是目录");
		}
		try {
			FileInputStream fis=new FileInputStream(input);
			return readInputStream(fis);
		} catch (Exception e) {
			throw e;
		}
	}
	/**
	 * 文件序列化
	 * @param input 文件流
	 * @return
	 */
	public static byte[] serializeFile(InputStream input)throws SerializeException,Exception{
		if (input==null) {
			throw new SerializeException(SerializeException.PARAM_IS_NULL, "序列化参数为空");
		}
		try {
			return readInputStream(input);
		} catch (Exception e) {
			throw e;
		}
	}
	/**
	 * 文件序列化
	 * @param input URL对象
	 * @return
	 */
	public static byte[] serializeFile(URL input)throws SerializeException,Exception{
		if (input==null) {
			throw new SerializeException(SerializeException.PARAM_IS_NULL, "序列化参数为空");
		}
		InputStream istream = null;
        try {
            istream = input.openStream();
            return readInputStream(istream);
        } catch (IOException e) {
        	throw e;
        }
	}
	/**
	 * 文件反序列化
	 * @param bytes 文件流
	 * @return
	 */
	public static InputStream unserializeFile(byte[]bytes)throws SerializeException,Exception{
		if (bytes==null) {
			throw new SerializeException(SerializeException.PARAM_IS_NULL, "反序列化参数为空");
		}
		InputStream inputStream=new ByteArrayInputStream(bytes);
		return inputStream;
	}
//	/**
//	 * 从网络序列化图片
//	 * @param imageUrl
//	 * @return
//	 */
//	public static byte[] serializeImage(URL imageUrl )throws SerializeException,Exception{
//		String[] imageFormats = ImageIO.getReaderFormatNames();
//		for (String string : imageFormats) {
//			System.out.println(string);
//		}
//		ByteArrayOutputStream outputStream = null;
//        try {
//            BufferedImage bufferedImage = ImageIO.read(imageUrl);
//            outputStream = new ByteArrayOutputStream();
//            ImageIO.write(bufferedImage, "jpg", outputStream);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        return outputStream.toByteArray();
//	}
	/**
	 * 读取文件为byte数组
	 * @param inStream
	 * @return
	 * @throws Exception
	 */
	public static byte[] readInputStream(InputStream inStream) throws Exception{
		ByteArrayOutputStream outStream = new ByteArrayOutputStream();
		//创建一个Buffer字符串
		byte[] buffer = new byte[1024];
		//每次读取的字符串长度，如果为-1，代表全部读取完毕
		int len = 0;
		//使用一个输入流从buffer里把数据读取出来
		while( (len=inStream.read(buffer)) != -1 ){
			//用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
			outStream.write(buffer, 0, len);
		}
		//关闭输入流
		inStream.close();
		//把outStream里的数据写入内存
		return outStream.toByteArray();
	}
}