MOngoDBUtil

package ro.shiken.db;
 
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
 
import org.bson.types.ObjectId;
 
import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;
 
public class MongoUtils {
 
	private Mongo mongo = null;
	private static MongoUtils instance = null;
	private DB db = null;
 
	private final static String DB_NAME = "db_name";
	private final static String DB_HOST = "host";
	private final static String DB_PORT = "port";
 
	private final static String ID = "_id";
 
	private Properties properties;
 
	private MongoUtils() {
		InputStream inputStream = this.getClass().getClassLoader()
				.getResourceAsStream("mongo.properties");
		properties = new Properties();
		try {
			properties.load(inputStream);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
 
	public static MongoUtils getMe() {
		if (instance == null) {
			instance = new MongoUtils();
		}
		return instance;
	}
 
	private DB getMongo() {
		if (mongo == null) {
			try {
				mongo = new Mongo(properties.getProperty(DB_HOST),
						Integer.parseInt(properties.getProperty(DB_PORT)));
			} catch (UnknownHostException e) {
				e.printStackTrace();
			} catch (MongoException e) {
				e.printStackTrace();
			}
		}
		return mongo.getDB(properties.getProperty(DB_NAME));
	}
 
	public DBCollection getCollection(Collection coll) {
		if (getMe().db == null) {
			getMe().db = getMongo();
		}
		return getMe().db.getCollection(coll.name());
	}
 
	public static enum Collection {
		USER, ITEM, PUPIL, RESPONSE, SESSION, TCH, TEST, PUPIL_SESSION
	}
 
	public static ObjectId save(Collection c, Object obj) {
		DBObject dbObj = getObject(obj);
		getMe().getCollection(c).save(dbObj);
		return (ObjectId) dbObj.get(ID);
	}
 
	public static <T> T getInstace(Class<T> clazz, DBObject object) {
		T t = null;
		if (object != null) {
			try {
				t = clazz.newInstance();
				List<Field> fields = Arrays.asList(clazz.getDeclaredFields());
				Set<String> props = object.keySet();
				for (Field f : fields) {
					String fn = f.getName();
					if (props.contains(fn)) {
						f.setAccessible(true);
						for (String n : props) {
							if (n.equals(fn)) {
								Object oo = object.get(n);
								if (oo instanceof BasicDBList) {
									if (f.getType().isArray()) {
										f.set(t,
												getArrayField(f.getType()
														.getComponentType(),
														(BasicDBList) oo));
									} else {
										f.set(t, getListField((BasicDBList) oo));
									}
								} else {
									f.set(t, oo);
								}
								props.remove(n);
								break;
							}
						}
					}
				}
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (SecurityException e) {
				e.printStackTrace();
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
			return t;
		}
		return null;
	}
 
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private static <T> T[] getArrayField(Class<T> clazz, BasicDBList obj) {
		ArrayList list = new ArrayList();
		Iterator<Object> it = obj.iterator();
		while (it.hasNext()) {
			list.add(it.next());
		}
		T[] result = (T[]) Array.newInstance(clazz, list.size());
		result = (T[]) list.toArray(result);
		return result;
 
	}
 
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private static ArrayList getListField(BasicDBList obj) {
		ArrayList list = new ArrayList();
 
		Iterator<Object> it = obj.iterator();
		while (it.hasNext()) {
			list.add(it.next());
		}
		return list;
	}
 
	public static DBObject getObject(Object obj) {
		DBObject bo = new BasicDBObject();
		try {
			Field[] fields = obj.getClass().getDeclaredFields();
			for (Field f : fields) {
				if (!f.getName().equals("serialVersionUID")) {
					f.setAccessible(true);
					Object fo = f.get(obj);
					if (fo != null) {
						bo.put(f.getName(), fo);
					}
				}
			}
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return bo;
	}
 
	public static DBCursor find(Collection coll, DBObject ref) {
		return getMe().getCollection(coll).find(ref);
	}
 
	public static DBCursor findByKeyValue(Collection coll, String key,
			Object value) {
		return find(coll, new BasicDBObject(key, value));
	}
 
	public static DBObject findOne(Collection coll, DBObject ref) {
		return getMe().getCollection(coll).findOne(ref);
	}
 
	public static DBObject findOneById(Collection coll, ObjectId id) {
		return findOne(coll, new BasicDBObject(ID, id));
	}
}