mongodb のセキュア認証を有効にするには、mongod サービスの起動時に -auth パラメータを指定して セキュア認証が有効であることを示す必要があります。

mongod --auth

開通後、クライアント経由で接続すると、接続はできるが、操作はできない

G:\JavaData\mongoDB\bin>mongo
MongoDB shell version: 2.6.3
connecting to: test

> show collections
2015-06-05T20:10:51.608+0800 error: {
        "$err" : "not authorized for query on test.system.namespaces",
        "code" : 13
} at src/mongo/shell/query.js:131
>

プロンプトから、このエラーは認証がないことが原因であることがわかります。

データベース管理者に切り替えて、ユーザーを追加します。ユーザーを作成する構文は次のとおりです。

db.createUser({
    user:"username",
    pwd:"password",
    customData:{any info},
    roles:[{role:"

"
,db:"
"
},{role:"
"
,db:"
"
}]
})

ここで、mongodb には組み込みのロールがあります：read, readWrite, dbAdmin, dbOwner, userAdmin, dbAdminAnyDatabase, userAdminAnyDatabase, readWriteAnyDatabase readAnyDatabase, clusterAdmin。

この例では、次のステートメントを使用して、読み取り専用権限を持つデモデータベース用のlwbユーザーを作成します。

> db.createUser({user:"lwb",pwd:"lwb",roles:[{role:"read",db:"demo"}]})
Successfully added user: {
        "user" : "lwb",
        "roles" : [
                {
                        "role" : "read",
                        "db" : "demo"
                }
        ]
}
> db
demo

は  db.auth("lwb","lwb")  を認証する

> use demo
switched to db demo
> show collections
2015-06-05T20:31:15.034+0800 error: {
        "$err" : "not authorized for query on demo.system.namespaces",
        "code" : 13
} at src/mongo/shell/query.js:131
> db.auth("lwb","lwb")
1
> show collections
system.indexes
users
> db.users.find()
{ "_id" : ObjectId("55717fd5e25992bae59cca66"), "username" : "saveMethod", "pwd" : " 9999" }

表示するための認証はできていますが、読み取り権限を指定したので、データを挿入できるかどうかをテストする必要があります。

> db.users.insert({username:'abc'})
WriteResult({
        "writeError" : {
                "code" : 13,
                "errmsg" : "not authorized on demo to execute command { insert: \"users\", documents: [ { _id: ObjectId(' 557196b2e661d1419e528fbb'), username: \
"abc\" } ], ordered: true }"
        }
})
>

ご覧の通り、認証に失敗しています。これは、lwb ユーザーが demo データベースの users コレクションにデータを挿入できないことを意味します。

比較のため、ユーザーrwu（read write user）を挿入し、このユーザーにreadWriteの権限を与えました。

