This blog teaches you how to create a MongoDB client object and connect to a MongoDB server using Java. You will also learn how to perform CRUD operations on a MongoDatabase object.
1. Introduction
MongoDB is a popular open-source document-oriented database that stores data in JSON-like format. It is widely used for building scalable and high-performance web applications.
Java is one of the most popular programming languages in the world, and it has a rich set of libraries and frameworks for working with MongoDB. In this tutorial, you will learn how to create a MongoDB client object and connect to a MongoDB server using Java. You will also learn how to create a MongoDatabase object and perform CRUD (create, read, update, and delete) operations on it.
By the end of this tutorial, you will be able to:
- Create a MongoClient object using different methods and parameters.
- Connect to a MongoDB server using a connection string or a MongoCredential object.
- Create a MongoDatabase object and access its properties and methods.
- Perform CRUD operations on a MongoDatabase object using various methods and filters.
- Close the connection to the MongoDB server and release the resources.
To follow this tutorial, you need to have some basic knowledge of Java and MongoDB. You also need to have MongoDB installed and running on your local machine or a remote server. You can download MongoDB from here and follow the installation instructions for your operating system.
Are you ready to start creating a MongoDB client in Java? Let’s begin!
2. Prerequisites
Before you start creating a MongoDB client in Java, you need to make sure that you have the following prerequisites:
- A Java Development Kit (JDK) version 8 or higher installed on your machine. You can download the JDK from here and follow the installation instructions for your operating system.
- An Integrated Development Environment (IDE) of your choice, such as Eclipse, IntelliJ IDEA, NetBeans, or Visual Studio Code. You can use any IDE that supports Java development and has a Maven plugin.
- A Maven project created in your IDE with the following dependencies added to the pom.xml file:
<dependencies>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-sync</artifactId>
<version>4.3.0</version>
</dependency>
</dependencies>
The mongodb-driver-sync dependency is the MongoDB Java driver that allows you to communicate with MongoDB from your Java code. You can find more information about the driver and its features on the official documentation.
Once you have these prerequisites, you are ready to create a MongoDB client object and connect to a MongoDB server.
3. Installing MongoDB Driver for Java
In this section, you will learn how to install the MongoDB driver for Java and add it to your Maven project. The MongoDB driver for Java is a library that allows you to communicate with MongoDB from your Java code. It provides various classes and methods to perform CRUD operations, query data, handle exceptions, and more.
To install the MongoDB driver for Java, you need to add the following dependency to your pom.xml file:
<dependencies>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-sync</artifactId>
<version>4.3.0</version>
</dependency>
</dependencies>
The mongodb-driver-sync dependency is the synchronous version of the MongoDB driver for Java, which means that it blocks the current thread until the operation is completed. There is also an asynchronous version of the driver, which uses callbacks or reactive streams to handle the results. You can choose the version that suits your needs and preferences.
After adding the dependency, you need to update your Maven project to download the driver and its dependencies. You can do this by right-clicking on your project in your IDE and selecting Maven > Update Project. Alternatively, you can run the following command in your terminal:
mvn clean install
This command will clean your project, install the dependencies, and build your project. You should see a message saying BUILD SUCCESS if everything goes well.
Now you have successfully installed the MongoDB driver for Java and added it to your Maven project. You are ready to create a MongoClient object and connect to a MongoDB server.
4. Creating a MongoClient Object
A MongoClient object is the main entry point to interact with MongoDB from your Java code. It represents a pool of connections to a MongoDB server or a cluster of servers. You can use a MongoClient object to create and access MongoDatabase objects, which represent specific databases on the server.
To create a MongoClient object, you need to import the following classes from the com.mongodb package:
import com.mongodb.MongoClient; import com.mongodb.MongoClientSettings; import com.mongodb.MongoCredential; import com.mongodb.ServerAddress;
The MongoClient class is the main class that provides the methods to create and manage a MongoClient object. The MongoClientSettings class is a builder class that allows you to configure various settings for the MongoClient object, such as connection timeout, read preference, write concern, and more. The MongoCredential class is a class that represents the credentials for authenticating with a MongoDB server. The ServerAddress class is a class that represents the address of a MongoDB server, which consists of a host name and a port number.
There are several ways to create a MongoClient object, depending on your needs and preferences. In this tutorial, we will cover two common methods: using a connection string and using a MongoCredential object.
5. Connecting to a MongoDB Server
After creating a MongoClient object, you can use it to connect to a MongoDB server or a cluster of servers. You can specify the address of the server or the cluster using a connection string or a list of ServerAddress objects. You can also provide authentication credentials using a MongoCredential object or a connection string.
In this section, you will learn how to connect to a MongoDB server using two methods: using a connection string and using a MongoCredential object. You will also learn how to verify the connection and handle any exceptions that may occur.
Using a Connection String
A connection string is a URI that contains the information needed to connect to a MongoDB server or a cluster of servers. It has the following format:
mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
The connection string consists of the following components:
- The mongodb scheme that identifies the protocol.
- The optional username and password for authentication, separated by a colon and followed by an at sign (@).
- The host name or IP address of the server or the cluster, followed by an optional port number, separated by a colon. If there are multiple hosts, they are separated by commas.
- The optional database name to connect to, preceded by a slash (/).
- The optional options to configure the connection, preceded by a question mark (?) and separated by ampersands (&).
For example, the following connection string connects to a MongoDB server running on localhost on port 27017, using the username admin and the password secret, and accessing the database test:
mongodb://admin:secret@localhost:27017/test
To connect to a MongoDB server using a connection string, you can use the MongoClient constructor that takes a String parameter. For example, the following code creates a MongoClient object using the connection string above:
MongoClient mongoClient = new MongoClient("mongodb://admin:secret@localhost:27017/test");
This constructor parses the connection string and creates a MongoClientSettings object that contains the configuration for the MongoClient object. You can also create a MongoClientSettings object manually and pass it to the MongoClient constructor that takes a MongoClientSettings parameter. For example, the following code creates a MongoClientSettings object using the connection string above and passes it to the MongoClient constructor:
MongoClientSettings settings = MongoClientSettings.builder()
.applyConnectionString(new ConnectionString("mongodb://admin:secret@localhost:27017/test"))
.build();
MongoClient mongoClient = new MongoClient(settings);
This method gives you more control over the settings of the MongoClient object, as you can use the MongoClientSettings.Builder class to customize various options, such as connection pool size, read preference, write concern, and more. You can find more information about the MongoClientSettings class and its methods on the official documentation.
6. Creating a MongoDatabase Object
Once you have connected to a MongoDB server using a MongoClient object, you can create a MongoDatabase object that represents a specific database on the server. A MongoDatabase object provides various methods to access and manipulate the collections and documents in the database, such as creating, dropping, listing, and renaming collections, executing commands, and creating indexes.
To create a MongoDatabase object, you need to import the following class from the com.mongodb.client package:
import com.mongodb.client.MongoDatabase;
The MongoDatabase class is the interface that defines the methods for interacting with a MongoDB database. You can obtain an instance of this class by calling the getDatabase method of the MongoClient object and passing the name of the database as a String parameter. For example, the following code creates a MongoDatabase object that represents the database test:
MongoDatabase database = mongoClient.getDatabase("test");
If the database does not exist, it will be created when you insert the first document into a collection. You can also specify the write concern and the read preference for the database using the withWriteConcern and withReadPreference methods of the MongoDatabase object. For example, the following code creates a MongoDatabase object with a majority write concern and a primary read preference:
MongoDatabase database = mongoClient.getDatabase("test")
.withWriteConcern(WriteConcern.MAJORITY)
.withReadPreference(ReadPreference.primary());
The write concern and the read preference are settings that determine how the MongoDB driver handles write and read operations. You can find more information about these settings and their possible values on the write concern documentation and the read preference documentation.
Now you have successfully created a MongoDatabase object and configured its settings. You are ready to perform CRUD operations on the database using various methods of the MongoDatabase object.
7. Performing CRUD Operations
CRUD stands for create, read, update, and delete, which are the four basic operations that you can perform on a MongoDB database. To perform CRUD operations, you need to use a MongoCollection object, which represents a collection of documents in the database. A MongoCollection object provides various methods to insert, find, update, and delete documents, as well as to perform aggregations, indexes, and transactions.
To create a MongoCollection object, you need to import the following class from the com.mongodb.client package:
import com.mongodb.client.MongoCollection;
The MongoCollection class is the interface that defines the methods for interacting with a MongoDB collection. You can obtain an instance of this class by calling the getCollection method of the MongoDatabase object and passing the name of the collection as a String parameter. You also need to specify the type of the documents in the collection using a generic parameter. For example, the following code creates a MongoCollection object that represents the collection users and contains documents of type Document:
MongoCollection collection = database.getCollection("users");
The Document class is a class that represents a BSON document, which is the data format used by MongoDB. It is a subclass of the Map interface and implements the Map<String, Object> type. You can use the Document class to create and manipulate documents in your Java code. You can also use other classes that implement the Map<String, Object> type, such as BasicDBObject or HashMap, or use your own custom classes that have the @BsonProperty annotation. You can find more information about the Document class and its methods on the official documentation.
If the collection does not exist, it will be created when you insert the first document into it. You can also specify the write concern and the read preference for the collection using the withWriteConcern and withReadPreference methods of the MongoCollection object. For example, the following code creates a MongoCollection object with a majority write concern and a primary read preference:
MongoCollection collection = database.getCollection("users")
.withWriteConcern(WriteConcern.MAJORITY)
.withReadPreference(ReadPreference.primary());
Now you have successfully created a MongoCollection object and configured its settings. You are ready to perform CRUD operations on the collection using various methods of the MongoCollection object.
8. Closing the Connection
When you are done with your MongoDB operations, you should close the connection to the MongoDB server and release the resources used by the MongoClient object. This will prevent memory leaks and improve the performance of your application.
To close the connection, you can use the close method of the MongoClient object. This method will close all the connections in the pool and terminate the background threads that monitor the connections. For example, the following code closes the connection to the MongoDB server:
mongoClient.close();
You should always call the close method in a finally block or use a try-with-resources statement to ensure that the connection is closed even if an exception occurs. For example, the following code uses a try-with-resources statement to create and close a MongoClient object:
try (MongoClient mongoClient = new MongoClient("mongodb://localhost:27017")) {
// perform MongoDB operations
} catch (Exception e) {
// handle exception
}
This statement will automatically call the close method at the end of the try block or when an exception is thrown.
Now you have successfully closed the connection to the MongoDB server and released the resources used by the MongoClient object. You have completed this tutorial and learned how to create a MongoDB client in Java and perform CRUD operations on a MongoDB database.
9. Conclusion
In this tutorial, you have learned how to create a MongoDB client in Java and perform CRUD operations on a MongoDB database. You have covered the following topics:
- How to install the MongoDB driver for Java and add it to your Maven project.
- How to create a MongoClient object using different methods and parameters.
- How to connect to a MongoDB server using a connection string or a MongoCredential object.
- How to create a MongoDatabase object and access its properties and methods.
- How to create a MongoCollection object and perform CRUD operations on it using various methods and filters.
- How to close the connection to the MongoDB server and release the resources used by the MongoClient object.
By following this tutorial, you have gained a basic understanding of how to use the MongoDB driver for Java and interact with a MongoDB database from your Java code. You can use the skills and knowledge you have acquired to build scalable and high-performance web applications using MongoDB and Java.
If you want to learn more about the MongoDB driver for Java and its features, you can visit the official documentation and the MongoDB Java driver reference. You can also find more tutorials and examples on the MongoDB developer hub.
Thank you for reading this tutorial and happy coding!
