java中使用MongoDB的方法

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

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

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

1、MongoClient 类；

  1. package com.mongodb;
  3. import com.mongodb.DBObjectCodec;
  4. import com.mongodb.DBObjectCodecProvider;
  5. import com.mongodb.DBRefCodecProvider;
  6. import com.mongodb.DocumentToDBRefTransformer;
  7. import com.mongodb.Function;
  8. import com.mongodb.ListDatabasesIterableImpl;
  9. import com.mongodb.Mongo;
  10. import com.mongodb.MongoClientOptions;
  11. import com.mongodb.MongoClientURI;
  12. import com.mongodb.MongoCredential;
  13. import com.mongodb.MongoDatabaseImpl;
  14. import com.mongodb.ReadPreference;
  15. import com.mongodb.ServerAddress;
  16. import com.mongodb.MongoClientOptions.Builder;
  17. import com.mongodb.client.ListDatabasesIterable;
  18. import com.mongodb.client.MongoDatabase;
  19. import com.mongodb.client.MongoIterable;
  20. import com.mongodb.client.model.geojson.codecs.GeoJsonCodecProvider;
  21. import java.io.Closeable;
  22. import java.util.Arrays;
  23. import java.util.List;
  24. import org.bson.BsonDocument;
  25. import org.bson.Document;
  26. import org.bson.codecs.BsonValueCodecProvider;
  27. import org.bson.codecs.DocumentCodecProvider;
  28. import org.bson.codecs.ValueCodecProvider;
  29. import org.bson.codecs.configuration.CodecProvider;
  30. import org.bson.codecs.configuration.CodecRegistries;
  31. import org.bson.codecs.configuration.CodecRegistry;
  33. public class MongoClient extends Mongo implements Closeable {
  34.     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()}));
  36.     public static CodecRegistry getDefaultCodecRegistry() {
  37.         return DEFAULT_CODEC_REGISTRY;
  38.     }
  40.     public MongoClient() {
  41.         this(new ServerAddress());
  42.     }
  44.     public MongoClient(String host) {
  45.         this(new ServerAddress(host));
  46.     }
  48.     public MongoClient(String host, MongoClientOptions options) {
  49.         this(new ServerAddress(host), options);
  50.     }
  52.     public MongoClient(String host, int port) {
  53.         this(new ServerAddress(host, port));
  54.     }
  56.     public MongoClient(ServerAddress addr) {
  57.         this(addr, (new Builder()).build());
  58.     }
  60.     public MongoClient(ServerAddress addr, List<MongoCredential> credentialsList) {
  61.         this(addr, credentialsList, (new Builder()).build());
  62.     }
  64.     public MongoClient(ServerAddress addr, MongoClientOptions options) {
  65.         super(addr, options);
  66.     }
  68.     public MongoClient(ServerAddress addr, List<MongoCredential> credentialsList, MongoClientOptions options) {
  69.         super(addr, credentialsList, options);
  70.     }
  72.     public MongoClient(List<ServerAddress> seeds) {
  73.         this(seeds, (new Builder()).build());
  74.     }
  76.     public MongoClient(List<ServerAddress> seeds, List<MongoCredential> credentialsList) {
  77.         this(seeds, credentialsList, (new Builder()).build());
  78.     }
  80.     public MongoClient(List<ServerAddress> seeds, MongoClientOptions options) {
  81.         super(seeds, options);
  82.     }
  84.     public MongoClient(List<ServerAddress> seeds, List<MongoCredential> credentialsList, MongoClientOptions options) {
  85.         super(seeds, credentialsList, options);
  86.     }
  88.     public MongoClient(MongoClientURI uri) {
  89.         super(uri);
  90.     }
  92.     public MongoClientOptions getMongoClientOptions() {
  93.         return super.getMongoClientOptions();
  94.     }
  96.     public List<MongoCredential> getCredentialsList() {
  97.         return super.getCredentialsList();
  98.     }
  100.     public MongoIterable<String> listDatabaseNames() {
  101.         return (new ListDatabasesIterableImpl(BsonDocument.class, getDefaultCodecRegistry(), ReadPreference.primary(), this.createOperationExecutor())).map(new Function() {
  102.             public String apply(BsonDocument result) {
  103.                 return result.getString("name").getValue();
  104.             }
  105.         });
  106.     }
  108.     public ListDatabasesIterable<Document> listDatabases() {
  109.         return this.listDatabases(Document.class);
  110.     }
  112.     public <T> ListDatabasesIterable<T> listDatabases(Class<T> clazz) {
  113.         return new ListDatabasesIterableImpl(clazz, this.getMongoClientOptions().getCodecRegistry(), ReadPreference.primary(), this.createOperationExecutor());
  114.     }
  116.     public MongoDatabase getDatabase(String databaseName) {
  117.         MongoClientOptions clientOptions = this.getMongoClientOptions();
  118.         return new MongoDatabaseImpl(databaseName, clientOptions.getCodecRegistry(), clientOptions.getReadPreference(), clientOptions.getWriteConcern(), this.createOperationExecutor());
  119.     }
  121.     static DBObjectCodec getCommandCodec() {
  122.         return new DBObjectCodec(getDefaultCodecRegistry());
  123.     }
  124. }

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

  1. package com.mongodb.client;
  3. import com.mongodb.ReadPreference;
  4. import com.mongodb.WriteConcern;
  5. import com.mongodb.annotations.ThreadSafe;
  6. import com.mongodb.client.ListCollectionsIterable;
  7. import com.mongodb.client.MongoCollection;
  8. import com.mongodb.client.MongoIterable;
  9. import com.mongodb.client.model.CreateCollectionOptions;
  10. import org.bson.Document;
  11. import org.bson.codecs.configuration.CodecRegistry;
  12. import org.bson.conversions.Bson;
  14. @ThreadSafe
  15. public interface MongoDatabase {
  16.     String getName();
  18.     CodecRegistry getCodecRegistry();
  20.     ReadPreference getReadPreference();
  22.     WriteConcern getWriteConcern();
  24.     MongoDatabase withCodecRegistry(CodecRegistry var1);
  26.     MongoDatabase withReadPreference(ReadPreference var1);
  28.     MongoDatabase withWriteConcern(WriteConcern var1);
  30.     MongoCollection<Document> getCollection(String var1);
  32.     <TDocument> MongoCollection<TDocument> getCollection(String var1, Class<TDocument> var2);
  34.     Document runCommand(Bson var1);
  36.     Document runCommand(Bson var1, ReadPreference var2);
  38.     <TResult> TResult runCommand(Bson var1, Class<TResult> var2);
  40.     <TResult> TResult runCommand(Bson var1, ReadPreference var2, Class<TResult> var3);
  42.     void drop();
  44.     MongoIterable<String> listCollectionNames();
  46.     ListCollectionsIterable<Document> listCollections();
  48.     <TResult> ListCollectionsIterable<TResult> listCollections(Class<TResult> var1);
  50.     void createCollection(String var1);
  52.     void createCollection(String var1, CreateCollectionOptions var2);
  53. }