> use admin
switched to db admin
> db.auth("admin","admin")
1
> db.createUser({user:"rwu",pwd:"rwu",roles:[{role:"readWrite",db:"demo"}]})
Successfully added user: {
        "user" : "rwu",
        "roles" : [
                {
                        "role" : "readWrite", //with read-write privileges
                        "db" : "demo" //read and write permissions for the demo database
                }
        }
}
> use demo
switched to db demo
> show collections
system.indexes
users
> db.users.find()
{ "_id" : ObjectId("55717fd5e25992bae59cca66"), "username" : "saveMethod", "pwd" : " 9999" }
> db.users.save({username:"rwu",pwd:"rwu"}) //insert a piece of data, inserting it successfully means the authorization is successful
WriteResult({ "nInserted" : 1 })
> db.users.find()
{ "_id" : ObjectId("55717fd5e25992bae59cca66"), "username" : "saveMethod", "pwd" : " 9999" }
{ "_id" : ObjectId("557198f5e661d1419e528fbc"), "username" : "rwu", "pwd" : "rwu& quot; }
>

上記の観察から、readWrite パーミッションを持つ新規作成ユーザー rwu は、demo データベースの users コレクションにデータを挿入できることがわかります。

パーミッションについては以上です。詳しくは mongodbのマニュアル .

環境整備。

1.mongoが正常に動作すること、第1回目の記事を参照

2. すでにデモ用データベースがある場合は、データがクリーンであることを確認するため、削除することをお勧めします。

use demo
switched to db demo
db.dropDatabase()
{ "dropped" : "demo", "ok" : 1 }

この記事では、ユーザー認証をオンにして直接操作することはありません。プロジェクトのビルドにはgradleを使用します。(gradleの使い方は、gradle入門の記事を参照してください)

プロジェクトmongoを作成し、ルートディレクトリの下にbuild.gradleファイルを作成します。

apply plugin:"java"
apply plugin:"eclipse"

repositories{
    mavenCentral()
}

dependencies{
    compile 'org.mongodb:mongo-java-driver:3.0.2'
}

さらに、mavenと合意した通りにソースファイルを作成します。

└─src
   └─main
       ├─java
       └─resources

そして、今後のソースコードはjavaディレクトリの下に、リソースファイルはresourcesディレクトリの下に配置されることになります。

ここからmongo-javaの旅が始まります。

mongoプロジェクトのルートパスで > gradle cleanEclipse eclipse を実行して、Eclipse java プロジェクトを生成します。そして、次のようにEclipseのImport...機能を使ってmongoプロジェクトを取り込みます。

D:\workspace_myeclipse\mongo> gradle cleanEclipse eclipse

package com.piedra.mongo;

import static com.mongodb.client.model.Filters.and;
import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Filters.gt;
import static com.mongodb.client.model.Filters.lte;

import java.util.ArrayList;
import java.util.List;

import org.bson;
import org.bson.conversions.Bson;

import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;

/**
 * HelloMongo 
 * Reference: http://mongodb.github.io/mongo-java-driver/3.0/driver/getting-started/quick-tour/
 * @author LINWENBIN
 * @since 2015-6-6
 */
public class HelloMongo {

    /**
     * Insert a piece of data into a collection
     * @param coll
     * @since 2015-6-6
     * @author LINWENBIN
     */
    public void insertOne(MongoCollection<Document> coll){
        /*
        {
           "name" : "MongoDB",
           "type" : "database",
           "count" : 1,
           "info" : {
                       x : 203,
                       y : 102
                     }
        }
        */
        System.out.println("insertOne Number of users collection before inserting record:" + coll.count());

        Document doc = new Document("name","MongoDB")
        .append("type","database").append("count", 1).append("info", new Document("x"," ;203").append("y","102"));

        coll.insertOne(doc);

        System.out.println("insertOne insert the number of users collection after inserting records:" + coll.count());
    }

    /**
     * Insert multiple data
     * @param coll
     * @since 2015-6-6
     * @author LINWENBIN
     */
    public void insertMany(MongoCollection<Document> coll){
        /*
         * insertMany(MongoCollection<Document> coll)
         */
        List<Document> docs = new ArrayList<Document>();
        for(int i=0; i<10; i++){
            docs.add(new Document("i",i));
        }

        coll.insertMany(docs);

        System.out.println("insertMany inserting 10 {i:i} records after users collection: " + coll.count());        
    }

    /**
     * Query all the data in the collection coll
     * @param coll
     * @since 2015-6-6
     * @author LINWENBIN
     */
    public void findAll(MongoCollection<Document> coll){
        MongoCursor<Document> cursor = coll.find().iterator();
        try {
            System.out.println("findAll Print result: ");
            while(cursor.hasNext()){
                System.out.println(cursor.next().toJson());
            }
        } finally {
            cursor.close();
        }
    }

    /**
     * Query the first piece of data that meets the condition
     * @param coll
     * @param filter
     * @since 2015-6-6
     * @author LINWENBIN
     */
    public void findSpecifyDoc(MongoCollection<Document> coll, Bson filter){
        System.out.println("findSpecifyDoc print result: ");
        System.out.println(coll.find(filter).first().toJson());
    }

    /**
     * query to meet the conditions of the document collection
     * @param coll
     * @param filter
     * @since 2015-6-6
     * @author LINWENBIN
     */
    public void findDocs(MongoCollection<Document> coll, Bson filter){
        Block<Document> printBlock = new Block<Document>() {
             @Override
             public void apply(final Document document) {
                 System.out.println(document.toJson());
             }
        };
        System.out.println("findDocs print result: ");
        coll.find(filter).forEach(printBlock);
    }

    /**
     * Update document properties
     * @param coll The collection to be manipulated
     * @param criteria the document filter to be updated
     * @param newDoc new document property
     * @since 2015-6-6
     * @author LINWENBIN
     */
    public void update(MongoCollection<Document> coll, Bson criteria, Document newDoc){
        coll.updateMany(criteria, new Document("$set",newDoc));
    }

    /**
     * Delete a document
     * @param coll
     * @param criteria
     * @since 2015-6-6
     * @author LINWENBIN
     */
    public void delete(MongoCollection<Document> coll, Bson criteria){
        coll.deleteMany(criteria);
    }

    public static void main(String[] args) {
        HelloMongo helloMongo = new HelloMongo();

        //mongoClient instance itself represents the database connection pool
        MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);
        /**
         * Calling the getDatabase() on MongoClient does not create a database. 
         * Only when a database is written to will a database be created
         */
        MongoDatabase db = mongoClient.getDatabase("demo");
        MongoCollection<Document> users = db.getCollection("users");


        helloMongo.insertOne(users);
        helloMongo.insertMany(users);
        helloMongo.findAll(users);
        helloMongo.findSpecifyDoc(users, eq("i",5));
        helloMongo.findDocs(users, and(gt("i",6),lte("i",8)));

        helloMongo.update(users, and(gt("i",6),lte("i",8)), new Document("ii",99));
        helloMongo.findDocs(users, and(gt("i",6),lte("i",8)));

        helloMongo.delete(users, and(gt("i",6),lte("i",8)));
        helloMongo.findDocs(users, and(gt("i",6),lte("i",8)));

        // destroy
        mongoClient.dropDatabase("demo");
        //close the database connection
        mongoClient.close();
    }
}
Print the results.


