注册 登录
LUPA开源社区 返回首页

joejoe0332的个人空间 http://www.lupaworld.com/?22802 [收藏] [复制] [分享] [RSS]

我的博客

Java Tutorial(Java操作MongoDB入门)

热度 1已有 1633 次阅读2011-8-8 10:31 |系统分类:IT技术

Java TutorialJava操作MongoDB入门)

Introduction

介绍

This page is a brief overview of working with the MongoDB Java Driver.

这是使用MongoDB java驱动的简单说明。

For more information about the Java API, please refer to the online API Documentation for Java Driver

想获取更多关于javaAPI,请查看在线API文档。

A Quick Tour

Using the Java driver is very simple. First, be sure to include the driver jar mongo.jar in your classpath. The following code snippets come from the examples/QuickTour.java example code found in the driver.

使用很简单。首先将驱动mongo.jar放入classpath。下面的代码段是驱动中例子examples/QuickTour.java中的内容

Making A Connection

创建连接

To make a connection to a MongoDB, you need to have at the minimum, the name of a database to connect to. The database doesn't have to exist - if it doesn't, MongoDB will create it for you.

创建连接至少需要你要连接的数据库名。如果数据库不存在,MongoDB会自动创建。

Additionally, you can specify the server address and port when connecting. The following example shows three ways to connect to the database mydb on the local machine :

此外,你还可以指定数据库服务器地址和端口。下边的例子中有三种连接本机mydb数据库方法:

01 import com.mongodb.Mongo;
02 import com.mongodb.DB;
03 import com.mongodb.DBCollection;
04 import com.mongodb.BasicDBObject;
05 import com.mongodb.DBObject;
06 import com.mongodb.DBCursor;
07   
08 Mongo m = new Mongo();
09 // or
10 Mongo m = new Mongo( "localhost" );
11 // or
12 Mongo m = new Mongo( "localhost" , 27017 );
13   
14 DB db = m.getDB( "mydb" );

At this point, the db object will be a connection to a MongoDB server for the specified database. With it, you can do further operations.

db对象就是连接服务器中指定数据库的连接。使用他你可以做很多操作。

Note: The Mongo object instance actually represents a pool of connections to the database; you will only need one object of class Mongo even with multiple threads. See the concurrency doc page for more information.

注意:Mongo的实例是数据库连接池;在多个线程中只需要一个实例。更多的介绍请参考concurrency文档。

The Mongo class is designed to be thread safe and shared among threads. Typically you create only 1 instance for a given DB cluster and use it across your app. If for some reason you decide to create many mongo intances, note that:

Mongo类是线程安全和共享的。可以在整个应用中使用他。如果你想创建多个Mongo实例,注意:

all resource usage limits (max connections, etc) apply per mongo instance

每个mongo实例的资源使用限制

to dispose of an instance, make sure you call mongo.close() to clean up resources

记得使用mongo.close()关闭资源

Authentication (Optional)

授权(可选)

MongoDB can be run in a secure mode where access to databases is controlled through name and password authentication. When run in this mode, any client application must provide a name and password before doing any operations. In the Java driver, you simply do the following with the connected mongo object :

MongoDB可以运行在通过用户名和密码控制的安全的模式下。当以安全模式运行时,任何客户端应用程序的操作必须验证用户名和密码。在java中,验证很简单:

1 boolean auth = db.authenticate(myUserName, myPassword);

If the name and password are valid for the database, auth will be true. Otherwise, it will be false. You should look at the MongoDB log for further information if available.

如果用户名和密码正确,auth值为true。错误为false。在日志中可以看到更多有效的信息。

Most users run MongoDB without authentication in a trusted environment.

很多用户将MongoDB以非授权模式运行在安全的环境中。

Getting A List Of Collections

查询Collection的集合(Collection类似于表)

Each database has zero or more collections. You can retrieve a list of them from the db (and print out any that are there) :

每个数据库可以有任意个collection。通过db对象可以检索并打印出来:

1 Set<String> colls = db.getCollectionNames();
2   
3  for (String s : colls) {
4   
5     System.out.println(s);
6   
7 }

and assuming that there are two collections, name and address, in the database, you would see

假如数据库中有nameaddress两个collection,结果输出入下

1 name
2   
3 address

as the output.

 Getting A Collection

