Couchbase Server Create-Read-Update-Delete Java Example

Couchbase Server was originally known as Membase, is an open-source, distributed multi-model NoSQL document-oriented database software package.

If you are writing large enterprise application then Caching is really important where you want to minimized access to database and access only if in case if it's really needed.

They never have to go to disk for a query so they are faster than a typical database.
Also databases often have to do some work to join data together from multiple tables, whereas a cache usually just stores data in a key/value.
This means the cache never has to actually process anything. It just does straight lookups.



Firstly you need to install Couchase Base Server and configure buckets. After it, it will look as below.

Creating Couch base Client which access cached Documents and dealing with reading,updating, deleting contents consisting of many steps.

Following are steps, assuming you already installed and configured Couchbase with Buckets.

1. Connect Couchbase Cluster

Ex. CouchbaseEnvironment env = DefaultCouchbaseEnvironment.builder()

  .connectTimeout(10000)

  .kvTimeout(3000)

  .build();

Cluster cluster = CouchbaseCluster.create(env, "localhost");

2. Open Bucket

Ex. cluster.openBucket(USERNAME,PASSWORD);

3. Generate Unique ID for Content you are going to create
Ex. String id = UUID.randomUUID().toString();

4. Create Document which is your content based on Above ID.

Ex. JsonObject content = JsonObject.empty()

  .put("name", "Anuj Patel")

  .put("type", "Person")

  .put("email", "ABC@DEF.com")

  .put("homeTown", "Earth");

JsonDocument jsonDocument= JsonDocument.create(id, content);

5. Add created document to Couchbase Server bucket
Ex. bucket.insert(jsonDocument);

6. Retrieve Document using ID
Ex. bucket.get(id);

7. Update Document with new Content.
Ex. JsonObject content = document.content();
content.put("homeTown", "Kansas City");
try {
//upserted = bucket.upsert(doc1);
upserted = bucket.replace(document);
}
catch(DocumentDoesNotExistException e) {
e.printStackTrace();
}

Here, if you are using upsert then it will update document if ID found else it will create document with it.

8. Retrieve Document from Replica incase failed.
Ex. bucket.getFromReplica(id, ReplicaMode.FIRST);

9. Disconnect Cluster
Ex. cluster.disconnect();

also,
Using Couchbase Dashboard, you can view & query created documents.

Couchbase Server Java Example

package com.anuj.couchBase;

import java.util.List;
import java.util.UUID;
import com.couchbase.client.core.CouchbaseException;
import com.couchbase.client.java.Bucket;
import com.couchbase.client.java.Cluster;
import com.couchbase.client.java.CouchbaseCluster;
import com.couchbase.client.java.ReplicaMode;
import com.couchbase.client.java.document.JsonDocument;
import com.couchbase.client.java.document.json.JsonObject;
import com.couchbase.client.java.env.CouchbaseEnvironment;
import com.couchbase.client.java.env.DefaultCouchbaseEnvironment;
import com.couchbase.client.java.error.BucketDoesNotExistException;
import com.couchbase.client.java.error.DocumentAlreadyExistsException;
import com.couchbase.client.java.error.DocumentDoesNotExistException;

/**
 * 
 * @author Anuj
 *
 */
public class CouchbaseExample {

 private static Cluster cluster = null;
 private static Bucket bucket = null;
 private static String USERNAME="root";
 private static String PASSWORD="MYPASSWORD";
 
 public static void main(String[] args) {
  
  CouchbaseExample couchbase = new CouchbaseExample();
  
  cluster = couchbase.initCouchbaseCluster();
  
  bucket = couchbase.openBucket(cluster);
    
  //String id = "8e0c5c41-b4d5-4b25-a730-c0bab27ab3bb";
  String id = UUID.randomUUID().toString();
  System.out.println("ID - " + id);
  
  JsonDocument document = couchbase.createDocument(id);
  System.out.println("Created - " + document);
  
  document = couchbase.addDocumentToCouchBase(document);
  System.out.println("Added to Couchbase - " + document);
  
  document = couchbase.retrieveDocument(id);
  System.out.println("Retrieve from Couchbase - " + document);
  
  document = couchbase.updateDocument(document);
  System.out.println("Updated to Couchbase - " + document);
  
  document = couchbase.retrieveBucketFromReplica(id);
  System.out.println("retrieve from Couchbase Replica- " + document);
  
  /*document = couchbase.deleteDocument(id);
  System.out.println("deleted from Couchbase - " + document);*/
  
  couchbase.disconnectCouchbaseCluster();
 }

 /**
  * Initialize Couchbase Cluster
  * @return Cluster
  */
 public Cluster initCouchbaseCluster() {
  //Connect to Cluster
  CouchbaseEnvironment env = DefaultCouchbaseEnvironment.builder()
      .connectTimeout(10000)
      .kvTimeout(3000)
      .build();
  Cluster cluster = CouchbaseCluster.create(env, "localhost");
  //Cluster cluster = CouchbaseCluster.create("localhost");   
  //Cluster cluster = CouchbaseCluster.create("192.168.4.1", "192.168.4.2"); -Multi Node Cluster
  return cluster;
 }
 
