mongodb

MongoDB[2] 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引存储的结构主要是以文档结构存储。

MongoDB 的设计目标是高性能、可扩展、易部署、易使用，存储数据非常方便。其主要功能特性如下。
（1）面向集合存储，容易存储对象类型的数据。在MongoDB 中数据被分组存储在集合中，集合类似RDBMS 中的表，一个集合中可以存储无限多的文档。
（2）模式自由，采用无模式结构存储。在MongoDB 中集合中存储的数据是无模式的文档，采用无模式存储数据是集合区别于RDBMS 中的表的一个重要特征。
（3）支持完全索引，可以在任意属性上建立索引，包含内部对象。MongoDB的索引和RDBMS 的索引基本一样，可以在指定属性、内部对象上创建索引以提高查询的速度。除此之外，MongoDB 还提供创建基于地理空间的索引的能力。
（4）支持查询。MongoDB 支持丰富的查询操作，MongoDB 几乎支持SQL中的大部分查询。
（5）强大的聚合工具。MongoDB 除了提供丰富的查询功能外，还提供强大的聚合工具，如count、group 等，支持使用MapReduce 完成复杂的聚合任务。
（6）支持复制和数据恢复。MongoDB 支持主从复制机制，可以实现数据备份、故障恢复、读扩展等功能。而基于副本集的复制机制提供了自动故障恢复的功能，确保了集群数据不会丢失。
（7）使用高效的二进制数据存储，包括大型对象（如视频）。使用二进制格式存储，可以保存任何类型的数据对象。
（8）自动处理分片，以支持云计算层次的扩展。MongoDB 支持集群自动切分数据，对数据进行分片可以使集群存储更多的数据，实现更大的负载，也能保证存储的负载均衡。
（9）支持Perl、PHP、Java、C#、JavaScript、Ruby、C 和C++语言的驱动程序，MongoDB 提供了当前所有主流开发语言的数据库驱动包，开发人员使用任何一种主流开发语言都可以轻松编程，实现访问MongoDB 数据库。
（10）文件存储格式为BSON（JSON 的一种扩展）。BSON 是对二进制格式的JSON 的简称，BSON 支持文档和数组的嵌套。
（11）可以通过网络访问。可以通过网络远程访问MongoDB 数据库


mongodb 简介：[url]http://baike.baidu.com/link?url=63fcML-w5OtG3DVirncnrllJ1D2X57rElq20Drf_r6mJqoJrHFv4XSZ1c4P4tE0ArZNZW4YSZm-StOkkYyC-9_[/url]
mongodb和关系性数据库的优缺点对比：[url]http://blog.sina.com.cn/s/blog_966e430001019s8v.html[/url]
mongodb的常用命令：[url]http://www.jb51.net/article/48217.htm[/url]

链接数据库 mongo 192.168.x.xx:27017/admin
db.auth("username","passwprd")认证。
show dbs:显示数据库列表
show collections：显示当前数据库中的集合（类似关系数据库中的表）
show users：显示用户
use <db name>：切换当前数据库，这和MS-SQL里面的意思一样
db.help()：显示数据库操作命令，里面有很多的命令
db.foo.help()：显示集合操作命令，同样有很多的命令，foo指的是当前数据库下，一个叫foo的集合，并非真正意义上的命令
db.foo.find()：对于当前数据库中的foo集合进行数据查找（由于没有条件，会列出所有数据）
db.foo.find( { a : 1 } )：对于当前数据库中的foo集合进行查找，条件是数据中有一个属性叫a，且a的值为1

package First.com.downjoy.first;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Query;

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.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.MongoException;
import com.mongodb.ServerAddress;
import com.mongodb.WriteResult;
import com.mongodb.util.JSON;

