go-java | Go runtime implementation in Java

Is it possible to use mongodb with Apache Camel asynchronously?

Indeed, this is what Apache Camel will be doing under the cover, otherwise, you will find yourself with an application blocking without proceeding with any valuable processing.

Since you have referred to the Channel Adapter (EIP) in your post, I would assume you are trying to implement a MongoDB consumer.

To consume data from a MongoDB database, Apache Camel offers two consumer strategies:

• Tailable Consumer: This strategy is about having a Thead continuously calling for next result on a MongoCursor. This strategy is feasible thanks to MongoDb Tailable Cursor feature which simply allows to have a query cursor open even after exhausting (iterating) results which removes the need to continuously have the former Thread executing the fetch query again and again
• Change Stream Consumer: This strategy on the other hand relies on the MongoDB Changes watch feature with which a client can receive (after subscription) changes for a particular collection. Same as for the Tailable consumer, there will be a Thread running endlessly (unless stopped) listening to changes on the MongoCollection of interest

As you can see, in both strategies, there is no need to perform direct queries for changes processing, unless for initial bootstrapping and resumption, neither using the synchronous Java Driver nor the Reactive Streams Driver.

This error message...

You're specifying your database as the authentication database. According to the Connection String URI Format page in the MongoDB reference the URI format is:

In your maven configuration, you are importing MongoDB. So, it will compile and you will be able to use it when you will develop.

But, when you will compile, it will not be included in final jar. And such as MongoDB isn't in spigot, it will create your error (don't find MongoDB class).

To fix it, there is multiple tutorial 1, 2, 3, 4 ... and I'm sure we can find more.

I suggest you to import mongo db like that :

Adding the annotation @EnableMongoRepositories({"path.to.repos"}) above my main class as well as the following pom dependencies:

The easiest route is probably to use org.springframework.jdbc.datasource.SimpleDriverDataSource and liquibase.ext.mongodb.database.MongoClientDriver.

The MongoClientDriver is part of the liquibase-mongodb extension and adapts a MongoClient to the java.sql.Driver interface as Liquibase needs it.

That should allow you to create the SimpleDriverDataSource and pass it to liquibase like:

The reason init and wait log statements have timestamps is that the Argo executable's logger writes timestamps by default.

The --timestamps option does not cause the containers themselves to log timestamps. It just decorates each log line with a timestamp (kubectl has a similar option).

As far as I know, there's no way to declaratively cause code running in the main container to log timestamps. You'd have to modify the code itself to use a logger which inserts timestamps.

The class you specified oracle.jdbc.driver.OracleDriver.

Does not implement the javax.sql.DataSource interface that is required for this org.eclipse.jetty.plus.jndi.Resource.

You have many class options, depending on your version of Oracle server installed, your version of oracle jdbc jar file, and if you have other requirements (like transactions, pooling, etc.).

Just pick the correct class for the line (that's what's wrong with your current setup)

I'm the morphia dev so there's some bias here but i'll try to be fair. when i first started building the pojo support in to the driver (i used to work for mongodb) my goal was to build as close to an ODM as possible in the driver so that morphia, such as it was, would only need to be a thin veneer on the driver. Some of my plans never came to fruition as I left the company mid-effort. That said, it came pretty close.

I know of several projects that are happily using the pojo codecs. If they fit your needs, then I would suggest to just go with that. For my own perspective, I think morphia offers a fair bit that the driver doesn't (to my knowledge.) Morphia supports annotation driven index and document validation definitions, and collection caps, e.g. It's a bit more powerful and forgiving in mapping. e.g., morphia can map non-String keyed Maps as fields and I don't think the driver supports. Morphia supports lifecycle events but the driver does not and last I checked it seemed like Morphia's generics support had a slight edge. (Granted that edge is probably an extreme edge case that most won't run in to. It's been a while so the details are fuzzy.)

There are a few other features that Morphia has that the driver doesn't (transparent reference support, e.g.) and some features I have planned that the driver will never support (build-time generated codecs to eliminate most/all reflection at runtime, e.g.).

So do we still need Morphia? It depends on what you want to do. I plan on working on Morphia until no one needs it, though. :)