One of the challenges of building a mobile application is how to store and manage persistent data in a way that is efficient and scalable. In this tutorial, we'll explore how to integrate MongoDB - a popular NoSQL database - into a Flutter application using the Dart programming language.
Prerequisites
Before we get started, make sure you have the following setup:
The Flutter SDK installed on your machine. You can download it here.
A MongoDB database instance running in the cloud or locally. You can create a free account on MongoDB Atlas to set up a cloud instance, or you can install MongoDB on your local machine using their official guide.
A text editor or IDE installed on your machine. We recommend using Visual Studio Code with the Dart plugin.
Setup
Create a new Flutter application using the following command:
flutter create myapp
This will create a new Flutter project in a directory called myapp. Next, open the project in your text editor or IDE.
Dependencies
Add the mongo_dart package to your pubspec.yaml file:
dependencies:
flutter:
sdk: flutter
mongo_dart: ^0.3.2
This package is an unofficial Dart driver for MongoDB that provides a simple and intuitive API for interacting with a MongoDB database.
Run flutter pub get to install the package.
Connecting to MongoDB
In order to connect to your MongoDB database, you'll need to create a new instance of the Db class provided by the mongo_dart package:
import 'package:mongo_dart/mongo_dart.dart';
void main() async {
final db = Db('mongodb://localhost:27017/mydatabase');
await db.open();
// ...
await db.close();
}
Replace mongodb://localhost:27017/mydatabase with the URI of your MongoDB instance and the name of your database.
The open() method will establish a connection to the database. The close() method should be called once you're finished working with the database to close the connection.
Collections
In MongoDB, data is stored in collections - which are similar to tables in a relational database. To insert or retrieve data from a collection, you'll need to create a new instance of the Collection class:
final collection = db.collection('books');
Replace books with the name of your collection.
CRUD operations
MongoDB supports four main types of operations: create, read, update, and delete (CRUD). Let's explore each of these in more detail.
Create
To insert a new document into the collection, you can use the insertOne() method:
final result = await collection.insertOne({
'title': 'Flutter in Action',
'author': 'Eric Windmill',
'published': DateTime.parse('2021-07-01'),
});
print(result.insertedCount); // 1
This will insert a new document into the books collection with the specified fields.
If you want to insert multiple documents at once, you can use the insertMany() method:
final result = await collection.insertMany([
{
'title': 'Dart in Action',
'author': 'Chris Buckett',
'published': DateTime.parse('2022-01-01'),
},
{
'title': 'Effective Dart',
'author': 'Kevin Moore',
'published': DateTime.parse('2021-10-01'),
},
]);
print(result.insertedCount); // 2
Read
To retrieve documents from the collection, you can use the find() method. This method returns a cursor that you can loop over to access each document:
final cursor = await collection.find();
await cursor.forEach((doc) {
print(doc);
});
This will print out all documents in the books collection.
If you want to filter documents by a specific field, you can use the findOne() method:
final doc = await collection.findOne(where.eq('title', 'Flutter in Action'));
print(doc);
This will return the document with the title 'Flutter in Action'.
Update
To update a document, you can use the updateOne() or updateMany() methods:
final result = await collection.updateOne(
where.eq('title', 'Flutter in Action'),
modify.set('published', DateTime.parse('2021-08-01')),
);
print(result.modifiedCount); // 1
This will update the published field of the document with the title 'Flutter in Action'.
Delete
To delete a document, you can use the deleteOne() or deleteMany() methods:
final result = await collection.deleteOne(where.eq('title', 'Flutter in Action'));
print(result.deletedCount); // 1
This will delete the document with the title 'Flutter in Action'.
Putting it all together
Now that we've covered the basic CRUD operations in MongoDB using mongo_dart, let's put it all together in a simple Flutter application.
Create a new file called data.dart with the following code:
import 'package:mongo_dart/mongo_dart.dart';
class Data {
static final db = Db('mongodb://localhost:27017/mydatabase');
static Collection get books => db.collection('books');
static Future<void> init() async {
await db.open();
}
static Future<void> close() async {
await db.close();
}
}
This class provides a simple and reusable API for interacting with the books collection in your MongoDB database.
Now, in your main.dart file, you can use this class to insert, retrieve, update, and delete data in your application:
import 'package:flutter/material.dart';
import 'package:myapp/data.dart';
void main() async {
await Data.init();
// Insert a new book
await Data.books.insertOne({
'title': 'Flutter in Action',
'author': 'Eric Windmill',
'published': DateTime.parse('2021-07-01'),
});
// Retrieve all books
final cursor = await Data.books.find().toList();
// Update a book
await Data.books.updateOne(
where.eq('title', 'Flutter in Action'),
modify.set('published', DateTime.parse('2021-08-01')),
);
// Delete a book
await Data.books.deleteOne(where.eq('title', 'Flutter in Action'));
await Data.close();
}
Conclusion
In this tutorial, we explored how to integrate MongoDB into a Flutter application using the mongo_dart package. We covered how to connect to a database, perform CRUD operations, and retrieve data using a simple and reusable API.
Using MongoDB in your mobile application can provide many benefits, including scalability, flexibility, and performance. With the mongo_dart package, you can easily add MongoDB support to your Flutter application and take advantage of these benefits.