NoSQL 之 Morphia 操作 MongoDB

发布时间：2020-12-13 14:01:04 所属栏目：百科来源：网络整理

导读：开发环境： System：Windows IDE：eclipse、MyEclipse 8 Database：mongoDB 开发依赖库： JavaEE5、mongo-2.5.3.jar、junit-4.8.2.jar 一、准备工作 1、首先，下载mongoDB对Java支持的驱动包驱动包下载地址：https://github.com/mongodb/mongo-java-driver

开发环境：

System：Windows

IDE：eclipse、MyEclipse 8

Database：mongoDB

开发依赖库：

JavaEE5、mongo-2.5.3.jar、junit-4.8.2.jar

一、准备工作

1、首先，下载mongoDB对Java支持的驱动包

驱动包下载地址：https://github.com/mongodb/mongo-java-driver/downloads

mongoDB对Java的相关支持、技术：http://www.mongodb.org/display/DOCS/Java+Language+Center

驱动源码下载：https://download.github.com/mongodb-mongo-java-driver-r2.6.1-7-g6037357.zip

在线查看源码：https://github.com/mongodb/mongo-java-driver

2、下面建立一个JavaProject工程，导入下载下来的驱动包。即可在Java中使用mongoDB，目录如下：

二、Java操作MongoDB示例

在本示例之前你需要启动mongod.exe的服务，启动后，下面的程序才能顺利执行；

1、建立SimpleTest.java，完成简单的mongoDB数据库操作

Mongo mongo = new Mongo();

这样就创建了一个MongoDB的数据库连接对象，它默认连接到当前机器的localhost地址，端口是27017。

DB db = mongo.getDB(“test”);

这样就获得了一个test的数据库，如果mongoDB中没有创建这个数据库也是可以正常运行的。如果你读过上一篇文章就知道，mongoDB可以在没有创建这个数据库的情况下，完成数据的添加操作。当添加的时候，没有这个库，mongoDB会自动创建当前数据库。

得到了db，下一步我们要获取一个“聚集集合DBCollection”，通过db对象的getCollection方法来完成。

DBCollection users = db.getCollection("users");

这样就获得了一个DBCollection，它相当于我们数据库的“表”。

查询所有数据

DBCursor cur = users.find();

while (cur.hasNext()) {

System.out.println(cur.next());

}

完整源码

package com.baison.test;

import java.net.UnknownHostException;
import com.baison.test.User;
import com.baison.test.BasicDBObjectUtils;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;
import com.mongodb.util.JSON;