 /**
  * disconnectCouchbaseCluster
  * @return boolean
  */
 public boolean disconnectCouchbaseCluster() {
  boolean isDisconnected = false;
  try {
   isDisconnected = cluster.disconnect();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return isDisconnected;
 }
 
 /**
  * Open Bucket
  * @param cluster
  * @return Bucket
  */
 public Bucket openBucket(Cluster cluster) {
  Bucket bucket = null;
  //Open Bucket
  try {
   //Bucket bucket = cluster.openBucket();
   //Bucket bucket = cluster.openBucket("default");
   //Bucket myBucket = cluster.openBucket("myBucket"); - no password
   //With Password
   bucket = cluster.openBucket(USERNAME,PASSWORD);
  }
  catch(BucketDoesNotExistException e){
   e.printStackTrace();
  }
  
  return bucket;
 }

 /**
  * Create Document
  * @return
  */
 public JsonDocument createDocument(String id) {
  JsonObject content = JsonObject.empty()
      .put("name", "Anuj Patel")
      .put("type", "Person")
      .put("email", "ABC@DEF.com")
      .put("homeTown", "Earth");
  
  JsonDocument doc1 = JsonDocument.create(id, content);
  
  return doc1;
 }
 
 /**
  * addDocumentToCouchBase 
  * @param doc1
  */
 public JsonDocument addDocumentToCouchBase(JsonDocument doc1) {
  JsonDocument document = null;
  try {
   document = bucket.insert(doc1);
   System.out.println(document);
  }
  catch(DocumentAlreadyExistsException e) {
   e.printStackTrace();
  }
  //upsert method, which will either insert the document (if the id is not found) or update the document (if the id is found)
  //JsonDocument upserted = bucket.upsert(document);
  
  return document;
 }
 
 /**
  * Retrieve Document from Bucket
  * @param id
  */
 public JsonDocument retrieveDocument(String id) {
  JsonDocument document = null;
  try {
   document = bucket.get(id);
   
  } catch (Exception e) {
   e.printStackTrace();
  }
  return document;
 }
 
 /**
  * updating record or replacing document
  * @param document
  * @return JsonDocument
  */
 public JsonDocument updateDocument(JsonDocument document) {
  JsonDocument upserted = null;
  
  JsonObject content = document.content();
  content.put("homeTown", "Kansas City");
  try {
   //upserted = bucket.upsert(doc1);
   upserted = bucket.replace(document);
   
  }
  catch(DocumentDoesNotExistException e) {
   e.printStackTrace();
  }
  
  return upserted;
 }
 
 /**
  * Remove Document
  * @param id
  * @return JsonDocument
  */
 public JsonDocument deleteDocument(String id) {
  JsonDocument document = null;
  try {
   //document = bucket.remove(doc1);
   document = bucket.remove(id);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return document;
 }
 
 /**
  * get bucket from Replica
  * @param id
  * @return JsonDocument
  */
 public JsonDocument retrieveBucketFromReplica(String id) {
  JsonDocument document = null;
  try{
      document = bucket.get(id);
  }
  catch(CouchbaseException e) {
      List<JsonDocument> list = bucket.getFromReplica(id, ReplicaMode.FIRST);
      if(!list.isEmpty()) {
          document = list.get(0);
       }
  }
  return document;
  
 }
}

Output

INFO: Opened bucket root

ID - 883f0770-eec5-4431-be7b-f4814088548c

Created - JsonDocument{id='883f0770-eec5-4431-be7b-f4814088548c', cas=0, expiry=0, content={"name":"Anuj Patel","homeTown":"Earth","type":"Person","email":"ABC@DEF.com"}, mutationToken=null}
JsonDocument{id='883f0770-eec5-4431-be7b-f4814088548c', cas=1545154531862642688, expiry=0, content={"name":"Anuj Patel","homeTown":"Earth","type":"Person","email":"ABC@DEF.com"}, mutationToken=null}

Added to Couchbase - JsonDocument{id='883f0770-eec5-4431-be7b-f4814088548c', cas=1545154531862642688, expiry=0, content={"name":"Anuj Patel","homeTown":"Earth","type":"Person","email":"ABC@DEF.com"}, mutationToken=null}

Retrieve from Couchbase - JsonDocument{id='883f0770-eec5-4431-be7b-f4814088548c', cas=1545154531862642688, expiry=0, content={"name":"Anuj Patel","homeTown":"Earth","type":"Person","email":"ABC@DEF.com"}, mutationToken=null}

Updated to Couchbase - JsonDocument{id='883f0770-eec5-4431-be7b-f4814088548c', cas=1545154531880599552, expiry=0, content={"name":"Anuj Patel","homeTown":"Kansas City","type":"Person","email":"ABC@DEF.com"}, mutationToken=null}

retrieve from Couchbase Replica- JsonDocument{id='883f0770-eec5-4431-be7b-f4814088548c', cas=1545154531880599552, expiry=0, content={"name":"Anuj Patel","homeTown":"Kansas City","type":"Person","email":"ABC@DEF.com"}, mutationToken=null}


deleted from Couchbase - JsonDocument{id='883f0770-eec5-4431-be7b-f4814088548c', cas=1545154531883614208, expiry=0, content=null, mutationToken=null}