import entity.User;
/**
 *  Mongo：连接服务器，执行一些数据库操作的选项，如新建立一个数据库等
    DB：对应一个数据库，可以用来建立集合等操作
    DBCollection：对应一个集合（类似表），可能是我们用得最多的，可以添加删除记录等
    DBObject接口和BasicDBObject对象：表示一个具体的记录，BasicDBObject实现了DBObject，是key-value的数据结构，用起来和HashMap是基本一致的。
    DBCursor：用来遍历取得的数据，实现了Iterable和Iterator
 * @author kun.zhang@downjoy.com
 *
 *
 */
public class MongodbTest {
	private static final String dbName ="test";
	private  static Mongo mongo;
	private static DB db;	
	private static char[] password = "Pwd-monGo-321".toCharArray();
	private static  final ServerAddress serverAddress1 = new ServerAddress("192.168.9.25",27017);

	static{	
		try{
			//权限认证：
			MongoCredential mongoCredential = MongoCredential.createCredential("super-user", "admin", password);
			List<MongoCredential> credentialsList  = new ArrayList<MongoCredential>();
			credentialsList.add(mongoCredential);
			//链接ip端口和数据库
			mongo = new MongoClient(serverAddress1,credentialsList,MongoClientOptions.builder().build());

			db = new DB(mongo, dbName);
			System.out.println("数据库链接成功");
		}
		catch(MongoException  e){
			e.printStackTrace();
		}
	}
	/**
	 * 判断文档是否存在：
	 * @param name
	 * @return
	 */
	public static boolean CollectionsExists(String name){	
		return db.collectionExists(name);
	}
	/**
	 * 查询单个按照主建查询
	 * @param id
	 * @param name
	 */
	public static void findById(String id,String name){
		Map<String,Object> map = new Hashtable<String, Object>();
		map.put("_id", id);
		findOne(map,name);

	}
	public static void findOne(Map<String, Object> map, String name) {
		DBObject dbObject = getMapped(map);
		DBObject object = getCollection(name).findOne(dbObject);

	}
	/**
	 * 根据名字获取指定的集合
	 * @param name
	 * @return
	 */
	public  static DBCollection getCollection(String name) {	
		return db.getCollection(name);
	}
	private static DBObject getMapped(Map<String, Object> map) {
		return  (DBObject) (map =new Hashtable<String, Object>());
	}
	/**
	 * 插入数据
	 * @param name 集合名
	 */
	public static void insertJson(String name){
		String jsonData = "{'a1':'1','a2':'2',"+"'detail':{'resords':99,'index':'vps_index','active':'true'}}}";
		DBObject dbObject = (DBObject) JSON.parse(jsonData);
		DBCollection collection = getCollection(name);
		collection.insert(dbObject);
		DBCursor cursor = collection.find();//获取刚刚插入的数据
		while(cursor.hasNext()){
			System.out.println(cursor.next());
		}
	}
	/**
	 * 获取所有的集合
	 */
	public void testGetAllCollections(){
		Set<String> setCollections = db.getCollectionNames(); 
		for (String string : setCollections) {
			System.out.println("所有集合："+string);
		}
	}
	/**
	 * 查询所有用户信息
	 */
	public void findUser(){		
	}
	/**
	 * 初始化数据
	 */
	public void testInit(String name){
		//获取一个集合想到与数据库中的表，如果没有就创建这个collection 
		DBCollection collection = getCollection(name);
		//删除数据库中的数据 相当于数据库中的表
		collection.drop();
		BasicDBObject basicDBObject = new BasicDBObject();
		String jsondata = "{'a':1,'b':2,'c':{'c1':'c1','c2':'c2'}}";
		basicDBObject = (BasicDBObject) JSON.parse(jsondata);
		basicDBObject.put("name", "name1");
		basicDBObject.put("type", "type1");
		basicDBObject.put("count", 2);
		BasicDBObject info = new BasicDBObject();
		info.put("x", 203);
		info.put("y", 102);
		basicDBObject.put("info", info);
		collection.insert(basicDBObject);//这一张表中插入数据
		//批量插入
		List datas = new ArrayList();
		for(int i=0;i<10;i++){
		 BasicDBObject bs = new BasicDBObject();
		 bs.put("name", "meinv");
		 bs.append("age",i);
		 datas.add(bs);	 
		}
		collection.insert(datas);		
		testFind(name);		
	}
	/**
	 * 查找集合中第一个文档
	 * @param name
	 */
	public void testfindone(String name){
		DBCollection collection = getCollection(name);
		System.out.println("统计文档的数量："+collection.getCount());
		DBObject db = collection.findOne();
		System.out.println(db);
	}
	/**
	 * 使用光标来获取全部文档
	 * @param name
	 */
	public void testFind(String name){
		DBCollection collection = getCollection(name);
        DBCursor cursor =		collection.find();
        for (DBObject dbObject : cursor) {
			System.out.println("文档内容："+dbObject);
		}	
	}
	/**
	 * 通过指定条件查询
	 * @param name
	 * @param i
	 */
	public void testQuery(String name,int i){
		DBObject query = new BasicDBObject();
		DBCollection collection = getCollection(name);
		query.put("age", i);
		DBCursor cursor = collection.find(query);
		for (DBObject dbObject : cursor) {
			System.out.println(dbObject);
		}	
	}	
	public void addUser(String name){
		testFind(name);
		DBCollection collection = getCollection(name);
		System.out.println("count:"+collection.count());
		DBObject dbObject = new BasicDBObject();
		//存入字段
		dbObject.put("name", "meinv");
		dbObject.put("id", 123l);
		System.out.println(collection.save(dbObject).getN());//获取影响行数
		//存入多个字段
		System.out.println(collection.insert(new BasicDBObject("key","value"),new BasicDBObject("key1","value1")));
		//存入一个集合
		//List<DBObject> list = new ArrayList<DBObject>();
		//list.add(dbObject);
		//System.out.println(collection.insert(list).getN());
		testFind(name);
	}	
	/**
	 * 根据传入的类型来判读移除
	 * @param name
	 * @param index
	 */
	public void remove(String name,Object index){
		testFind(name);
		DBObject dbObject = null;
		DBCollection collection = getCollection(name);
		if(index instanceof Long){
			dbObject= new BasicDBObject("id",index);
		}else{
			 dbObject = new BasicDBObject("key",index);	
	    }
		System.out.println((collection.remove(dbObject)).getN());
		testFind(name);
       }
/**
 * 条件移除  mongoDB提供了比较操作符，$lt(<)，$lte(<=),$gt(>),$gte(>=),$ne(!=)
 * @param name
 * @param i
 */
   public void  removeExpend(String name,Integer i  ){
	   testFind(name);
		DBObject dbObject = null;
		DBCollection collection = getCollection(name);
		//移除年龄大于i的数据
		dbObject =new BasicDBObject("age", new BasicDBObject("$gte",i)) ;
		System.out.println(collection.remove(dbObject).getN());
		testFind(name);
   }  
   /**
    * 修改
    * @param name
    * @param id
    * @param age
    */
   public void updateUser(String name,Long id,Integer age){
	   testFind(name);
	   DBObject dbObject = null;
	   DBCollection collection = getCollection(name);
	   dbObject = new BasicDBObject("_id",id);
	  //修改编号为id 的年龄 true 表示如果数据库没有是否添加 ，false 表示如果存在多条数据，就修改
	  WriteResult writeResult = collection.update(dbObject, new BasicDBObject("age",age), true, false);
	  System.out.println(writeResult.getN());
	  testFind(name);  
   }  
}