MongoDatabase实现类

  1. package com.mongodb;
  3. import com.mongodb.Function;
  4. import com.mongodb.ListCollectionsIterableImpl;
  5. import com.mongodb.MongoClient;
  6. import com.mongodb.MongoCollectionImpl;
  7. import com.mongodb.MongoNamespace;
  8. import com.mongodb.ReadPreference;
  9. import com.mongodb.WriteConcern;
  10. import com.mongodb.assertions.Assertions;
  11. import com.mongodb.client.ListCollectionsIterable;
  12. import com.mongodb.client.MongoCollection;
  13. import com.mongodb.client.MongoDatabase;
  14. import com.mongodb.client.MongoIterable;
  15. import com.mongodb.client.model.CreateCollectionOptions;
  16. import com.mongodb.operation.CommandReadOperation;
  17. import com.mongodb.operation.CreateCollectionOperation;
  18. import com.mongodb.operation.DropDatabaseOperation;
  19. import com.mongodb.operation.OperationExecutor;
  20. import org.bson.BsonDocument;
  21. import org.bson.Document;
  22. import org.bson.codecs.configuration.CodecRegistry;
  23. import org.bson.conversions.Bson;
  25. class MongoDatabaseImpl implements MongoDatabase {
  26.     private final String name;
  27.     private final ReadPreference readPreference;
  28.     private final CodecRegistry codecRegistry;
  29.     private final WriteConcern writeConcern;
  30.     private final OperationExecutor executor;
  32.     MongoDatabaseImpl(String name, CodecRegistry codecRegistry, ReadPreference readPreference, WriteConcern writeConcern, OperationExecutor executor) {
  33.         this.name = (String)Assertions.notNull("name", name);
  34.         this.codecRegistry = (CodecRegistry)Assertions.notNull("codecRegistry", codecRegistry);
  35.         this.readPreference = (ReadPreference)Assertions.notNull("readPreference", readPreference);
  36.         this.writeConcern = (WriteConcern)Assertions.notNull("writeConcern", writeConcern);
  37.         this.executor = (OperationExecutor)Assertions.notNull("executor", executor);
  38.     }
  40.     public String getName() {
  41.         return this.name;
  42.     }
  44.     public CodecRegistry getCodecRegistry() {
  45.         return this.codecRegistry;
  46.     }
  48.     public ReadPreference getReadPreference() {
  49.         return this.readPreference;
  50.     }
  52.     public WriteConcern getWriteConcern() {
  53.         return this.writeConcern;
  54.     }
  56.     public MongoDatabase withCodecRegistry(CodecRegistry codecRegistry) {
  57.         return new MongoDatabaseImpl(this.name, codecRegistry, this.readPreference, this.writeConcern, this.executor);
  58.     }
  60.     public MongoDatabase withReadPreference(ReadPreference readPreference) {
  61.         return new MongoDatabaseImpl(this.name, this.codecRegistry, readPreference, this.writeConcern, this.executor);
  62.     }
  64.     public MongoDatabase withWriteConcern(WriteConcern writeConcern) {
  65.         return new MongoDatabaseImpl(this.name, this.codecRegistry, this.readPreference, writeConcern, this.executor);
  66.     }
  68.     public MongoCollection<Document> getCollection(String collectionName) {
  69.         return this.getCollection(collectionName, Document.class);
  70.     }
  72.     public <TDocument> MongoCollection<TDocument> getCollection(String collectionName, Class<TDocument> documentClass) {
  73.         return new MongoCollectionImpl(new MongoNamespace(this.name, collectionName), documentClass, this.codecRegistry, this.readPreference, this.writeConcern, this.executor);
  74.     }
  76.     public Document runCommand(Bson command) {
  77.         return (Document)this.runCommand(command, Document.class);
  78.     }
  80.     public Document runCommand(Bson command, ReadPreference readPreference) {
  81.         return (Document)this.runCommand(command, readPreference, Document.class);
  82.     }
  84.     public <TResult> TResult runCommand(Bson command, Class<TResult> resultClass) {
  85.         return this.runCommand(command, ReadPreference.primary(), resultClass);
  86.     }
  88.     public <TResult> TResult runCommand(Bson command, ReadPreference readPreference, Class<TResult> resultClass) {
  89.         Assertions.notNull("readPreference", readPreference);
  90.         return this.executor.execute(new CommandReadOperation(this.getName(), this.toBsonDocument(command), this.codecRegistry.get(resultClass)), readPreference);
  91.     }
  93.     public void drop() {
  94.         this.executor.execute(new DropDatabaseOperation(this.name));
  95.     }
  97.     public MongoIterable<String> listCollectionNames() {
  98.         return (new ListCollectionsIterableImpl(this.name, BsonDocument.class, MongoClient.getDefaultCodecRegistry(), ReadPreference.primary(), this.executor)).map(new Function() {
  99.             public String apply(BsonDocument result) {
  100.                 return result.getString("name").getValue();
  101.             }
  102.         });
  103.     }
  105.     public ListCollectionsIterable<Document> listCollections() {
  106.         return this.listCollections(Document.class);
  107.     }
  109.     public <TResult> ListCollectionsIterable<TResult> listCollections(Class<TResult> resultClass) {
  110.         return new ListCollectionsIterableImpl(this.name, resultClass, this.codecRegistry, ReadPreference.primary(), this.executor);
  111.     }
  113.     public void createCollection(String collectionName) {
  114.         this.createCollection(collectionName, new CreateCollectionOptions());
  115.     }
  117.     public void createCollection(String collectionName, CreateCollectionOptions createCollectionOptions) {
  118.         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())));
  119.     }
  121.     private BsonDocument toBsonDocument(Bson document) {
  122.         return document == null?null:document.toBsonDocument(BsonDocument.class, this.codecRegistry);
  123.     }
  124. }

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

  1. import com.ifunpay.util.function.TryToDo;
  2. import com.mongodb.MongoClient;
  3. import com.mongodb.MongoCredential;
  4. import com.mongodb.ServerAddress;
  5. import com.mongodb.client.MongoCollection;
  6. import com.mongodb.client.MongoDatabase;
  7. import lombok.extern.log4j.Log4j;
  8. import org.bson.Document;
  10. import javax.annotation.PreDestroy;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.concurrent.*;
  16. @Log4j
  17. public class MongoConfig {
  19.     static String host;
  20.     static int port;
  21.     static String db;
  23.     static String user;
  24.     static String password;
  26.     static ExecutorService executor;
  27.     private static boolean isLocalExecutor = false;
  29.     public void setHost(String host) {
  30.         MongoConfig.host = host;
  31.     }
  33.     public void setPort(int port) {
  34.         MongoConfig.port = port;
  35.     }
  37.     public void setDb(String db) {
  38.         MongoConfig.db = db;
  39.     }
  41.     public void setUser(String user) {
  42.         MongoConfig.user = user;
  43.     }
  45.     public void setPassword(String password) {
  46.         MongoConfig.password = password;
  47.     }
  49.     public void setExecutorService(ExecutorService executor) {
  50.         MongoConfig.executor = executor;
  51.     }
  53.     //前面讲解的两个类
  55.     /*******************************************/
  56.     static MongoDatabase applicationMongoDb;
  57.     static MongoClient applicationMongoClient;
  59.     /*******************************************/
  61.     public static MongoCollection<Document> getCollection(String name) {
  62.         if (applicationMongoDb == null) {
  63.             synchronized (MongoCollection.class) {
  64.                 if (applicationMongoDb == null) {
  65.                     if (host == null || host.isEmpty() || port == 0 || db == null || db.isEmpty()) {
  66.                         log.info("config failed");
  67.                         return null;
  68.                     } else {
  69.                         List<MongoCredential> list = new ArrayList<>();
  70.                         if (user != null && !user.isEmpty() && password != null && !password.isEmpty()) {
  71.                             list.add(MongoCredential.createCredential(user, db, password.toCharArray()));
  72.                         }
  73.                         applicationMongoClient = new MongoClient(new ServerAddress(host, port), list);
  74.                         applicationMongoDb = applicationMongoClient.getDatabase(db);
  75.                     }
  76.                 }
  77.             }
  78.         }
  79.         return applicationMongoDb.getCollection(name);
  80.     }
  82.     static synchronized ExecutorService initExecutorService() {
  83.         if (executor == null) {
  84.             synchronized (MongoConfig.class) {
  85.                 if (executor == null) {
  86.                     executor = Executors.newFixedThreadPool(10);
  87.                     isLocalExecutor = true;
  88.                 }
  89.             }
  90.         }
  91.         return executor;
  92.     }
  94.     public static void execute(Runnable r) {
  95.         initExecutorService();
  96.         executor.execute(r);
  97.     }
  100.     public static <V> Future<V> submit(Callable<V> callable) {
  101.         return initExecutorService().submit(callable);
  102.     }
  105.     @PreDestroy
  106.     public void destroy() {
  107.         shutdown();
  108.     }
  111.     public static void shutdown() {
  112.         try {
  113.             if (applicationMongoClient != null)
  114.                 applicationMongoClient.close();
  115.         } catch (Throwable throwable) {
  116.             log.error("", throwable);
  117.         }
  118.         TryToDo.toTry(() -> {
  119.             if (isLocalExecutor) {
  120.                 log.info("try to shutdown executor");
  121.                 ExecutorService executorService = (ExecutorService) executor;
  122.                 if (!executorService.isShutdown())
  123.                     executorService.shutdown();
  124.             }
  125.         }).ifFailed(e -> log.error("", e));
  126.     }
  128. }

