Today in this article, we will see how to perform Java- Apache Spark Connect to MongoDB with examples.

We will make use of MongoDB Spark Connector which helps connect to MongoDB and allows us to read and write data between Java and MongoDB.

Here’s a basic example demonstrating how to read data from MongoDB, perform a transformation, and then write the results back to MongoDB.

We have below MongoDB collection,

Install MongoDB Connector for Apache Spark in JAVA

You can download the connector from the official MongoDB website or use Maven/Gradle to include it as a dependency in your project.

Please install MongoDB Spark Connector using the below command.

Gradle Command

implementation 'org.mongodb.spark:mongo-spark-connector_2.12:3.0.1' // Replace with the latest version

Maven Dependency:

<dependency>
    <groupId>org.mongodb.spark</groupId>
    <artifactId>mongo-spark-connector_2.12</artifactId>
    <version>3.0.1</version>
</dependency>

Please replace the above using the latest version as supported

For more details please visit the official website: https://www.mongodb.com/products/spark-connector

Create a SparkSession Object

Create a SparkSession Object to use for read and write operations,

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.*;
import org.bson.Document;
import java.util.HashMap;
import java.util.Map;


public class SparkMongoDBTheCodeBuzz {
    public static void main(String[] args) {
        // Configure Spark
        SparkConf sparkConf = new SparkConf()
                .setAppName("MongoDB Spark Connector Example")
                .setMaster("local[*]")
                .set("spark.mongodb.input.uri", "mongodb://host/TheCodeBuzz.Orders"")
                .set("spark.mongodb.output.uri", "mongodb://host/TheCodeBuzz.Orders"");

       // Create a SparkContext
        JavaSparkContext jsc = new JavaSparkContext(sparkConf);

        // Create a SparkSession
        SparkSession spark = SparkSession.builder().config(sparkConf).getOrCreate();

We create a Spark session with the MongoDB connector configurations.

We will use the above SparkSession object to read, and write data to MongoDB, etc.

Read Data from MongoDB using Spark

You must specify the following configuration settings to read from MongoDB:

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.*;
import org.bson.Document;
import java.util.HashMap;
import java.util.Map;


public class SparkMongoDBTheCodeBuzz {
    public static void main(String[] args) {
        // Configure Spark
        SparkConf sparkConf = new SparkConf()
                .setAppName("MongoDB Spark Connector Example")
                .setMaster("local[*]")
                .set("spark.mongodb.input.uri", "mongodb://host/TheCodeBuzz.Orders"")
                .set("spark.mongodb.output.uri", "mongodb://host/TheCodeBuzz.Orders"");

      // Create a SparkContext
        JavaSparkContext jsc = new JavaSparkContext(sparkConf);

        // Create a SparkSession
        SparkSession spark = SparkSession.builder().config(sparkConf).getOrCreate();

        // Read data from MongoDB
        JavaRDD<Document> mongoRDD = MongoSpark.load(jsc);

        // Perform transformations or analyses as needed
        // For example, you can convert the RDD to a DataFrame
        Dataset<Row> mongoDF = spark.createDataFrame(mongoRDD, Document.class);

        // Show the data
        mongoDF.show();
}

Write data to MongoDB using Java Spark

To write data from MongoDB, call the write function on your SparkSession object.

You must specify the following configuration settings to read from MongoDB,

data = [
  {

    "Order": "journal2",
    "qty": 25,
    "books": [
      "white"
    ],
    "domain": [
      14
    ],
    "Link": "https://www.thecodebuzz.com/order/23456"
  },
  {

    "Order": "journal1",
    "qty": 25,
    "books": [
      "black"
    ],
    "domain": [
      15
    ],
    "Link": "https://www.thecodebuzz.com/order/2324"
  }
]

Let’s save this JSON file in any temporary location and access it

       // Assume df is a DataFrame with the data you want to write to MongoDB
        Dataset<Row> df = spark.read().json("path/to/json/file");

        // Write data to MongoDB
        MongoSpark.write(df).option("TheCodeBuzz", "Orders").mode("append").save();

        // Stop the Spark session
        spark.stop();

That’s all! Happy coding!

Does this help you fix your issue?

Do you have any better solutions or suggestions? Please sound off your comments below.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Java- Apache Spark Connect to MongoDB first appeared on TheCodeBuzz.

Today, in this article will cover Java – MongoDB Date Time query with examples.

Using Java code, we will see how to get records using a date filter like ‘greater than’ OR ‘less than’ or get the records between 2 dates.

To achieve the same, We will use the MongoDB Driver package supported in JAVA. We will install the Mongo driver and query MongoDB using supported driver classes.

 There are 2 types of Java MongoDB driver packages available.

You can use one of the following drivers for your application to work with MongoDB based on what suits your requirements.

• Java Driver – Used for synchronous Java applications.
• Reactive Streams Driver  – used for asynchronous stream processing to use the Reactive Streams API.

We will cover the below aspects in today’s article,

Getting started

Here below is a sample schema or document we shall use for the date range query,

Use MongoDB Java Client Libraries

Please install the Java MongoDB driver package to get support for the MongoClient connection class and properties.

For more details visit- https://mongodb.github.io/mongo-java-driver

Add MongoDB Import statements

Please add below IMPORT namespaces

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.conversions.Bson;

Additionally, you can add below import statements for filter and timestamp query support

import java.text.SimpleDateFormat;
import java.util.Date;
import org.bson.Document;
import com.mongodb.client.FindIterable;
import static com.mongodb.client.model.Filters.lt;

Connecting to an Atlas Cluster in Java Applications

Using the MongoClient class to define the MongoDB Connection,

MongoClient mongoClient = new MongoClient(
    new MongoClientURI(
        "mongodb://localhost:27017/"
    )
);

MongoDatabase database = mongoClient.getDatabase("Books");
MongoCollection<Document> collection = database.getCollection("Book");
FindIterable<Document> result = collection.find(filter);

Above you need to replace the “Books” database with your DB name.

Also please update the “Book” collection name with your collection name.

Here we will be using the below query to get the documents between two dates in MongoDB Collection.

Java query – Mongo Date greater than query (‘gt’)

Define the date

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date dateAdded= dateFormat.parse("2023-01-01");

Define the filter

Let’s define the date filter as below,

Document query = new Document("DateAdded", new Document("$gt", dateAdded));

Get the results

            MongoCursor<Document> cursor = collection.find(query).iterator();

            // Iterating over the results
            while (cursor.hasNext()) {
                Document document = cursor.next();
                System.out.println(document.toJson());
            }

Complete sample code,

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.conversions.Bson;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.bson.Document;


MongoClient mongoClient = new MongoClient(
    new MongoClientURI(
        "mongodb://localhost:27017/"
    )
);





SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date dateAdded= dateFormat.parse("2023-01-01");


Document query = new Document("DateAdded", new Document("$gt", dateAdded));



MongoDatabase database = mongoClient.getDatabase("Books");
MongoCollection<Document> collection = database.getCollection("Book");

MongoCursor<Document> cursor = collection.find(query).iterator();

            // Iterating over the results
            while (cursor.hasNext()) {
                Document document = cursor.next();
                System.out.println(document.toJson());
            }

Mongo Atlas UI

The above query produces the same result as indicated below using ATLAS UI,

Java example – Mongo Date less than query (‘lt’)

Let’s define JAVA Mongo Datetime less than query (‘lt’)

# define date for the query 


SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date dateAdded= dateFormat.parse("2023-01-01");


Document query = new Document("DateAdded", new Document("$lt", dateAdded));

MongoDatabase database = mongoClient.getDatabase("Books");
MongoCollection<Document> collection = database.getCollection("Book");

MongoCursor<Document> cursor = collection.find(query).iterator();

Java example – Mongo Date less than and greater than date query

# define date for the query 

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

Date startDateAdded= dateFormat.parse("2023-01-01");
Date endDateAdded= dateFormat.parse("2024-01-01");

# define filter for the query 


Document query = new Document("DateAdded", 
                new Document("$gt", startDateAdded)
                        .append("$lt", endDateAdded));

MongoDatabase database = mongoClient.getDatabase("Books");
MongoCollection<Document> collection = database.getCollection("Book");

MongoCursor<Document> cursor = collection.find(query).iterator();

For more details on queries where no date field in the schema is available, please visit this article,

• Query MongoDB using ObjectId by Date -MongoShell

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Java – MongoDB Date Time query with examples first appeared on TheCodeBuzz.

Whether you’re a novice in Java or have years of experience, you can always enhance your knowledge and skills with books. Sure, practice means the most for a coder, but theory can give you direction and help look at problems in a new light, describe fundamental concepts that you can apply in practice.

A good source of theory is books.

So in this article, you’ll find six must-read Java books that you should add to your library. They cover various topics, including Java principles, framework, data structures, providing valuable resources for all Java programmers, from novices to experts.

Today in this article, we will cover below aspects,

Why Do Books Still Matter?

Good question. The abundance of learning tools might make you think that books are a thing of the past. But reading is still your best ally because it allows you to exercise your analytical and comprehension abilities. And what better way to do that than with a piece written by an expert in your field.

That’s why books are important for progressing the never-ending learning curve of any programmer. Though you can also opt for alternative reading materials provided online like this java programming Blog from CodeGym.

Great Java Books You Should Check Out

If you look at the piece from CodeGym’s blog about Java books, the author agrees that “Head First Java” is a top choice for beginners, so let’s start this list it.

Head First Java

• Authors: Kathy Sierra & Bert Bates
• Suitable for beginners

This publication is quick and enjoyable, engaging you with a combination of riddles, great images, mysteries, and soul-searching conversations with famous Java objects.

This piece is a complete introduction to object-oriented coding and Java, despite the lighthearted presentation of this page-turner. It covers everything from the basic to expert level.

What else should you expect? A visually rich format created with your brain in mind. Instead of a text-heavy technique that drives you to sleep, you’ll understand Java through issues and challenges that will occupy your imagination.

If you’re one to collect hard copies, this title can become a great addition to your bookshelf. You’re more than likely to refer to it even after gaining some hands-on experience.

Java: A beginner’s Guide

• Author: Herbert Schildt
• Suitable for beginners

Herbert Schildt, a best-selling coding author, starts with the fundamentals, such as writing, constructing, and running a program. This book gets you up and running with keywords, grammar, and constructs that make up the backbone of the language.

Multicore programming, generic versions, lambda expressions, modules, and Swing are among the most sophisticated features covered in the book. An introduction to JShell, Java’s interactive programming tool, is given as an extra.

Most importantly, it’s presented in a clear, sharp, and straightforward manner so you don’t get your brain into trouble just reading it. The guide offers example code accompanied with an annotation that explains the programming principles demonstrated.

Head First Design Patterns

• Author: Eric Freeman and Elisabeth Robson
• Suitable for beginners

If you want to become an efficient conder, understanding and applying design patterns is essential. How do they solve various difficulties? What is the best way to use them? You can find the answers in this book.

It also includes several helpful tools, such as workouts and memorization maps, that aid in learning design patterns. This book is an excellent way to start if you want to master basic Java design patterns and object-oriented design concepts.

Thinking in Java

• Author: Bruce Eckel
• Suitable for beginners to experts

You truly know a language when you start thinking in it. And this guidebook will show you how to do that. It contains over 600 functioning Java applications in over 650 compilation files, all of which have been rewritten for the latest edition of Java.

Thinking in Java starts with an object-oriented foundation for both novices and professionals, then goes to design patterns, XML, concurrency, and other topics. Overall, this is a book that will continue to be helpful to you even after you have spent years learning and writing in Java.

Effective Java

• Author: Joshua Bloch
• Suitable for professionals

For experienced Java programmers, this is a must-read book. The writing style of the author will engage you with topics but you’ll also learn a lot about the language and its APIs.

This book can be read on vacation while traveling or at your workplace. It’s simply fantastic. There’s no question that after reading this book, you’ll be a sharper problem-solver. But it’s only suitable for the ones who already have experience in Java.

Clean Code

• Author: Robert C. Martin (aka Uncle Bob)
• Suitable for advanced coders

Even terrible code can get the job done. However, if regulation isn’t well-written, it can knock a development team to its knees. Clean code presents a good view of how code should be written to be understandable and manageable.

Clean Code is broken down into three sections. The first section discusses the principles, patterns, and techniques for writing clean code. The second section contains a series of increasingly complicated case examples. Each case study is an activity in code cleanup, in which you’ll learn how to turn a sloppy codebase into a clean and effective one.

The payout comes in the third section, a single chapter featuring a list of heuristics and “smells” obtained during the case study creation. As a result, we have a knowledge base that outlines how we think about writing, reading, and cleaning a code.

Clean Code is a hard one. Don’t skip through it; fight your way through it. It is well worth your time.

Conclusion

While practice is key to developing practical skills, reading exercises your comprehension and analytical skills. After all, where else can you learn fundamentals, get inspiration and ideas to solve problems, and tap into the experience of fellow coders?

The six titles reviewed in this article can support your journey from beginner level to senior developer. Each book adds a penny to your piggy bank of knowledge and explores a multitude of concepts helping you to become a true professional.

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post The Java Bookshelf: 6 Must-Read Guides first appeared on TheCodeBuzz.

Today in this article, we will learn how to perform Java-Bulk Submit URLs to Google Search Console. We will Java example to Bulk Submit URLs to Google Search Engine/Console for Indexing or Crawling purpose.

We already learned how to set up the service account, project, and other configurations so that we can leverage Google’s Indexing API before.

Today in this article, we will cover below aspects,

If you have not performed mandatory prerequisites, please follow the below article for more details,

• Configuration to setup multiple URLs submit to Google Search Console

You may find the need to submit the URLs due to many reasons like article update due to new data or upgrade or article enhancement, etc. In such scenarios, it is always difficult to perform indexing manually.

We shall be using below endpoints required for publishing the URLs,

Step1- Define the scope and endpoint

SCOPES = [ “https://www.googleapis.com/auth/indexing“ ]

ENDPOINT = “https://indexing.googleapis.com/v3/urlNotifications:publish“

In your Java code please define the scopes and endpoint as below,

String scopes = "https://www.googleapis.com/auth/indexing";
String endPoint = "https://indexing.googleapis.com/v3/urlNotifications:publish";

Step2 – Include the service account access token

Please include the service account access token in your code. In the last article, we generated a service account token thecodebuzz-da659b2b8b0d.json which is the private key that you use to authenticate the service account using OAuth2.

For more details :

Step3 – Define the body of the request and invoke API

Below is a sample Java code that can be used to send Bulk URLs to Indexing API

JsonFactory jsonFactory = new JacksonFactory();

// thecodebuzz-da659b2b8b0d.json is the private key that you created for your service account.
InputStream in = IOUtils.toInputStream("thecodebuzz-da659b2b8b0d.json");

GoogleCredential credentials =
  GoogleCredential.fromStream(in, this.httpTransport, jsonFactory).createScoped(Collections.singleton(scopes));

GenericUrl genericUrl = new GenericUrl(endPoint);
HttpRequestFactory requestFactory = this.httpTransport.createRequestFactory();

// Define all URLs to be submitted to API

String content = "{"
  + "\"url\": \"http://your url .com\","
  + "\"type\": \"URL_UPDATED\","
  + "}";


HttpRequest request =
  requestFactory.buildPostRequest(genericUrl, ByteArrayContent.fromString("application/json", content));

credentials.initialize(request);
HttpResponse response = request.execute();
int statusCode = response.getStatusCode();

• In the above code content is defined to contain the URL to be submitted.

• We have to define request format as “application/json”

• getStatusCode lets you verify the status code after executing the API

Once successfully submitted the URLs for indexing, you can see the status code as 200 for the request.

References :

Please follow the below article for more details on prerequisites,

• Configuration to setup multiple URLs submit to Google Search Console

• Using Python for indexing/Crawling the URL

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Java-Bulk Submit URLs to Google Search Console first appeared on TheCodeBuzz.