mongodb查询获取对象转换

package First.com.downjoy.first;
import java.util.List;
import org.mongodb.morphia.Datastore;
import org.mongodb.morphia.dao.BasicDAO;
import org.mongodb.morphia.query.Query;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import entity.User;
public class UserServiceMongo extends BasicDAO<User, String>{	
	public MongodbTest mongodbTest;
	public UserServiceMongo(Class<User> entityClass, Datastore ds) {
		super(entityClass, ds);
	}
	/**
	 * 存入一个对象。相当于把这个对象当做一个集合列表来存。
	 * @param name
	 */
	public void testClassCon(String name){
		User user = new User();
		user.setAge(18);
		user.setId(1202l);
		user.setName("meinv");
		user.setWife("meinv");
		MongodbTest mongodbTest = new MongodbTest();
		DBCollection collection = mongodbTest.getCollection(name);
		collection.drop();
		this.save(user);
		DBCursor cursor = collection.find();
		while(cursor.hasNext()){
			System.out.println(cursor.next());
		}
		System.out.println(user.getAge());	
	}	
	/** 
	 * Datastore ds = ...  
     * Query q = ds.createQuery(MyEntity.class).filter("foo >", 12);  
     * Datastore ds = ... Query q = ds.createQuery(MyEntity.class).filter("foo >", 12);
	 * filter(..)方法过滤  filter("foo >", 12)
	 * Fields fluent 接口以field(name)开始。接着一下任何一个方法都可以添加到这个格式中， 流式查询接口
	 * 将查询出来的数据转成一个list列表 通过Query spring -data -mongodb 已经配置文件
	 *  //is相当于等于  
     *  in相当于sql中的in  
     *  ne相当于不等于  
     *  orOperator接受多个条件，组成or逻辑
	 */
	public void updateUser(){
		Query<User> query = createQuery();
		List<User> userList = query.asList();
		for(int i=0;i<userList.size();i++){
			User user = userList.get(i);
			System.out.println(user.getWife());
		}
	}
}