得到Collection

To get a collection to use, just specify the name of the collection to the getCollection(String collectionName) method:

要使用collection,使用getCollection(String collectionName) 方法传入collection的名称:

1 DBCollection coll = db.getCollection("testCollection")

Once you have this collection object, you can now do things like insert data, query for data, etc

得到collection对象后就可以进行插入、查询等操作了。

Inserting a Document

插入一个文档(类似一条记录)

Once you have the collection object, you can insert documents into the collection. For example, lets make a little document that in JSON would be represented as

得到collection对象就可以把documents插入到collection中。例如,创建一个如下的JSON文档

01 {
02   
03    "name" : "MongoDB",
04   
05    "type" : "database",
06   
07    "count" : 1,
08   
09    "info" : {
10   
11                x : 203,
12   
13                y : 102
14   
15              }
16   
17 }

Notice that the above has an "inner" document embedded within it. To do this, we can use the BasicDBObject class to create the document (including the inner document), and then just simply insert it into the collection using the insert() method.

注意,上面的文档中有个内部文档(就是{ x : 203, y : 102})。存储上面的文档,可以使用BasicDBObject 类来创建文档(包括inner文档),使用insert()方法可以简单的把文档插入collection中。

01 BasicDBObject doc = new BasicDBObject();
02  
03  
04 doc.put("name", "MongoDB");
05  
06 doc.put("type", "database");
07  
08 doc.put("count", 1);
09  
10 BasicDBObject info = new BasicDBObject();
11  
12 info.put("x", 203);
13  
14 info.put("y", 102);
15  
16  
17  
18 doc.put("info", info);
19  
20  
21  
22 coll.insert(doc);

 

Finding the First Document In A Collection using findOne()

使用findOne()方法查找collection中的第一个文档document

To show that the document we inserted in the previous step is there, we can do a simple findOne() operation to get the first document in the collection. This method returns a single document (rather than the DBCursor that the find() operation returns), and it's useful for things where there only is one document, or you are only interested in the first. You don't have to deal with the cursor.

可以使用findOne()操作来查找collection中的第一个文档来显示上一步中插入的文档。方法返回一个文档,用来找只有一个文档或第一条文档很实用。可以不使用cursor(游标)

1 DBObject myDoc = coll.findOne();
2   
3 System.out.println(myDoc);

and you should see

打印的结果

1 { "_id" : "49902cde5162504500b45c2c" , "name" : "MongoDB" , "type" : "database" , "count" : 1 , "info" : { "x" : 203 , "y" : 102}}

Note the _id element has been added automatically by MongoDB to your document. Remember, MongoDB reserves element names that start with "_"/"$" for internal use.

注意,_id元素是MongoDB自动添加的。MongoDB内部的元素以"_"/"$"开始。

Adding Multiple Documents

添加多个文档

In order to do more interesting things with queries, let's add multiple simple documents to the collection. These documents will just be

为了方便下面的讲解,我们来添加多个简单的文档,入下

1 {
2   
3    "i" : value
4   
5 }

and we can do this fairly efficiently in a loop

用循环来快速的实现

1 for (int i=0; i < 100; i++) {
2   
3     coll.insert(new BasicDBObject().append("i", i));
4   
5 }

Notice that we can insert documents of different "shapes" into the same collection. This aspect is what we mean when we say that MongoDB is "schema-free"

注意,可以在一个collection中插入不同类型的文档。就是说MongoDB"schema-free"(什么意思?)

Counting Documents in A Collection

统计collection中所有的document数量

Now that we've inserted 101 documents (the 100 we did in the loop, plus the first one), we can check to see if we have them all using the getCount() method.

现在,插入了101个文档(循环的100个和第一个),使用getCount()检查一下。

1 System.out.println(coll.getCount());

and it should print 101.

输出结果是101.

Using a Cursor to Get All the Documents

使用游标查找所有的文档

In order to get all the documents in the collection, we will use the find() method. The find() method returns a DBCursor object which allows us to iterate over the set of documents that matched our query. So to query all of the documents and print them out :

使用find()来查找所有的documentfind()方法查询返回一个可以遍历文档集合的DBCursor 对象。如下:

1 DBCursor cur = coll.find();
2  
3  
4  
5 while(cur.hasNext()) {
6  
7     System.out.println(cur.next());
8  
9 }