/**
 * <b>function:</b> Mongo实例对象的相关方法测试
 * 
 * @author hoojo
 * @createDate 2011-5-24 下午02:42:29
 * @file MongoDBTest.java
 * @package com.hoo.test
 * @project MongoDB
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class MongoDBTest {

	public static void main(String[] args) throws UnknownHostException,MongoException {
		Mongo mg = new Mongo();

		System.out.println("查询所有的Database的名称");
		for (String name : mg.getDatabaseNames()) {
			System.out.println("dbName: " + name);
		}

		System.out.println("查询test库中的所有collection集合（表）名称");
		DB db = mg.getDB("test");
		for (String name : db.getCollectionNames()) {
			System.out.println("collectionName: " + name);
		}

		System.out.println("添加测试数据");
		DBCollection users = db.getCollection("users");
		try {
			// 用自定义BasicDBObjectUtils工具类，将User Enity对象转换成DBObject
			DBObject user = BasicDBObjectUtils.castModel2DBObject(new User(
					345567,"jack",true,22,"beijin"));
			users.insert(user);
			// 用BasicDBObjectBuilder构建一个DBObject对象
			user = BasicDBObjectBuilder.start("id",1546555)
					.append("name","jojo").add("address","gz")
					.append("email","hoojo_@126.com").get();
			users.insert(user);
		} catch (Exception e) {
			e.printStackTrace();
		}

		System.out.println("游标查询所有users集合数据");
		DBCursor cur = users.find();
		while (cur.hasNext()) {
			System.out.println(cur.next());
		}
		System.out.println("查询游标相关内容");
		System.out.println(cur.count());
		System.out.println(cur.getCursorId());
		System.out.println(cur.getOptions());
		System.out.println(cur.getQuery());
		System.out.println(cur.getSizes().listIterator());

		System.out.println(cur.itcount());
		// System.out.println(cur.length());
		System.out.println(cur.size());
		System.out.println(cur.numGetMores());
		System.out.println(cur.curr());
		// System.out.println(cur.toArray().get(0));

		System.out.println("显示游标查询到的所有内容： " + JSON.serialize(cur));
	}
}

工具类，将带有getter、setter方法的Java类序列化成DBObject对象

package com.baison.test;

import java.lang.reflect.Method;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;

/**
 * <b>function:</b> 将Entity/Model转换成DBObject
 * 
 * @author hoojo
 * @createDate 2011-5-30下午01:53:08
 * @file BasicDBObjectUtil.java
 * @package com.hoo.util
 * @project MongoDB
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class BasicDBObjectUtils {
	public static <T> DBObject castModel2DBObject(T entity) throws Exception {
		Method[] method = entity.getClass().getMethods();

		DBObject dbObject = new BasicDBObject();
		for (Method m : method) {
			// System.out.println(m.getName());
			if (m.getName().startsWith("get")) {
				String name = m.getName().replace("get","");
				for (Method m2 : method) {
					if (m2.getName().equals("set" + name)) {
						name = name.substring(0,1).toLowerCase()
								+ name.substring(1);
						Object returnVal = m.invoke(entity,new Object[] {});
						if (returnVal != null) {
							// System.out.println(name + " : " +
							// m.invoke(shipping,new Object[] {}));
							dbObject.put(name,returnVal);
						}
					}
				}
			}
		}
		System.out.println("dbObject: " + dbObject);
		return dbObject;
	}
}

2、完成索引操作，首先建立一个MongoDB4IndexTest.java，基本测试代码如下：

package com.baison.test;

import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import org.bson.types.ObjectId;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.mongodb.BasicDBObject;
import com.mongodb.Bytes;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;
import com.mongodb.QueryOperators;
import com.mongodb.util.JSON;

/**
 * <b>function:</b> 实现MongoDB的Index操作
 * 
 * @author hoojo
 * @createDate 2011-6-2 下午03:21:23
 * @file MongoDB4IndexTest.java
 * @package com.hoo.test
 * @project MongoDB
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class MongoDB4IndexTest {

	private Mongo mg = null;
	private DB db;
	private DBCollection coll;

	@Before
	public void init() {
		try {
			mg = new Mongo();
			// mg = new Mongo("localhost",27017);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (MongoException e) {
			e.printStackTrace();
		}
		// 获取temp DB；如果默认没有创建，mongodb会自动创建
		db = mg.getDB("temp");
		// 获取users DBCollection；如果默认没有创建，mongodb会自动创建
		coll = db.getCollection("users");
	}

	@After
	public void destory() {
		if (mg != null) {
			coll.drop();
			db.dropDatabase();
			mg.close();
		}
		mg = null;
		db = null;
		coll = null;
		System.gc();
	}

	public void print(Object o) {
		System.out.println(o);
	}

	private void query() {
		print("查询users的所有数据：");
		// db游标
		DBCursor cur = coll.find();
		while (cur.hasNext()) {
			print(cur.next());
		}
	}

	/**
	 * <b>function:</b> 测试Collection的index相关操作
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16 下午08:32:26
	 */
	@Test
	public void testIndex() {
		query();

		for (DBObject index : coll.getIndexInfo()) {
			print("IndexInfo: " + index);
		}

		coll.dropIndexes();
		// 创建索引
		coll.createIndex(new BasicDBObject("name","idx_name"));
		print(coll.findOne(new BasicDBObject("name","haha")));
		coll.createIndex(coll.findOne(new BasicDBObject("name","haha")));
		DBObject o = new BasicDBObject("unique",true);
		// coll.createIndex(coll.findOne(),o);

		// 修改索引，如果存在就修改不存在就添加
		coll.ensureIndex(o);
		coll.ensureIndex("age_1");
		coll.ensureIndex(new BasicDBObject("age3_1",6),new BasicDBObject(
				"ts",-1));
		coll.ensureIndex(new BasicDBObject("age_2",1),new BasicDBObject("ts",1));
		coll.ensureIndex(new BasicDBObject("password",2),new BasicDBObject(
				"z","idx"));
		coll.ensureIndex(new BasicDBObject("password",new BasicDBObject(
				"etc","idx"));
		// 创建唯一索引
		coll.ensureIndex(new BasicDBObject("emial",new BasicDBObject(
				"unique",false));
		// 创建索引，指定索引名称default_index
		coll.ensureIndex(new BasicDBObject("address",new BasicDBObject(
				"name","default_index"));
		// 创建索引对象，索引名称user_index
		coll.ensureIndex(coll.findOne(new BasicDBObject("name","hoho")),"user_index");
		// 唯一索引
		coll.ensureIndex(coll.findOne(new BasicDBObject("name","hehe")),"users_index_unique",true);

		// 查询所有索引
		for (DBObject index : coll.getIndexInfo()) {
			print("IndexInfo: " + index);
		}

		print(DBCollection.genIndexName(coll.findOne()));

		// coll.dropIndex(coll.findOne());
		print(DBCollection.genIndexName(new BasicDBObject("password",2)));
		// coll.dropIndex(DBCollection.genIndexName(new
		// BasicDBObject("password",2)));
		// coll.dropIndexes();
		// coll.dropIndexes("assword_1");
	}
}

三、Morphia基本操作

1、 morphia可以利用annotation对JavaEntity进行注解，那样我们就可以用morphia操作JavaEntity对象

package com.baison.test;

import com.google.code.morphia.annotations.Entity;
import com.google.code.morphia.annotations.Id;

/**
 * <b>function:</b> JavaEntity对象
 * 
 * @author hoojo
 * @createDate 2011-5-31上午11:45:21
 * @file User.java
 * @package com.hoo.entity
 * @project Morphia
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
// 利用morphia的annotation进行注解
@Entity
public class User {
	@Id
	private long id;
	private String name;
	private boolean sex;
	private int age;
	private String address;

	public User() {
	}

	public User(long id,String name,boolean sex,int age,String address) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.address = address;
	}

	// getter、setter

	@Override
	public String toString() {
		return this.id + "#" + this.name + "#" + this.age + "#" + this.sex
				+ "#" + this.address;
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public boolean isSex() {
		return sex;
	}

	public void setSex(boolean sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

}

2、对Morphia对象一些简单的使用，看看该对象提供了哪些基本的操作方法

package com.baison.test;

import java.net.UnknownHostException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.google.code.morphia.Datastore;
import com.google.code.morphia.EntityInterceptor;
import com.google.code.morphia.Morphia;
import com.google.code.morphia.mapping.MappedClass;
import com.google.code.morphia.mapping.Mapper;
import com.google.code.morphia.mapping.cache.EntityCache;
import com.baison.test.User;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

/**
 * <b>function:</b> morphia对象的简单测试
 * 
 * @author hoojo
 * @createDate 2011-5-31上午11:30:20
 * @file MorphiaTest.java
 * @package com.hoo.test
 * @project Morphia
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class MorphiaTest {
	private Mongo mongo;
	private Morphia morphia;

	@Before
	public void init() {
		try {
			mongo = new Mongo();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (MongoException e) {
			e.printStackTrace();
		}
		morphia = new Morphia();
	}

	private void print(Object o) {
		if (o != null) {
			System.out.println(o.toString());
		}
	}

	/**
	 * <b>function:</b> morphia对象的简单测试
	 * 
	 * @author hoojo
	 */
	@SuppressWarnings("deprecation")
	@Test
	public void testMorphia() {
		// 创建一个Datastore，过时的方法不推荐使用
		Datastore ds = morphia.createDatastore("myTestDB");
		print("createDatastore: " + ds);
		// 创建ds
		ds = morphia.createDatastore(mongo,"myTestDB");
		print("createDatastore: " + ds);
		// 创建一个带用户名、密码的ds
		// ds = morphia.createDatastore(mongo,"myTestDB","admin",new char[] {
		// '1','2','3','4','5','6' });

		// 设置操作资源对象，这里设置User.class 就可以完成对User的一系列操作
		// morphia.map(User.class);
		// morphia.mapPackage("com.hoo.entity");//会把整个包下面的类都加载进来
		// 将对象转成DBObject
		print("toDBObject: "
				+ morphia.toDBObject(new User(System.currentTimeMillis(),"jackson",null)));
		// 将参数2转换成参数1的类型
		print("fromDBObject: "
				+ morphia.fromDBObject(User.class,BasicDBObjectBuilder.start("sex",true).get()));
		print("getMapper: " + morphia.getMapper());
		print("isMapped: " + morphia.isMapped(User.class));

	}

	/**
	 * <b>function:</b> 对Mapper对象相关操作
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16下午10:20:38
	 */
	@Test
	public void testMapper() {
		Mapper mapper = morphia.getMapper();
		// 添加对象映射
		print("addMappedClass: " + mapper.addMappedClass(User.class));
		// print(mapper.addMappedClass(mapper.addMappedClass(User.class));

		// 创建实体缓存
		print("createEntityCache: " + mapper.createEntityCache());
		print(mapper.getCollectionName("myTestDB"));
		print(mapper.getConverters());
		User user = new User(System.currentTimeMillis(),null);
		user.setId(1306814012734L);
		print(mapper.getId(user));

		for (EntityInterceptor ei : mapper.getInterceptors()) {
			System.out.println("EntityInterceptor: " + ei);
		}

		// 查询主键
		print("getKey: " + mapper.getKey(user));
		// 所有已经映射的class
		for (MappedClass mc : mapper.getMappedClasses()) {
			System.out.println("getMappedClasses: " + mc);
		}

		print("mcMap: " + mapper.getMCMap());

		print("getOptions: " + mapper.getOptions());
		print("keyToRef: " + mapper.keyToRef(mapper.getKey(user)));
		print("refToKey: "
				+ mapper.refToKey(mapper.keyToRef(mapper.getKey(user))));
	}

	/**
	 * <b>function:</b> 实体缓存
	 * 
	 * @author hoojo
	 */
	@Test
	public void testEntityCache() {
		EntityCache ec = morphia.getMapper().createEntityCache();
		print("EntityCache: " + ec);
		Datastore ds = morphia.createDatastore(mongo,"myTestDB");
		User user = new User(System.currentTimeMillis(),null);
		user.setId(1306814012734L);

		// 添加实体
		ec.putEntity(ds.getKey(user),user);
		// 代理
		ec.putProxy(ds.getKey(user),user);

		print("getKey: " + ds.getKey(user));
		print("getProxy: " + ec.getProxy(ds.getKey(user)));
		print("getEntity: " + ec.getEntity(ds.getKey(user)));

		print(ec.exists(ds.getKey(user)));

		print("stats: " + ec.stats());
	}

	@After
	public void destory() {
		mongo = null;
		morphia = null;
		System.gc();
	}
}

四、利用Morphia完成对Datastore对象的CRUD操作

1、首先添加如下准备代码，随后的方法直接添加到该文件中即可

package com.baison.test;

import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.google.code.morphia.Datastore;
import com.google.code.morphia.Key;
import com.google.code.morphia.Morphia;
import com.google.code.morphia.query.UpdateOperations;
import com.baison.test.User;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

/**
 * <b>function:</b> Datastore增删改查操作
 * 
 * @author hoojo
 * @createDate 2011-5-31下午06:29:04
 * @fileDatastore DatastoreTest.java
 * @package com.hoo.test.ds
 * @project Morphia
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class DatastoreTest {
	private Mongo mongo;
	private Morphia morphia;
	private Datastore ds;

	@Before
	public void init() {
		try {
			mongo = new Mongo();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (MongoException e) {
			e.printStackTrace();
		}
		morphia = new Morphia();
		morphia.map(User.class);
		ds = morphia.createDatastore(mongo,"temp");
	}

	private void print(Object o) {
		if (o != null) {
			System.out.println(o.toString());
		}
	}

	/**
	 * <b>function:</b> 查询所有
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16 下午10:36:13
	 */
	private void query() {
		Iterable<User> it = ds.createQuery(User.class).fetch();
		while (it.iterator().hasNext()) {
			print("fetch: " + it.iterator().next());
		}
	}

	@After
	public void destory() {
		mongo.close();
		mongo = null;
		morphia = null;
		ds = null;
		System.gc();
	}

	/**
	 * <b>function:</b> CUD增删改
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16 下午10:46:08
	 */
	@Test
	public void testCUD() {
		// 添加测试数据
		for (int i = 0; i < 50; i++) {
			User u = new User(System.currentTimeMillis() + i,"test-" + i,((i % 2 == 0) ? true : false),18 + i,"china-gz#" + i);
			print(ds.save(u));
		}
		// ds.delete(ds.createQuery(User.class));

		List<User> users = new ArrayList<User>();
		users.add(new User(1306907246518L,"zhangsan","china-gz"));
		User user = new User(System.currentTimeMillis() + 3,"zhaoliu",29,"china-beijin");
		users.add(user);
		users.add(new User(System.currentTimeMillis() + 6,"wangwu",24,"china-shanghai"));
		users.add(new User(System.currentTimeMillis() + 9,"lisi",26,"china-wuhan"));
		// 添加集合
		print("save: " + ds.save(users));

		// 添加数组
		print("save: " + ds.save(users.toArray()));

		this.query();
		print("getKey: " + ds.find(User.class,"id",1306907246518L).getKey());

		// 修改操作
		UpdateOperations<User> uo = ds.createUpdateOperations(User.class);

		print("update: "
				+ ds.update(ds.find(User.class,1306907246518L).getKey(),uo).getUpdatedCount());
		uo.add("name","zhaoliuliu").set("age",29).set("sex",true)
				.add("address","gzz");
		print("update: "
				+ ds.update(ds.find(User.class,uo).getUpdatedCount());

		print("update: "
				+ ds.update(
						ds.createQuery(User.class).field("id")
								.equal(1306907246518L),uo).getUpdatedCount());
		print("update: "
				+ ds.update(ds.find(User.class,1306907246518L),uo)
						.getUpdatedCount());

		uo = ds.createUpdateOperations(User.class);
		uo.set("name","zhaoqq").set("age","fzz");
		print("update: "
				+ ds.update(ds.find(User.class,1306907246518L).get(),uo)
						.getUpdatedCount());

		print("update: "
				+ ds.update(
						ds.createQuery(User.class).field("id")
								.equal(1306907246518L),uo,true)
						.getUpdatedCount());

		// 修改第一个对象
		print("updateFirst: "
				+ ds.updateFirst(
						ds.createQuery(User.class).field("id")
								.equal(1306907246518L),uo).getUpdatedCount());
		// 当参数createIfMissing为true的时候，如果修改的对象不存在就会添加这条数据，如果为false的情况下，不存在也不添加
		print("updateFirst: "
				+ ds.updateFirst(
						ds.createQuery(User.class).field("id")
								.equal(1306907246519L),true)
						.getUpdatedCount());
		user.setId(1306907246518L);
		print("updateFirst: "
				+ ds.updateFirst(
						ds.createQuery(User.class).field("id")
								.equal(1306907246518L),user,true)
						.getUpdatedCount());

		user.setId(1306916670518L);
		// 合并
		print("merge: " + ds.merge(user).getId());
		this.query();

		// 删除
		print("delete: "
				+ ds.delete(
						ds.createQuery(User.class).field("id")
								.equal(1306907246518L)).getN());
		print("delete: "
				+ ds.delete(ds.find(User.class,"age",29).get()).getN());
		// print("delete: " + ds.delete(User.class,1306911594631L).getN());
		// print("delete: " + ds.delete(User.class,users).getN());
		// ds.delete(ds.createQuery(User.class));
		this.query();
	}

	/**
	 * <b>function:</b> find查询
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16 下午10:45:55
	 */
	@Test
	public void testFind() {
		print("find: " + ds.find(User.class).asList());
		// like
		print("find-contains: "
				+ ds.find(User.class).field("name").contains("test-1").asList());
		// 忽略大小写
		print("find-containsIgnoreCase: "
				+ ds.find(User.class).field("name").containsIgnoreCase("ja")
						.asList());

		print("find-endsWith: "
				+ ds.find(User.class).field("name").endsWith("22").asList());
		print("find-endsWithIgnoreCase: "
				+ ds.find(User.class).field("name").endsWithIgnoreCase("CK")
						.asList());

		// 过滤null或是没有name属性的
		print("find-doesNotExist: "
				+ ds.find(User.class).field("name").doesNotExist().asList());
		// 查询name有值的数据
		print("find-doesNotExist: "
				+ ds.find(User.class).field("name").exists().asList());
		// age > 48
		print("find-greaterThan: "
				+ ds.find(User.class).field("age").greaterThan(66).asList());
		// age >= 48
		print("find-greaterThan: "
				+ ds.find(User.class).field("age").greaterThanOrEq(66).asList());

		List<Integer> ageList = new ArrayList<Integer>();
		ageList.add(22);
		ageList.add(55);
		ageList.add(66);
		// all
		print("find-hasAllOf: "
				+ ds.find(User.class).field("age").hasAllOf(ageList).asList());
		// in
		print("find-hasAnyOf: "
				+ ds.find(User.class).field("age").hasAnyOf(ageList).asList());
		// not in
		print("find-hasNoneOf: "
				+ ds.find(User.class).field("age").hasNoneOf(ageList).asList());
		// elemMatch
		// print("find-hasThisElement: " +
		// ds.find(User.class).field("age").hasThisElement(55).asList());
		print("find-hasThisOne: "
				+ ds.find(User.class).field("age").hasThisOne(55).asList());

		print("find-in: "
				+ ds.find(User.class).field("age").in(ageList).asList());
		print("find-lessThan: "
				+ ds.find(User.class).field("age").lessThan(20).asList());
		print("find-lessThanOrEq: "
				+ ds.find(User.class).field("age").lessThanOrEq(18).asList());

		// print("find-lessThanOrEq: " +
		// ds.find(User.class).field("age").near(.2,.8).asList());

		print("find: " + ds.find(User.class,1306813979609L).get());
		print("find: " + ds.find(User.class,28,1,2).asList());

		print("findAndDelete: "
				+ ds.findAndDelete(ds.createQuery(User.class).field("id")
						.equal(1306813979609L)));
		print("find: " + ds.find(User.class).asList());
	}

	/**
	 * <b>function:</b> query查询
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16 下午10:40:10
	 */
	@Test
	public void testQuery() {
		// 查询所有
		print("query: " + ds.createQuery(User.class).asList());
		// 查询主键
		print("query key: " + ds.createQuery(User.class).asKeyList());
		// 结果集数量
		print("query: " + ds.createQuery(User.class).countAll());
		// 抓取查询所有记录
		Iterable<User> it = ds.createQuery(User.class).fetch();
		while (it.iterator().hasNext()) {
			print("fetch: " + it.iterator().next());
		}

		// null
		it = ds.createQuery(User.class).fetchEmptyEntities();
		while (it.iterator().hasNext()) {
			print("fetchEmptyEntities: " + it.iterator().next());
		}

		// all key
		Iterable<Key<User>> itkeys = ds.createQuery(User.class).fetchKeys();
		while (itkeys.iterator().hasNext()) {
			print("fetchKeys: " + itkeys.iterator().next());
		}

		// age > 24
		print("query: "
				+ ds.createQuery(User.class).filter("age > ",24).asList());
		// age in (20,28)
		print("query: "
				+ ds.createQuery(User.class)
						.filter("age in ",new int[] { 20,28 }).asList());

		// limit 3
		print("query: " + ds.createQuery(User.class).limit(3).asList());
		// 分页类似MySQL
		print("query: "
				+ ds.createQuery(User.class).offset(11).limit(5).asList());
		// order排序，默认asc
		print("query: " + ds.createQuery(User.class).order("age").asList());
		// desc
		print("query: " + ds.createQuery(User.class).order("-age").asList());
		// 组合排序 order by age,name
		print("query: "
				+ ds.createQuery(User.class).order("age,name").asList());

		print("query: " + ds.createQuery(User.class).queryNonPrimary().asList());
		print("query: "
				+ ds.createQuery(User.class).queryPrimaryOnly().asList());
		// 如果include 为true就表示取该属性的值，其他的默认null，反之为false则该属性为null，取其他的值
		print("query: "
				+ ds.createQuery(User.class).retrievedFields(false,"age")
						.asList());
	}

	/**
	 * <b>function:</b> get查询
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16 下午10:39:09
	 */
	@Test
	public void testGet() {
		User user = new User();
		user.setId(1306916670518L);
		print("get: " + ds.get(user));
		List<Long> ids = new ArrayList<Long>();
		ids.add(1306907246519L);
		ids.add(1306916670524L);
		// 通过id集合查询相当于in ()
		print("get: " + ds.get(User.class,ids).asList());
		// id查询
		print("get: " + ds.get(User.class,1306916670524L));
	}

	/**
	 * <b>function:</b> count查询
	 * 
	 * @author hoojo
	 * @createDate 2012-2-16 下午10:38:02
	 */
	@Test
	public void testGetCount() {
		User user = new User();
		user.setId(1306916670518L);
		print("getCount: " + ds.getCount(user));
		print("getCount: " + ds.getCount(User.class));

		List<Long> ids = new ArrayList<Long>();
		ids.add(1306907246519L);
		ids.add(1306916670524L);
		print("getCount: " + ds.getCount(ds.get(User.class,ids)));

		// age > 22的记录
		print("getCount: "
				+ ds.getCount(ds.createQuery(User.class).filter("age > ",22)));
		// 所有
		print("countAll: " + ds.get(User.class,ids).countAll());
		print("countAll: " + ds.find(User.class).countAll());
	}

	@Test
	public void testOthers() {
		query();
		/** 索引 */
		ds.ensureIndexes();
		// 同时用annotation也可以给指定的属性建立索引
		// 只需用在JavaEntity建立索引的属性上添加annotation
		/*
		 * @Indexed(value = IndexDirection.ASC,name = "address_index") String
		 * address; // 建立唯一索引
		 * 
		 * @Indexed(value = IndexDirection.ASC,name = "bandName",unique =
		 * true) String name;
		 */

		ds.ensureCaps();
		User user = new User();
		user.setId(1306916670518L);
		print("getDB: " + ds.getDB());
		print("getDefaultWriteConcern: " + ds.getDefaultWriteConcern());
		print("DBColl: " + ds.getCollection(User.class)); // 查询User对象对应的集合
		Key<User> key = ds.getKey(user); // 主键
		print("getKey: " + key);
		print("exists: " + ds.exists(user)); // 是否存在该对象
		print("exists: " + ds.exists(ds.getKey(user)));

		print("getByKey: " + ds.getByKey(User.class,key));
		List<Key<User>> keys = new ArrayList<Key<User>>();
		keys.add(key);
		user.setId(1306916670521L);
		keys.add(ds.getKey(user));
		print("getByKey: " + ds.getByKeys(keys));
		print("getByKey: " + ds.getByKeys(User.class,keys));

		query();
	}
}

用Morphia操作对象相对比较简单，它对MongoDB对Java的操作进行了一些封装，特别是查询这方面的。有没有感觉像是在用Hibernate？

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!