增删改查的实现类

  1. import com.ifunpay.util.mongo.MongoConfig;
  2. import com.mongodb.client.AggregateIterable;
  3. import com.mongodb.client.MongoCollection;
  4. import org.bson.Document;
  5. import org.springframework.stereotype.Component;
  7. import java.util.ArrayList;
  8. import java.util.List;
  11. @Component
  12. public class MongodbDao {
  14.     public int countResult(String collectionName, Document filter) {
  15.         return (int) MongoConfig.getCollection(collectionName).count(filter);
  16.     }
  18.     public List<Document> find(String collectionName, Document filter) {
  19.         ArrayList list = new ArrayList();
  20.         MongoConfig.getCollection(collectionName).find(filter).iterator().forEachRemaining(list::add);
  21.         return list;
  22.     }
  24.     public List<Document> find(String collectionName, Document filter, Document sort, int limit) {
  25.         List<Document> list = new ArrayList<>();
  26.         MongoConfig.getCollection(collectionName).find(filter).sort(sort).limit(limit).iterator().forEachRemaining(list::add);
  27.         return list;
  28.     }
  30.     public static List<Document> find(String collectionName, Document filter, Document sort, int start, int size) {
  31.         List<Document> list = new ArrayList<>();
  32.         MongoConfig.getCollection(collectionName).find(filter).sort(sort).skip(start).limit(size).iterator().forEachRemaining(list::add);
  33.         return list;
  34.     }
  35. }

发表评论

表情：
评论列表 （有 0 条评论，470人围观）

还没有评论，来说两句吧...

相关阅读