and that should print all 101 documents in the collection.

打印所有的document

Getting A Single Document with A Query

查询出单个文档

We can create a query to pass to the find() method to get a subset of the documents in our collection. For example, if we wanted to find the document for which the value of the "i" field is 71, we would do the following ;

可以通过find()方法查找部分document,例如,如果想查找i=71document,这样做

01 BasicDBObject query = new BasicDBObject();
02  
03  
04  
05 query.put("i", 71);
06  
07  
08  
09 cur = coll.find(query);
10  
11  
12  
13 while(cur.hasNext()) {
14  
15     System.out.println(cur.next());
16  
17 }
 

and it should just print just one document

会打印找到的单个document

1 { "_id" : "49903677516250c1008d624e" , "i" : 71 }

You may commonly see examples and documentation in MongoDB which use $ Operators, such as this:

MongoDB文档和例子中经常出现$操作符,如下

1 db.things.find({j: {$ne: 3}, k: {$gt: 10} });
 

These are represented as regular String keys in the Java driver, using embedded DBObjects:

他表示驱动中预设的字符:

01 BasicDBObject query = new BasicDBObject();
02  
03  
04  
05 query.put("j", new BasicDBObject("$ne", 3));
06  
07 query.put("k", new BasicDBObject("$gt", 10));
08  
09  
10  
11 cur = coll.find(query);
12  
13  
14  
15 while(cur.hasNext()) {
16  
17     System.out.println(cur.next());
18  
19 }

Getting A Set of Documents With a Query

查找多个文档

We can use the query to get a set of documents from our collection. For example, if we wanted to get all documents where "i" > 50, we could write :

例如,想找"i">50的文档,这样做:

01 query = new BasicDBObject();
02  
03  
04  
05 query.put("i", new BasicDBObject("$gt", 50));  // e.g. find all where i > 50
06  
07  
08  
09 cur = coll.find(query);
10  
11  
12  
13 while(cur.hasNext()) {
14  
15     System.out.println(cur.next());
16  
17 }

which should print the documents where i > 50. We could also get a range, say 20 < i <= 30 :

会打印出i>50的文档。也可以查找范围如20<i<=30

01 query = new BasicDBObject();
02  
03  
04  
05 query.put("i", new BasicDBObject("$gt", 20).append("$lte", 30));  // i.e.   20 < i <= 30
06  
07  
08  
09 cur = coll.find(query);
10  
11  
12  
13 while(cur.hasNext()) {
14  
15     System.out.println(cur.next());
16  
17 }

 

Creating An Index

创建索引

MongoDB supports indexes, and they are very easy to add on a collection. To create an index, you just specify the field that should be indexed, and specify if you want the index to be ascending (1) or descending (-1). The following creates an ascending index on the "i" field :

MongoDB支持索引,并且很容易添加。只需要指定索引的字段和排序(升序1,降序-1)。下面是创建i降序索引的例子:

1 coll.createIndex(new BasicDBObject("i", 1));  // create index on "i", ascending

 

Getting a List of Indexes on a Collection

查询collection全部索引

You can get a list of the indexes on a collection :

 

1 List<DBObject> list = coll.getIndexInfo();
2  
3  
4  
5 for (DBObject o : list) {
6  
7     System.out.println(o);
8  
9 }
 

and you should see something like

打印如下

1 { "name" : "i_1" , "ns" : "mydb.testCollection" , "key" : { "i" : 1} }

Quick Tour of the Administrative Functions

管理方法

Getting A List of Databases

查询所有数据库

You can get a list of the available databases:

打印出可用的数据库

1 Mongo m = new Mongo();
2  
3  
4  
5 for (String s : m.getDatabaseNames()) {
6  
7     System.out.println(s);
8  
9 }

 

Dropping A Database

删除数据库

You can drop a database by name using the Mongo object:

通过名称删除

1 m.dropDatabase("my_new_db");

刚表态过的朋友 (0 人)

评论 (0 个评论)

facelist

您需要登录后才可以评论 登录 | 注册
验证问答 换一个 验证码 换一个

关于LUPA|人才芯片工程|人才招聘|LUPA认证|LUPA教育|LUPA开源社区 ( 浙B2-20090187 浙公网安备 33010602006705号   

返回顶部