MongoDB : Java program to do basic crud operation

Sample Java program to connect MongoDb and perform Crud Operations.

Copy paste, run and learn 😉

note :- Please ensure you have installed mongo dependency using jar, github or mvn


package com.premaseem.core;

import com.mongodb.*;

import java.util.Date;

 * Java + MongoDB Crud operation example
public class App {
    public static void main(String[] args) {

        try {

            /**** Connect to MongoDB ****/
            // Since 2.10.0, uses MongoClient
            MongoClient mongo = new MongoClient("localhost", 27017);

            // or, to connect to a replica set, with auto-discovery of the primary, supply a seed list of members
//            MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017),
//                    new ServerAddress("localhost", 27018),
//                    new ServerAddress("localhost", 27019)));

            /**** Get database ****/
            // if database doesn't exists, MongoDB will create it for you
            DB db = mongo.getDB("testdb");

            /**** Get collection / table from 'testdb' ****/
            // if collection doesn't exists, MongoDB will create it for you
            DBCollection table = db.getCollection("user");

            /**** Insert ****/
            // create a document to store key and value
            BasicDBObject document = new BasicDBObject();
            document.put("name", "premaseem");
            document.put("age", 30);
            document.put("createdDate", new Date());

            /**** Find and display ****/
            BasicDBObject searchQuery = new BasicDBObject();
            searchQuery.put("name", "premaseem");

            DBCursor cursor = table.find(searchQuery);

            while (cursor.hasNext()) {

            /**** Update ****/
            // search document where name="premaseem" and update it with new values
            BasicDBObject query = new BasicDBObject();
            query.put("name", "premaseem");

            BasicDBObject newDocument = new BasicDBObject();
            newDocument.put("name", "premaseem-updated");

            BasicDBObject updateObj = new BasicDBObject();
            updateObj.put("$set", newDocument);

            table.update(query, updateObj);

            /**** Find and display ****/
            BasicDBObject searchQuery2
                    = new BasicDBObject().append("name", "premaseem-updated");

            DBCursor cursor2 = table.find(searchQuery2);

            while (cursor2.hasNext()) {

            /**** Done ****/

        }  catch (MongoException e) {


Certificate : Google’s Go Lang programming

Google’s recent programming language called as Go Lang is super awesome. Here is the certificated of completion for a Google’s Go Programming Language course by Todd Mcleod


This certificate above verifies that Aseem Jain successfully completed the course Learn How To Code: Google’s Go (golang) Programming Language on Jan. 29, 2017 as taught by Todd McLeod on Udemy. The certificate indicates the entire course was completed as validated by the student.

GoLang : Type conversion VS type assertion in go

Just learned an interesting subtlety about Go. There are two ways to “cast” values. I put cast in quotes because one isn’t really casting but it’s just the general term I always use for saying “change on type to another one”.

The first one I was pretty used to, type conversion:

var x int = 5
var x64 int64 = int64(x)

The one I was unaware of is type assertion:

var x interface{} = int64(5)
var x64 int64 = x.(int64)

So what’s the difference? Well conversion should be used when you are dealing with a type, whether that be a constant or struct or whatever. Assertion is used when when you’re dealing with an interface. Say for example a method returns an interface instead of a struct, there’s still a value associated with the return but it has a generic type. You can use assertion to convert the return value to any type that implements that interface.

JavaScript : Closure Program

A closure is an inner function that has access to the outer (enclosing) function’s variables—scope chain. The closure has three scope chains: it has access to its own scope (variables defined between its curly brackets), it has access to the outer function’s variables, and it has access to the global variables.

var add = (function () {
var counter = 0;
return function () {return counter += 1;}

function myFunction(){
document.getElementById(“demo”).innerHTML = add();

Example Explained

The variable add is assigned the return value of a self-invoking function.

The self-invoking function only runs once. It sets the counter to zero (0), and returns a function expression.

This way add becomes a function. The “wonderful” part is that it can access the counter in the parent scope.

This is called a JavaScript closure. It makes it possible for a function to have “private” variables.

The counter is protected by the scope of the anonymous function, and can only be changed using the add function.

A closure is a function having access to the parent scope, even after the parent function has closed.

GoLang : Closure program

Hi Friends,

Here is a sample closure program. A closure is an inner function that has access to the outer (enclosing) function’s variables—scope chain. The closure has three scope chains: it has access to its own scope (variables defined between its curly brackets), it has access to the outer function’s variables, and it has access to the global variables.

package main

import "fmt"

func closureFunc() func() int {
       fmt.Println("init the x ")
       x := 1
       return func() int {
              return x

func normalFunc() int {
       x := 100
       return x

func main() {
       increment := closureFunc()
       num := normalFunc()
       increment1 := closureFunc()

closure helps us limit the scope of variables used by multiple functions
without closure, for two or more funcs to have access to the same variable,
that variable would need to be package scope



MongoDB : Exporting JSON with mongoexport

This will export a JSON representation of the database. Note that as a rule – particularly for backing up or moving data – MongoDB recommends the “dump and restore” approach as BSON can contain more rich data than JSON. Nevertheless, mongoexport still has its uses, sometimes a JSON representation of the data is very useful – it’s what we’ve been using so far in the application development.

Basic output to console

Need to specify the name of the database –db and the collection –collection to export. Restoring dumped data with MongoRestore Inserts only, no updates Exporting JSON with mongoexport

Basic output to console

> mongoexport –db meantest –collection tech

Send to a file

> mongoexport –db meantest –collection tech –out MEAN/api/data/tech.json

Create as array

> mongoexport –db meantest –collection tech –out MEAN/api/data/tech.json –jsonArray

Make output pretty

> mongoexport –db meantest –collection tech –out MEAN/api/data/tech.json –jsonArray –pretty