Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

Java Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:


1. Overview

In this previous article, we've seen how to retrieve BSON documents as Java objects from MongoDB.

This is a very common way to develop a REST API, as we may want to modify these objects before converting them to JSON (using Jackson for example).

However, we might not want to change anything to our documents. To save us the trouble of coding verbose Java objects mapping, we can use direct BSON to JSON document conversion.

Let's see how MongoDB BSON API works for this use case.

2. BSON Document Creation in MongoDB with Morphia

First of all, let's set up our dependencies using Morphia as described in this article.

Here is our example entity which includes various attribute types:

public class Book {
    private String isbn;

    private Publisher publisher;

    private double cost;

    private LocalDateTime publishDate;

    // Getters and setters ...

Then let's create a new BSON entity for our test and save it to MongoDB:

public class BsonToJsonIntegrationTest {
    private static final String DB_NAME = "library";
    private static Datastore datastore;

    public static void setUp() {
        Morphia morphia = new Morphia();
        datastore = morphia.createDatastore(new MongoClient(), DB_NAME);
        datastore.save(new Book()
          .setPublisher(new Publisher(new ObjectId("fffffffffffffffffffffffa"),"publisher"))
          .setPublishDate(LocalDateTime.parse("2020-01-01T18:13:32Z", DateTimeFormatter.ISO_DATE_TIME)));

3. Default BSON to JSON Document Conversion

Now let's test the default conversion which is very simple: simply call toJson method from the BSON Document class:

public void givenBsonDocument_whenUsingStandardJsonTransformation_thenJsonDateIsObjectEpochTime() {
     String json = null;
     try (MongoClient mongoClient = new MongoClient()) {
         MongoDatabase mongoDatabase = mongoClient.getDatabase(DB_NAME);
         Document bson = mongoDatabase.getCollection("Books").find().first();
         assertEquals(expectedJson, bson.toJson());

The expectedJson value is:

    "_id": "isbn",
    "className": "com.baeldung.morphia.domain.Book",
    "publisher": {
        "_id": {
            "$oid": "fffffffffffffffffffffffa"
        "name": "publisher"
    "price": 3.95,
    "publishDate": {
        "$date": 1577898812000

This seems to correspond to a standard JSON mapping.

However, we can see that the date was converted by default as an object with a $date field in epoch time format. Let's see now how we can change this date format.

4. Relaxed BSON to JSON Date Conversion

For instance, if we want a more classic ISO date representation (such as for a JavaScript client), we can pass the relaxed JSON mode to the toJson method, using JsonWriterSettings.builder:


As a result, we can see the publishDate field's “relaxed” conversion:

    "publishDate": {
        "$date": "2020-01-01T17:13:32Z"

This format seems correct, but we still have the $date field — let's see how to get rid of it using a custom converter.

5. Custom BSON to JSON Date Conversion

First, we have to implement the BSON Converter interface for type Long, as date values are expressed in milliseconds since epoch time. We're using DateTimeFormatter.ISO_INSTANT to get the expected output format:

public class JsonDateTimeConverter implements Converter<Long> {

    private static final Logger LOGGER = LoggerFactory.getLogger(JsonDateTimeConverter.class);
    static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ISO_INSTANT

    public void convert(Long value, StrictJsonWriter writer) {
        try {
            Instant instant = new Date(value).toInstant();
            String s = DATE_TIME_FORMATTER.format(instant);
        } catch (Exception e) {
            LOGGER.error(String.format("Fail to convert offset %d to JSON date", value), e);

Then, we can pass an instance of this class as a DateTime converter to the JsonWriterSettings builder:

  .dateTimeConverter(new JsonDateTimeConverter())

Finally, we get a plain JSON ISO date format:

    "publishDate": "2020-01-01T17:13:32Z"

6. Conclusion

In this article, we've seen the default behavior of BSON to JSON document conversion.

We highlighted how to customize the date format, which is a common issue, using BSON Converter.

Of course, we can proceed the same way to convert other data types: number, boolean, null value, or object id, for example.

As always, the code can be found over on GitHub.

NoSql Bottom

Build a Dashboard Using Cassandra, Astra, and Stargate

Persistence bottom

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

Java bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

Persistence footer banner
Comments are closed on this article!