java中使用MongoDB的方法

首先引入mongo-java-driver-3.1.0.jar这个jar包。--版本根据自己的项目定，我这里以mongo-java-driver-3.1.0为例；

java项目中使用MongoDB最关键的两个类：

1、MongoClient 类；

package com.mongodb;

import com.mongodb.DBObjectCodec;
import com.mongodb.DBObjectCodecProvider;
import com.mongodb.DBRefCodecProvider;
import com.mongodb.DocumentToDBRefTransformer;
import com.mongodb.Function;
import com.mongodb.ListDatabasesIterableImpl;
import com.mongodb.Mongo;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientURI;
import com.mongodb.MongoCredential;
import com.mongodb.MongoDatabaseImpl;
import com.mongodb.ReadPreference;
import com.mongodb.ServerAddress;
import com.mongodb.MongoClientOptions.Builder;
import com.mongodb.client.ListDatabasesIterable;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;
import com.mongodb.client.model.geojson.codecs.GeoJsonCodecProvider;
import java.io.Closeable;
import java.util.Arrays;
import java.util.List;
import org.bson.BsonDocument;
import org.bson.Document;
import org.bson.codecs.BsonValueCodecProvider;
import org.bson.codecs.DocumentCodecProvider;
import org.bson.codecs.ValueCodecProvider;
import org.bson.codecs.configuration.CodecProvider;
import org.bson.codecs.configuration.CodecRegistries;
import org.bson.codecs.configuration.CodecRegistry;

public class MongoClient extends Mongo implements Closeable {
    private static final CodecRegistry DEFAULT_CODEC_REGISTRY = CodecRegistries.fromProviders(Arrays.asList(new CodecProvider[]{new ValueCodecProvider(), new DBRefCodecProvider(), new DocumentCodecProvider(new DocumentToDBRefTransformer()), new DBObjectCodecProvider(), new BsonValueCodecProvider(), new GeoJsonCodecProvider()}));

    public static CodecRegistry getDefaultCodecRegistry() {
        return DEFAULT_CODEC_REGISTRY;
    }

    public MongoClient() {
        this(new ServerAddress());
    }

    public MongoClient(String host) {
        this(new ServerAddress(host));
    }

    public MongoClient(String host, MongoClientOptions options) {
        this(new ServerAddress(host), options);
    }

    public MongoClient(String host, int port) {
        this(new ServerAddress(host, port));
    }

    public MongoClient(ServerAddress addr) {
        this(addr, (new Builder()).build());
    }

    public MongoClient(ServerAddress addr, List<MongoCredential> credentialsList) {
        this(addr, credentialsList, (new Builder()).build());
    }

    public MongoClient(ServerAddress addr, MongoClientOptions options) {
        super(addr, options);
    }

    public MongoClient(ServerAddress addr, List<MongoCredential> credentialsList, MongoClientOptions options) {
        super(addr, credentialsList, options);
    }

    public MongoClient(List<ServerAddress> seeds) {
        this(seeds, (new Builder()).build());
    }

    public MongoClient(List<ServerAddress> seeds, List<MongoCredential> credentialsList) {
        this(seeds, credentialsList, (new Builder()).build());
    }

    public MongoClient(List<ServerAddress> seeds, MongoClientOptions options) {
        super(seeds, options);
    }

    public MongoClient(List<ServerAddress> seeds, List<MongoCredential> credentialsList, MongoClientOptions options) {
        super(seeds, credentialsList, options);
    }

    public MongoClient(MongoClientURI uri) {
        super(uri);
    }

    public MongoClientOptions getMongoClientOptions() {
        return super.getMongoClientOptions();
    }

    public List<MongoCredential> getCredentialsList() {
        return super.getCredentialsList();
    }

    public MongoIterable<String> listDatabaseNames() {
        return (new ListDatabasesIterableImpl(BsonDocument.class, getDefaultCodecRegistry(), ReadPreference.primary(), this.createOperationExecutor())).map(new Function() {
            public String apply(BsonDocument result) {
                return result.getString("name").getValue();
            }
        });
    }

