java中使用MongoDB的方法

Bertha 。 2022-05-14 20:41 354阅读 0赞

首先引入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;
        }
    }