insertOne 插入记录之前 users集合的数量:0
einfügenEin 插入记录之后 benutzer集合的数量:1
insertMany 插入10条 {i:i} 记录之后 users集合的数量:11
findAll 打印结果：
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bd8" }, "name" : "MongoDB", "type" : "database", "count" : 1, "info" : { "x" : "203", "y" : "102" } }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bd9" }, "i" : 0 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bda" }, "i" : 1 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bdb" }, "i" : 2 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bdc" }, "i" : 3 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bdd" }, "i" : 4 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bde" }, "i" : 5 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bdf" }, "i" : 6 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42be0" }, "i" : 7 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42be1" }, "i" : 8 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42be2" }, "i" : 9 }
findSpecifyDoc 打印结果：
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42bde" }, "i" : 5 }
findDocs 打印结果：
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42be0" }, "i" : 7 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42be1" }, "i" : 8 }
findDocs 打印结果：
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42be0" }, "i" : 7, "ii" : 99 }
{ "_id" : { "$oid" : "5572841e0ef45c0bf0e42be1" }, "i" : 8, "ii" : 99 }
findDocs 打印结果：

<イグ

HelloMongo.javaのソースコードは次のとおりです。

查询条件

首先往数据库集合里面插入几条数据 ...

测试数据：

> db.users.insert({username:"mongo", url:"webinglin.github.io", tags:["mongodb", database","nosql"],likes:999, author:"linwenbin"})
> db.users.insert({Benutzername:"redis", url:"webinglin.github.io", tags:["redis","database","nosql"],likes:888, author:"linwenbin"})
> db.users.insert({username:"spring", url:"webinglin.github.io", tags:["spring","framework"],likes:777, author:"linwenbin"})

> db.users.find().pretty()
{
        "_id" : ObjectId("5574bdabc705777157a515aa"),
        "username" : "mongo",
        "url" : "webinglin.github.io",
        "tags" : [
                "mongodb",
                "database",
                "nosql"
        ],
        "likes" : 999,
        "author" : "linwenbin"
}
{
        "_id" : ObjectId("5574bdd2c705777157a515ab"),
        "username" : "redis",
        "url" : "webinglin.github.io",
        "tags" : [
                "redis",
                "database",
                "nosql"
        ],
        "likes" : 888,
        "author" : "linwenbin"
}
{
        "_id" : ObjectId("5574bdf3c705777157a515ac"),
        "username" : "spring",
        "url" : "webinglin.github.io",
        "tags" : [
                "spring",
                "framework"
        ],
        "likes" : 777,
        "author" : "linwenbin"
}

pretty() 方法是对查询结果进行格式化

查询的时候可以带上查询条件，那具体的查询条件怎么使用？

その他

等于操作直接使用｛key:value｝这样的文档形式即可。

> db.users.find({username:"mongo"})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : "webinglin.github. io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, "author" : "linwenbin" }
>

大于

语法：{key : {$gt:value}。}

> db.users.find({likes:{$gt:888}})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : "webinglin.github. io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, "author" : "linwenbin" }
>

大于等于

语法：{key : {$gte:value}。}

> db.users.find({likes:{$gte:888}})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : "webinglin.github. io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, "author" : "linwenbin" }
{ "_id" : ObjectId("5574bdd2c705777157a515ab"), "username" : "redis", "url" : "webinglin.github. io", "tags" : [ "redis", "database", "nosql" ], "likes" : 888, "author" : "linwenbin" }

小于

语法：{key : {$lt:value}. }

> db.users.find({likes:{$lt:888}})
{ "_id" : ObjectId("5574bdf3c705777157a515ac"), "username" : "spring", "url" : "webinglin. github.io", "tags" : [ "spring", "framework" ], "likes" : 777, "author" : "linwenbin" }

小于等于

语法：{key : {$lte:value}}。

> db.users.find({likes:{$lte:888}})
{ "_id" : ObjectId("5574bdd2c705777157a515ab"), "username" : "redis", "url" : "webinglin.github. io", "tags" : [ "redis", "database", "nosql" ], "likes" : 888, "author" : "linwenbin" }
{ "_id" : ObjectId("5574bdf3c705777157a515ac"), "username" : "spring", "url" : "webinglin. github.io", "tags" : [ "spring", "framework" ], "likes" : 777, "author" : "linwenbin" }

不等于

语法：{key : {$ne:value}。}

> db.users.find({likes:{$ne:888}})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : "webinglin.github. io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, "author" : "linwenbin" }
{ "_id" : ObjectId("5574bdf3c705777157a515ac"), "username" : "spring", "url" : "webinglin. github.io", "tags" : [ "spring", "framework" ], "likes" : 777, "author" : "linwenbin" }

且操作アンド

语法：{key1:value1, key2:value2, key3:value3 ...}。

> db.users.find({likes:{$gt:777},username:"mongo"})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : "webinglin.github. io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, "author" : "linwenbin" }

> db.users.find({likes:{$gt:777}})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : "webinglin.github. io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, "author" : "linwenbin" }
{ "_id" : ObjectId("5574bdd2c705777157a515ab"), "username" : "redis", "url" : "webinglin.github. io", "tags" : [ "redis", "database", "nosql" ], "likes" : 888, "author" : "linwenbin" }

または演算OR

構文 { $or: [ {key1: value1}, {key2: value2} ] } or条件の {key:value} をすべて$orの値（配列）に入れる。

> db.users.find({$or:[{username:"mongo"},{username:"redis"}]})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : " webinglin.github.io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, " quot;author" : "linwenbin" }
{ "_id" : ObjectId("5574bdd2c705777157a515ab"), "username" : "redis", "url" : " webinglin.github.io", "tags" : [ "redis", "database", "nosql" ], "likes" : 888, " author" : "linwenbin" }

複雑な条件付きクエリ

すべての条件を連結して使うには？

例えば、次のようなクエリにしたい>=888 && (username="mongo" or username="spring")

上記のデータ項目は3つしかないので、like>=888を満たすのはmongoとredisだけで、その後にusername="mongo" or username="spring " もmongoとspringが条件を満たすことがわかり、この2つと操作の後に条件を満たすのはmongoだけが残っていることがわかるのです。というわけで、最終的には mongo 用のドキュメントができあがるはずです。

> db.users.find({likes:{$gte:888},$or:[{username:"mongo"},{username:"spring"}]})
{ "_id" : ObjectId("5574bdabc705777157a515aa"), "username" : "mongo", "url" : " webinglin.github.io", "tags" : [ "mongodb", "database", "nosql" ], "likes" : 999, " quot;author" : "linwenbin" }
>

find() のその他の使用法

投影

mongodbで、すべてのフィールドではなく、見たいフィールドを表示するという意味のプロジェクションとは何でしょうか？