    public ListDatabasesIterable<Document> listDatabases() {
        return this.listDatabases(Document.class);
    }

    public <T> ListDatabasesIterable<T> listDatabases(Class<T> clazz) {
        return new ListDatabasesIterableImpl(clazz, this.getMongoClientOptions().getCodecRegistry(), ReadPreference.primary(), this.createOperationExecutor());
    }

    public MongoDatabase getDatabase(String databaseName) {
        MongoClientOptions clientOptions = this.getMongoClientOptions();
        return new MongoDatabaseImpl(databaseName, clientOptions.getCodecRegistry(), clientOptions.getReadPreference(), clientOptions.getWriteConcern(), this.createOperationExecutor());
    }

    static DBObjectCodec getCommandCodec() {
        return new DBObjectCodec(getDefaultCodecRegistry());
    }
}

2、MongoDatabase接口以及它的实现类；

package com.mongodb.client;

import com.mongodb.ReadPreference;
import com.mongodb.WriteConcern;
import com.mongodb.annotations.ThreadSafe;
import com.mongodb.client.ListCollectionsIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoIterable;
import com.mongodb.client.model.CreateCollectionOptions;
import org.bson.Document;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.conversions.Bson;

@ThreadSafe
public interface MongoDatabase {
    String getName();

    CodecRegistry getCodecRegistry();

    ReadPreference getReadPreference();

    WriteConcern getWriteConcern();

    MongoDatabase withCodecRegistry(CodecRegistry var1);

    MongoDatabase withReadPreference(ReadPreference var1);

    MongoDatabase withWriteConcern(WriteConcern var1);

    MongoCollection<Document> getCollection(String var1);

    <TDocument> MongoCollection<TDocument> getCollection(String var1, Class<TDocument> var2);

    Document runCommand(Bson var1);

    Document runCommand(Bson var1, ReadPreference var2);

    <TResult> TResult runCommand(Bson var1, Class<TResult> var2);

    <TResult> TResult runCommand(Bson var1, ReadPreference var2, Class<TResult> var3);

    void drop();

    MongoIterable<String> listCollectionNames();

    ListCollectionsIterable<Document> listCollections();

    <TResult> ListCollectionsIterable<TResult> listCollections(Class<TResult> var1);

    void createCollection(String var1);

    void createCollection(String var1, CreateCollectionOptions var2);
}

MongoDatabase实现类

package com.mongodb;

import com.mongodb.Function;
import com.mongodb.ListCollectionsIterableImpl;
import com.mongodb.MongoClient;
import com.mongodb.MongoCollectionImpl;
import com.mongodb.MongoNamespace;
import com.mongodb.ReadPreference;
import com.mongodb.WriteConcern;
import com.mongodb.assertions.Assertions;
import com.mongodb.client.ListCollectionsIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;
import com.mongodb.client.model.CreateCollectionOptions;
import com.mongodb.operation.CommandReadOperation;
import com.mongodb.operation.CreateCollectionOperation;
import com.mongodb.operation.DropDatabaseOperation;
import com.mongodb.operation.OperationExecutor;
import org.bson.BsonDocument;
import org.bson.Document;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.conversions.Bson;

class MongoDatabaseImpl implements MongoDatabase {
    private final String name;
    private final ReadPreference readPreference;
    private final CodecRegistry codecRegistry;
    private final WriteConcern writeConcern;
    private final OperationExecutor executor;

    MongoDatabaseImpl(String name, CodecRegistry codecRegistry, ReadPreference readPreference, WriteConcern writeConcern, OperationExecutor executor) {
        this.name = (String)Assertions.notNull("name", name);
        this.codecRegistry = (CodecRegistry)Assertions.notNull("codecRegistry", codecRegistry);
        this.readPreference = (ReadPreference)Assertions.notNull("readPreference", readPreference);
        this.writeConcern = (WriteConcern)Assertions.notNull("writeConcern", writeConcern);
        this.executor = (OperationExecutor)Assertions.notNull("executor", executor);
    }