package First.com.downjoy.first;
import mongo.ext.DataStoreFactoryBean;
import mongo.ext.MongoClientOption;
import mongo.ext.MongoFactoryBean;
import org.junit.Test;
import org.mongodb.morphia.Morphia;
import com.mongodb.MongoClient;
import entity.User;
public class TestRedis {	
	MongodbTest mongodbTest = new MongodbTest();
	//@Test
    public void test1(){
		RedisTest redisTest = new RedisTest();
		redisTest.show();	
	}
   @Test
    public void test2() throws Exception{
    	//mongodbTest.insertJson("test");
    	//mongodbTest.testGetAllCollections();
    	//mongodbTest.testInit("user");
    	//mongodbTest.testfindone("user");
    	//mongodbTest.testFind("user");
    	//mongodbTest.testQuery("user", 7);
    	MongoFactoryBean mongoFactoryBean = new MongoFactoryBean();
    	mongoFactoryBean.setMongoOption(new MongoClientOption());
    	mongoFactoryBean.setReadSecondary(true);
    	mongoFactoryBean.setServerStrings(new String[]{"192.168.9.25:27017"});
    	mongoFactoryBean.setCredentialStrings(new String[]{"admin:super-user:Pwd-monGo-321"});
    	DataStoreFactoryBean bean = new DataStoreFactoryBean();
    	bean.setDbName("test");
    	bean.setMongo((MongoClient)mongoFactoryBean.createInstance());
    	Morphia morphia = new Morphia();
    	morphia = morphia.map(User.class);
    	bean.setMorphia(morphia);
    	UserServiceMongo userServiceMongo = new UserServiceMongo(User.class, bean.createInstance());
//		User user = new User();
//		user.setAge(20);
//		user.setId(1207l);
//		user.setName("meinv");
//		user.setWife("meinv");
//		userServiceMongo.save(user);
    	//userServiceMongo.testClassCon("user");	
    	userServiceMongo.updateUser();
    }
    //@Test
    public void testMongodb(){
    	//mongodbTest.addUser("user");
    	//mongodbTest.remove("user", 123l);
    	//mongodbTest.removeExpend("user", 19);
    	mongodbTest.updateUser("user", 1202l, 17);
    }

}

这里说明一下，转成对象，是通过Spring -data -mongodb API实现的，可以通过配置文件实现 ：[url]http://my.oschina.net/fengshuzi/blog/346303[/url]