    public String getName() {
        return this.name;
    }

    public CodecRegistry getCodecRegistry() {
        return this.codecRegistry;
    }

    public ReadPreference getReadPreference() {
        return this.readPreference;
    }

    public WriteConcern getWriteConcern() {
        return this.writeConcern;
    }

    public MongoDatabase withCodecRegistry(CodecRegistry codecRegistry) {
        return new MongoDatabaseImpl(this.name, codecRegistry, this.readPreference, this.writeConcern, this.executor);
    }

    public MongoDatabase withReadPreference(ReadPreference readPreference) {
        return new MongoDatabaseImpl(this.name, this.codecRegistry, readPreference, this.writeConcern, this.executor);
    }

    public MongoDatabase withWriteConcern(WriteConcern writeConcern) {
        return new MongoDatabaseImpl(this.name, this.codecRegistry, this.readPreference, writeConcern, this.executor);
    }

    public MongoCollection<Document> getCollection(String collectionName) {
        return this.getCollection(collectionName, Document.class);
    }

    public <TDocument> MongoCollection<TDocument> getCollection(String collectionName, Class<TDocument> documentClass) {
        return new MongoCollectionImpl(new MongoNamespace(this.name, collectionName), documentClass, this.codecRegistry, this.readPreference, this.writeConcern, this.executor);
    }

    public Document runCommand(Bson command) {
        return (Document)this.runCommand(command, Document.class);
    }

    public Document runCommand(Bson command, ReadPreference readPreference) {
        return (Document)this.runCommand(command, readPreference, Document.class);
    }

    public <TResult> TResult runCommand(Bson command, Class<TResult> resultClass) {
        return this.runCommand(command, ReadPreference.primary(), resultClass);
    }

    public <TResult> TResult runCommand(Bson command, ReadPreference readPreference, Class<TResult> resultClass) {
        Assertions.notNull("readPreference", readPreference);
        return this.executor.execute(new CommandReadOperation(this.getName(), this.toBsonDocument(command), this.codecRegistry.get(resultClass)), readPreference);
    }

    public void drop() {
        this.executor.execute(new DropDatabaseOperation(this.name));
    }

    public MongoIterable<String> listCollectionNames() {
        return (new ListCollectionsIterableImpl(this.name, BsonDocument.class, MongoClient.getDefaultCodecRegistry(), ReadPreference.primary(), this.executor)).map(new Function() {
            public String apply(BsonDocument result) {
                return result.getString("name").getValue();
            }
        });
    }

    public ListCollectionsIterable<Document> listCollections() {
        return this.listCollections(Document.class);
    }

    public <TResult> ListCollectionsIterable<TResult> listCollections(Class<TResult> resultClass) {
        return new ListCollectionsIterableImpl(this.name, resultClass, this.codecRegistry, ReadPreference.primary(), this.executor);
    }

    public void createCollection(String collectionName) {
        this.createCollection(collectionName, new CreateCollectionOptions());
    }

    public void createCollection(String collectionName, CreateCollectionOptions createCollectionOptions) {
        this.executor.execute((new CreateCollectionOperation(this.name, collectionName)).capped(createCollectionOptions.isCapped()).sizeInBytes(createCollectionOptions.getSizeInBytes()).autoIndex(createCollectionOptions.isAutoIndex()).maxDocuments(createCollectionOptions.getMaxDocuments()).usePowerOf2Sizes(createCollectionOptions.isUsePowerOf2Sizes()).storageEngineOptions(this.toBsonDocument(createCollectionOptions.getStorageEngineOptions())));
    }

    private BsonDocument toBsonDocument(Bson document) {
        return document == null?null:document.toBsonDocument(BsonDocument.class, this.codecRegistry);
    }
}

后面只需要根据项目需求自己 实现就好。如下利用MongoDB做增删改查；

import com.ifunpay.util.function.TryToDo;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import lombok.extern.log4j.Log4j;
import org.bson.Document;

import javax.annotation.PreDestroy;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;


@Log4j
public class MongoConfig {

    static String host;
    static int port;
    static String db;

    static String user;
    static String password;

    static ExecutorService executor;
    private static boolean isLocalExecutor = false;

    public void setHost(String host) {
        MongoConfig.host = host;
    }

    public void setPort(int port) {
        MongoConfig.port = port;
    }

    public void setDb(String db) {
        MongoConfig.db = db;
    }

    public void setUser(String user) {
        MongoConfig.user = user;
    }

    public void setPassword(String password) {
        MongoConfig.password = password;
    }

    public void setExecutorService(ExecutorService executor) {
        MongoConfig.executor = executor;
    }

    //前面讲解的两个类

    /*******************************************/
    static MongoDatabase applicationMongoDb;
    static MongoClient applicationMongoClient;

    /*******************************************/

    public static MongoCollection<Document> getCollection(String name) {
        if (applicationMongoDb == null) {
            synchronized (MongoCollection.class) {
                if (applicationMongoDb == null) {
                    if (host == null || host.isEmpty() || port == 0 || db == null || db.isEmpty()) {
                        log.info("config failed");
                        return null;
                    } else {
                        List<MongoCredential> list = new ArrayList<>();
                        if (user != null && !user.isEmpty() && password != null && !password.isEmpty()) {
                            list.add(MongoCredential.createCredential(user, db, password.toCharArray()));
                        }
                        applicationMongoClient = new MongoClient(new ServerAddress(host, port), list);
                        applicationMongoDb = applicationMongoClient.getDatabase(db);
                    }
                }
            }
        }
        return applicationMongoDb.getCollection(name);
    }

    static synchronized ExecutorService initExecutorService() {
        if (executor == null) {
            synchronized (MongoConfig.class) {
                if (executor == null) {
                    executor = Executors.newFixedThreadPool(10);
                    isLocalExecutor = true;
                }
            }
        }
        return executor;
    }

    public static void execute(Runnable r) {
        initExecutorService();
        executor.execute(r);
    }


    public static <V> Future<V> submit(Callable<V> callable) {
        return initExecutorService().submit(callable);
    }


    @PreDestroy
    public void destroy() {
        shutdown();
    }


    public static void shutdown() {
        try {
            if (applicationMongoClient != null)
                applicationMongoClient.close();
        } catch (Throwable throwable) {
            log.error("", throwable);
        }
        TryToDo.toTry(() -> {
            if (isLocalExecutor) {
                log.info("try to shutdown executor");
                ExecutorService executorService = (ExecutorService) executor;
                if (!executorService.isShutdown())
                    executorService.shutdown();
            }
        }).ifFailed(e -> log.error("", e));
    }

}

 增删改查的实现类

import com.ifunpay.util.mongo.MongoConfig;
import com.mongodb.client.AggregateIterable;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import org.springframework.stereotype.Component;

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


@Component
public class MongodbDao {

    public int countResult(String collectionName, Document filter) {
        return (int) MongoConfig.getCollection(collectionName).count(filter);
    }

    public List<Document> find(String collectionName, Document filter) {
        ArrayList list = new ArrayList();
        MongoConfig.getCollection(collectionName).find(filter).iterator().forEachRemaining(list::add);
        return list;
    }

    public List<Document> find(String collectionName, Document filter, Document sort, int limit) {
        List<Document> list = new ArrayList<>();
        MongoConfig.getCollection(collectionName).find(filter).sort(sort).limit(limit).iterator().forEachRemaining(list::add);
        return list;
    }

    public static List<Document> find(String collectionName, Document filter, Document sort, int start, int size) {
        List<Document> list = new ArrayList<>();
        MongoConfig.getCollection(collectionName).find(filter).sort(sort).skip(start).limit(size).iterator().forEachRemaining(list::add);
        return list;
    }
}