From 5b9c3a9a785b2b3a101811d5b1d4b39a38b29881 Mon Sep 17 00:00:00 2001
From: Rachel Mackintosh <rachel.mackintosh@mongodb.com>
Date: Tue, 20 May 2025 10:07:53 -0400
Subject: [PATCH 1/5] first draft

---
 snooty.toml                                   |   1 +
 source/integrations.txt                       |   4 +
 .../integrations/spring-data-integration.txt  | 325 ++++++++++++++++++
 3 files changed, 330 insertions(+)
 create mode 100644 source/integrations/spring-data-integration.txt

diff --git a/snooty.toml b/snooty.toml
index 779c5740d..d841f5e34 100644
--- a/snooty.toml
+++ b/snooty.toml
@@ -19,6 +19,7 @@ toc_landing_pages = [
     "/api-documentation",
     "/security",
     "/security/auth",
+    "/integrations"
 ]
 
 sharedinclude_root = "https://raw.githubusercontent.com/10gen/docs-shared/main/"
diff --git a/source/integrations.txt b/source/integrations.txt
index af3ad44f1..a012fdcdc 100644
--- a/source/integrations.txt
+++ b/source/integrations.txt
@@ -18,6 +18,10 @@ Third-Party Integrations
    :depth: 2
    :class: singlecol
 
+.. toctree::
+
+   Tutorial: Spring Data Framework </integrations/spring-data-integration>
+
 Overview
 --------
 
diff --git a/source/integrations/spring-data-integration.txt b/source/integrations/spring-data-integration.txt
new file mode 100644
index 000000000..4a7324744
--- /dev/null
+++ b/source/integrations/spring-data-integration.txt
@@ -0,0 +1,325 @@
+.. _java-flask-celery:
+.. original URL: https://www.mongodb.com/developer/products/mongodb/python-flask-celery-newsletter/
+
+===========================================
+Tutorial: Spring Data Framework Integration
+===========================================
+
+.. contents:: On this page
+   :local:
+   :backlinks: none
+   :depth: 3
+   :class: singlecol
+
+.. facet::
+   :name: genre
+   :values: tutorial
+
+.. meta::
+   :description: Build an application using the Spring Data Framework and the MongoDB Java driver.
+   :keywords: spring, tutorial, bulk insert, code example
+
+Overview
+--------
+
+In this tutorial, you can learn how to use `Spring Data
+MongoDB <https://spring.io/projects/spring-data-mongodb>`__ with the
+{+driver-short+} to build a bulk write application. 
+
+Spring Data MongoDB
+~~~~~~~~~~~~~~~~~~~
+
+Spring Data MongoDB is a third-party Java ORM for MongoDB. The Spring Data
+project provides a familiar and consistent Spring-based programming model which
+is enhanced by MongoDB-specific features and capabilities. Spring Data MongoDB
+uses a POJO-centric model for interacting with collections and writing
+repository-style data access layers. 
+
+The Spring Data BulkOperations Interface
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+BulkOperations is an Spring Framework interface that contains a list of write
+operations that can be applied to your database. They can be any combination of
+the following {+driver-short+} operations:
+
+- ``insert``
+- ``updateOne``
+- ``updateMany``
+- ``replaceOne``
+- ``deleteOne``
+- ``deleteMany``
+- ``upsert``
+
+A BulkOperation can be ordered or unordered. Ordered operations will be applied
+sequentially and if an error is detected, will return with an error code.
+Unordered operations will be applied in parallel, which means they can be
+faster. However, you must check if there were errors during the operations. 
+
+For more information, see the `BulkOperations
+<https://www.mongodb.com/docs/manual/core/bulk-write-operations/>`__ page of the
+Spring Framework API documentation and the :manual:`Bulk Write Operations
+</core/bulk-write-operations/>` page of the MongoDB server manual. 
+
+Tutorial
+--------
+
+You can find the completed sample app for this tutorial in the
+:github:`SpringDataBulkInsert sample project
+</jorge-imperial/SpringDataMongoBulkInsert>` GitHub repository. 
+
+.. note:: Imports Not specified
+   
+   The import statements required for the classes in the tutorial have not been included. See the GitHub repository for complete files. 
+
+Prerequisites
+~~~~~~~~~~~~~
+
+Ensure you have the following components installed and set up before you start
+this tutorial:
+
+- `Java 8 or later <https://www.oracle.com/java/technologies/downloads/>`__
+- A MongoDB Atlas cluster
+  To learn how to set up a cluster, see the :ref:`Getting Started
+  <java-get-started>`__ guide for more information. 
+- `Spring Boot application setup <https://spring.io/guides/gs/spring-boot>`__ 
+- Maven for dependency management
+
+Add Dependencies
+~~~~~~~~~~~~~~~~
+
+Add the following dependencies to your ``pom.xml``:
+
+.. code-block:: xml
+
+   <dependencies>
+   <dependency>
+       <groupId>org.springframework.boot</groupId>
+       <artifactId>spring-boot-starter-data-mongodb</artifactId>
+       <version>4.4.0</version>
+   </dependency>
+
+Ensure that you are using a Spring Data version that is compatible with the
+{+driver-long+} and Java versions you are using. For compatibility specifications, see
+the `Requirements
+<https://docs.spring.io/spring-data/mongodb/reference/preface.html>`__ page
+of the Spring Data MongoDB documentation, and the :ref:`Compatibility
+<java-compatibility-tables>` page of this guide.
+
+MongoClient Configuration
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``MongodConfig`` class contains the configuration for the ``MongoClient``
+that will allow the Spring Data framework to interact with the MongoDB server
+and sets the template for data operations.
+
+This application uses ``@Configuration`` annotations for classes, ``@Bean``
+annotations for methods, and ``@Value`` annotations for parameter conversion.
+These annotations allow the Spring IoC container to manage objects. For a
+detailed explanation of these annotations, see the following sections of the
+Spring Data framework guide: 
+
+- ``@Configuration`` and ``@Bean`` annotations: `Java-based Container
+  Configuration
+  <https://docs.spring.io/spring-framework/docs/5.3.22/reference/html/core.html#beans-java>`__
+- ``@Value`` annotations: `Using @Value
+  <https://docs.spring.io/spring-framework/docs/5.3.22/reference/html/core.html#beans-value-annotations>`__ 
+
+Create configuration and template classes to set up your MongoDB connection by adding the
+following code to your application:
+
+.. code-block:: java
+
+   @Configuration
+   public class MongoConfig   {
+      @Value("${mongodb.uri}")
+      private String uri;
+
+      @Value("${mongodb.database}")
+      private String databaseName;
+
+      // Indicates whether you deployment is managed by Atlas
+      @Value("${mongodb.atlas}")
+      private boolean atlas;
+
+      // Details for accessing credentials in your JVM trust store
+      // for non-Atlas deployments
+      @Value("${truststore.path}")
+      private String trustStorePath;
+      @Value("${truststore.pwd}")
+      private String trustStorePwd;
+
+      @Bean
+      public MongoClient mongo() {
+         ConnectionString connectionString = new ConnectionString(uri);
+            MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
+               .applyConnectionString(connectionString)
+               .applyToSslSettings(builder -> {
+                  if (!atlas) {
+                     // Use SSLContext if a trustStore has been provided
+                     if (!trustStorePath.isEmpty()) {
+                        SSLFactory sslFactory = SSLFactory.builder()
+                           .withTrustMaterial(Paths.get(trustStorePath), trustStorePwd.toCharArray())
+                           .build();
+                        SSLContext sslContext = sslFactory.getSslContext();
+                        builder.context(sslContext);
+                        builder.invalidHostNameAllowed(true);
+                     }
+                  }
+                  builder.enabled(true);
+               })
+               .build();
+         return MongoClients.create(mongoClientSettings);
+      }
+
+      @Bean
+      public MongoTemplate mongoTemplate() throws Exception {
+         return new MongoTemplate(mongo(), databaseName);
+      }
+   }
+
+Ensure that your connection string (``mongodb.database``) and
+database name (``mongodb.database``) are set in your environment variables. For
+more information, see the :ref:`<java-get-started-connection-string>` section of
+this guide.
+
+For non-Atlas deployments, ensure your JVM trust store information is set in
+your environment variables. For more information, see the :ref:`Configure the
+JVM Trust Store <tls-configure-jvm-truststore>` of this guide.
+
+Object to Document Mapping
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Mapping a class to a collection allows the Spring IoC container to store objects
+as MongoDB documents. You can use the ``@Document`` annotation to specify which
+collection a class maps to. For more information about mapping objects to MongoDB
+documents, see the `Mapping Annotation Overview
+<https://docs.spring.io/spring-data/mongodb/docs/current-SNAPSHOT/reference/html/#mapping-usage-annotations>`__
+section of the Spring Data MongoDB documentation.
+
+Create your ``Product`` class and map it to your ``products`` collection by
+adding the following code to your application: 
+
+.. code-block:: java
+
+   @Document("products")
+   public class Products {
+
+       private static final Logger LOG = LoggerFactory
+          .getLogger(Products.class);
+
+       // Indicates our default index   
+       @Id
+       private String id;
+
+       private String name;
+       private int qty;
+       private double price;
+       private Date available;
+       private Date  unavailable;
+       private String skuId;
+
+       // Getters and setters
+   }
+
+You can add getters and setters for each field.
+
+Implement a Bulk Write Method
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The repository that stores your Products is implemented by two classes: an
+interface, and an interface implementation. This will allow you to create
+multiple product repositories for storing different products, while maintaining
+a basic interface.
+
+Create a generic repository interface with a bulk inserts method by adding the
+following code to your application:
+
+.. code-block:: java
+
+   public interface CustomProductsRepository {
+      void updateProductQuantity(String name, int newQty);
+      int bulkInsertProducts(int count);
+   } 
+
+Create a class that implements and customizes the repository by adding the
+following code to your application:
+
+.. code-block:: java
+
+   @Component
+   public class CustomProductsRepositoryImpl implements CustomProductsRepository {
+
+      private static final Logger LOG = LoggerFactory
+         .getLogger(CustomProductsRepository.class);
+
+      @Autowired
+      MongoTemplate mongoTemplate;
+
+      public int bulkInsertProducts(int count) {
+
+         // For testing purposes, clear any existing data in your product collection
+         LOG.info("Dropping collection...");
+         mongoTemplate.dropCollection(Products.class);
+         LOG.info("Dropped!");
+
+         Instant start = Instant.now();
+         mongoTemplate.setWriteConcern(WriteConcern.W1.withJournal(true));
+
+         Products [] productList = Products.RandomProducts(count);
+         BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Products.class);
+
+         for (int i=0; i<productList.length; ++i)
+            bulkInsertion.insert(productList[i]);
+
+         BulkWriteResult bulkWriteResult = bulkInsertion.execute();
+
+         LOG.info("Bulk insert of "+bulkWriteResult.getInsertedCount()+" documents completed in "+ Duration.between(start, Instant.now()).toMillis() + " milliseconds");
+         return bulkWriteResult.getInsertedCount();
+      }
+   }
+
+This method uses unordered bulk inserts, which can improve performance by not guaranteeing the order of operations.
+
+Perform a Bulk Operation
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Create a main application class, trigger the bulk insert on startup:
+
+.. code-block:: java
+
+   @SpringBootApplication
+   public class Application implements CommandLineRunner {
+
+       @Autowired
+       private ProductRepository productRepository;
+
+       @Override
+       public void run(String... args) throws Exception {
+           List<Product> products = Arrays.asList(
+               new Product("Product1", 10, 100.0),
+               new Product("Product2", 20, 200.0)
+           );
+           productRepository.bulkInsert(products);
+       }
+
+       public static void main(String[] args) {
+           SpringApplication.run(Application.class, args);
+       }
+   }
+
+Conclusion
+----------
+
+Implementing bulk writes in Spring Boot with MongoDB significantly improves performance by minimizing database round trips. By following the steps in this tutorial, you can efficiently manage batch data operations in your applications.
+
+More Resources
+--------------
+
+For more information about the Spring Data Framework, see the
+following resources:
+
+- `Spring Framework Documentation <https://docs.spring.io/spring-framework/reference/>`__
+- `Spring Data for MongoDB reference <https://docs.spring.io/spring-data/mongodb/reference/>`__
+- `Spring Data for MongoDB API documentation <https://docs.spring.io/spring-data/mongodb/docs/current/api/org/springframework/data/mongodb/core/package-summary.html>`__
+
+For support or to contribute to the MongoDB Community, see the `MongoDB Developer Community <https://community.mongodb.com/>`__.
\ No newline at end of file

From 62bc102c8d899148e351b2e87a5a23685844c475 Mon Sep 17 00:00:00 2001
From: Rachel Mackintosh <rachel.mackintosh@mongodb.com>
Date: Tue, 27 May 2025 11:31:58 -0400
Subject: [PATCH 2/5] edits

---
 source/integrations/spring-data-integration.txt | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/source/integrations/spring-data-integration.txt b/source/integrations/spring-data-integration.txt
index 4a7324744..0ea040681 100644
--- a/source/integrations/spring-data-integration.txt
+++ b/source/integrations/spring-data-integration.txt
@@ -38,9 +38,9 @@ repository-style data access layers.
 The Spring Data BulkOperations Interface
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-BulkOperations is an Spring Framework interface that contains a list of write
+BulkOperations is an Spring Framework Data interface that contains a list of write 
 operations that can be applied to your database. They can be any combination of
-the following {+driver-short+} operations:
+the following operations which map to similar {+driver-short+} operations:
 
 - ``insert``
 - ``updateOne``
@@ -55,10 +55,13 @@ sequentially and if an error is detected, will return with an error code.
 Unordered operations will be applied in parallel, which means they can be
 faster. However, you must check if there were errors during the operations. 
 
-For more information, see the `BulkOperations
-<https://www.mongodb.com/docs/manual/core/bulk-write-operations/>`__ page of the
-Spring Framework API documentation and the :manual:`Bulk Write Operations
-</core/bulk-write-operations/>` page of the MongoDB server manual. 
+For more information about bulk operations, see the following resources:
+
+- `BulkOperations
+  <https://docs.spring.io/spring-data/mongodb/docs/current/api/org/springframework/data/mongodb/core/BulkOperations.html>`__
+  in the Spring Framework API documentation
+- :ref:`Bulk Write Operations <java-fundamentals-bulkwrite>` in this guide 
+- :manual:`Bulk Write Operations </core/bulk-write-operations/>` in the MongoDB server manual. 
 
 Tutorial
 --------
@@ -69,7 +72,7 @@ You can find the completed sample app for this tutorial in the
 
 .. note:: Imports Not specified
    
-   The import statements required for the classes in the tutorial have not been included. See the GitHub repository for complete files. 
+   The import statements required for the classes in the tutorial have not been included. See the :github:`GitHub repository</jorge-imperial/SpringDataMongoBulkInsert>` for complete files.
 
 Prerequisites
 ~~~~~~~~~~~~~

From d857cda88137f3834c11202668132500c4c60a93 Mon Sep 17 00:00:00 2001
From: Rachel Mackintosh <rachel.mackintosh@mongodb.com>
Date: Thu, 12 Jun 2025 13:58:43 -0400
Subject: [PATCH 3/5] use includes

---
 .../main/java/CustomProductsRepository.java   |   8 +
 .../java/CustomProductsRepositoryImpl.java    |  68 +++++
 .../main/java/MongoConfig.java                |  64 +++++
 .../main/java/Products.java                   | 107 ++++++++
 .../java/SpringDataBulkInsertApplication.java |  35 +++
 .../main/resources/application.properties     |  10 +
 .../spring-data-tutorial-code/pom.xml         |  76 ++++++
 .../integrations/spring-data-integration.txt  | 232 ++++++------------
 8 files changed, 437 insertions(+), 163 deletions(-)
 create mode 100644 source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
 create mode 100644 source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java
 create mode 100644 source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
 create mode 100644 source/includes/integrations/spring-data-tutorial-code/main/java/Products.java
 create mode 100644 source/includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java
 create mode 100644 source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties
 create mode 100644 source/includes/integrations/spring-data-tutorial-code/pom.xml

diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java b/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
new file mode 100644
index 000000000..f788c267b
--- /dev/null
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
@@ -0,0 +1,8 @@
+package com.mongodb.examples.springdatabulkinsert;
+
+// start-customproductsrepo
+public interface CustomProductsRepository {
+    void updateProductQuantity(String name, int newQty)  ;
+    int bulkInsertProducts(int count);
+}
+// end-customproductsrepo
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java b/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java
new file mode 100644
index 000000000..e9d92cbf1
--- /dev/null
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java
@@ -0,0 +1,68 @@
+package com.mongodb.examples.springdatabulkinsert;
+
+import com.mongodb.WriteConcern;
+import com.mongodb.bulk.BulkWriteResult;
+import com.mongodb.client.result.UpdateResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.BulkOperations;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.time.Instant;
+
+// start-customproductsrepoimpl
+@Component
+public class CustomProductsRepositoryImpl implements CustomProductsRepository {
+
+    private static final Logger LOG = LoggerFactory
+            .getLogger(CustomProductsRepository.class);
+
+    private final MongoTemplate mongoTemplate;
+
+    @Autowired
+    public CustomProductsRepositoryImpl(MongoTemplate mongoTemplate){
+        this.mongoTemplate = mongoTemplate;
+    }
+
+
+    public void updateProductQuantity(String name, int newQuantity) {
+        Query query = new Query(Criteria.where("name").is(name));
+        Update update = new Update();
+        update.set("quantity", newQuantity);
+
+        UpdateResult result = mongoTemplate.updateFirst(query, update, Products.class);
+
+        if(result == null)
+            LOG.error("No documents updated");
+        else
+            LOG.info(result.getModifiedCount() + " document(s) updated..");
+    }
+
+    public int bulkInsertProducts(int count) {
+
+        LOG.info("Dropping collection...");
+        mongoTemplate.dropCollection(Products.class);
+        LOG.info("Dropped!");
+
+        Instant start = Instant.now();
+        mongoTemplate.setWriteConcern(WriteConcern.W1.withJournal(true));
+
+        Products [] productList = Products.RandomProducts(count);
+        BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Products.class);
+
+        for (int i=0; i<productList.length; ++i)
+            bulkInsertion.insert(productList[i]);
+
+        BulkWriteResult bulkWriteResult = bulkInsertion.execute();
+
+        LOG.info("Bulk insert of "+bulkWriteResult.getInsertedCount()+" documents completed in "+ Duration.between(start, Instant.now()).toMillis() + " milliseconds");
+        return bulkWriteResult.getInsertedCount();
+    }
+}
+// end-customproductsrepoimpl
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java b/source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
new file mode 100644
index 000000000..7e8013502
--- /dev/null
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
@@ -0,0 +1,64 @@
+package com.mongodb.examples.springdatabulkinsert;
+
+import com.mongodb.ConnectionString;
+import com.mongodb.MongoClientSettings;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.core.MongoTemplate;
+
+import javax.net.ssl.SSLContext;
+import java.nio.file.Paths;
+import nl.altindag.ssl.SSLFactory;
+
+// start-mongoconfig
+@Configuration
+public class MongoConfig   {
+    @Value("${mongodb.uri}")
+    private String uri;
+    @Value("${mongodb.database}")
+    private String databaseName;
+
+    @Value("${truststore.path}")
+    private String trustStorePath;
+    @Value("${truststore.pwd}")
+    private String trustStorePwd;
+
+    @Value("${mongodb.atlas}")
+    private boolean atlas;
+
+    @Bean
+    public MongoClient mongo() {
+
+        ConnectionString connectionString = new ConnectionString(uri);
+
+            MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
+                    .applyConnectionString(connectionString)
+                    .applyToSslSettings(builder -> {
+                        if (!atlas) {
+                            // Use SSLContext if a trustStore has been provided
+                            if (!trustStorePath.isEmpty()) {
+                                SSLFactory sslFactory = SSLFactory.builder()
+                                        .withTrustMaterial(Paths.get(trustStorePath), trustStorePwd.toCharArray())
+                                        .build();
+                                SSLContext sslContext = sslFactory.getSslContext();
+                                builder.context(sslContext);
+                                builder.invalidHostNameAllowed(true);
+                            }
+                        }
+                        builder.enabled(true);
+                    })
+                    .build();
+
+
+        return MongoClients.create(mongoClientSettings);
+    }
+
+    @Bean
+    public MongoTemplate mongoTemplate() throws Exception {
+        return new MongoTemplate(mongo(), databaseName);
+    }
+}
+// end-mongoconfig
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/Products.java b/source/includes/integrations/spring-data-tutorial-code/main/java/Products.java
new file mode 100644
index 000000000..8165c98e7
--- /dev/null
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/Products.java
@@ -0,0 +1,107 @@
+package com.mongodb.examples.springdatabulkinsert;
+
+import net.datafaker.Faker;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+import java.util.Date;
+import java.util.Random;
+
+// start-products-class
+@Document("products")
+public class Products {
+
+    private static final Logger LOG = LoggerFactory
+            .getLogger(Products.class);
+
+    @Id
+    private String id;
+    private String name;
+    private int qty;
+    private double price;
+    private Date available;
+    private Date  unavailable;
+    private String skuId;
+
+    public Products(String name, int qty, double price, Date available, Date unavailable, String skuId) {
+        this.name = name;
+        this.qty = qty;
+        this.price = price;
+        this.available = available;
+        this.unavailable = unavailable;
+        this.skuId = skuId;
+    }
+
+    public static Products [] RandomProducts( int  count) {
+
+        Faker faker = new Faker();
+        Random rand = new Random();
+
+        Products [] retProds = new Products[count];
+        for (int i=0; i<count; ++i) {
+
+            Products p = new Products(  faker.animal().name(),
+                    1+rand.nextInt(998),
+                    10.0+rand.nextInt(9999),
+                    new Date(), new Date(),
+                    faker.idNumber().valid());
+
+            retProds[i] = p;
+        }
+        return retProds;
+    }
+
+    // Getters and setters
+}
+// end-products-class
+
+//     public String getName() {
+//         return name;
+//     }
+
+//     public void setName(String name) {
+//         this.name = name;
+//     }
+
+//     public int getQty() {
+//         return qty;
+//     }
+
+//     public void setQty(int qty) {
+//         this.qty = qty;
+//     }
+
+//     public double getPrice() {
+//         return price;
+//     }
+
+//     public void setPrice(double price) {
+//         this.price = price;
+//     }
+
+//     public Date getAvailable() {
+//         return available;
+//     }
+
+//     public void setAvailable(Date available) {
+//         this.available = available;
+//     }
+
+//     public Date getUnavailable() {
+//         return unavailable;
+//     }
+
+//     public void setUnavailable(Date unavailable) {
+//         this.unavailable = unavailable;
+//     }
+
+//     public String getSkuId() {
+//         return skuId;
+//     }
+
+//     public void setSkuId(String skuId) {
+//         this.skuId = skuId;
+//     }
+// }
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java b/source/includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java
new file mode 100644
index 000000000..76016361d
--- /dev/null
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java
@@ -0,0 +1,35 @@
+package com.mongodb.examples.springdatabulkinsert;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+// start-application
+@SpringBootApplication
+public class SpringDataBulkInsertApplication implements CommandLineRunner {
+
+    @Value("${documentCount}")
+    private int count;
+    private static final Logger LOG = LoggerFactory
+            .getLogger(SpringDataBulkInsertApplication.class);
+
+    @Autowired
+    private CustomProductsRepository repository;
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringDataBulkInsertApplication.class, args);
+    }
+
+    @Override
+    public void run(String... args) throws Exception {
+
+        repository.bulkInsertProducts(count);
+        LOG.info("End run");
+        System.exit(1);
+    }
+}
+// end-application
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties b/source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties
new file mode 100644
index 000000000..3fd734d77
--- /dev/null
+++ b/source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties
@@ -0,0 +1,10 @@
+
+mongodb.database=bulk
+
+mongodb.uri=<connection string>
+mongodb.atlas=1
+
+truststore.path=/etc/ssl/truststore.jks
+truststore.pwd=P4ssw0rd
+
+documentCount=25000
diff --git a/source/includes/integrations/spring-data-tutorial-code/pom.xml b/source/includes/integrations/spring-data-tutorial-code/pom.xml
new file mode 100644
index 000000000..4b345e2ad
--- /dev/null
+++ b/source/includes/integrations/spring-data-tutorial-code/pom.xml
@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.2.5</version>
+        <relativePath/> <!-- Lookup parent from repository -->
+    </parent>
+    <groupId>com.mongodb.examples</groupId>
+    <artifactId>SpringDataBulkInsert</artifactId>
+    <name>SpringDataBulkInsert</name>
+    <description>SpringDataBulkInsert</description>
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    <dependencies>
+        <!-- Spring Boot Web Starter -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <!-- Spring Data MongoDB -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-mongodb</artifactId>
+        </dependency>
+
+        <!-- Lombok (optional, for annotations like @Getter/@Setter) -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <!-- Testing -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.junit.vintage</groupId>
+                    <artifactId>junit-vintage-engine</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>net.datafaker</groupId>
+            <artifactId>datafaker</artifactId>
+            <version>2.4.3</version>
+        </dependency>
+
+        <!-- Security (optional) -->
+        <dependency>
+            <groupId>io.github.hakky54</groupId>
+            <artifactId>sslcontext-kickstart</artifactId>
+            <version>8.3.7</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <!-- Spring Boot Maven Plugin -->
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
diff --git a/source/integrations/spring-data-integration.txt b/source/integrations/spring-data-integration.txt
index 0ea040681..0154867a2 100644
--- a/source/integrations/spring-data-integration.txt
+++ b/source/integrations/spring-data-integration.txt
@@ -1,5 +1,5 @@
-.. _java-flask-celery:
-.. original URL: https://www.mongodb.com/developer/products/mongodb/python-flask-celery-newsletter/
+.. _java-spring-data:
+.. original URL: https://www.mongodb.com/developer/languages/java/java-spring-bulk-writes/
 
 ===========================================
 Tutorial: Spring Data Framework Integration
@@ -30,10 +30,10 @@ Spring Data MongoDB
 ~~~~~~~~~~~~~~~~~~~
 
 Spring Data MongoDB is a third-party Java ORM for MongoDB. The Spring Data
-project provides a familiar and consistent Spring-based programming model which
-is enhanced by MongoDB-specific features and capabilities. Spring Data MongoDB
-uses a POJO-centric model for interacting with collections and writing
-repository-style data access layers. 
+project provides a familiar and consistent Spring-based programming model while
+enabling MongoDB-specific features and capabilities. Spring Data MongoDB uses a
+POJO-centric model for interacting with collections and writing repository-style
+data access layers.  
 
 The Spring Data BulkOperations Interface
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -61,18 +61,18 @@ For more information about bulk operations, see the following resources:
   <https://docs.spring.io/spring-data/mongodb/docs/current/api/org/springframework/data/mongodb/core/BulkOperations.html>`__
   in the Spring Framework API documentation
 - :ref:`Bulk Write Operations <java-fundamentals-bulkwrite>` in this guide 
-- :manual:`Bulk Write Operations </core/bulk-write-operations/>` in the MongoDB server manual. 
+- :manual:`Bulk Write Operations </core/bulk-write-operations/>` in the MongoDB server manual 
 
 Tutorial
 --------
 
 You can find the completed sample app for this tutorial in the
 :github:`SpringDataBulkInsert sample project
-</jorge-imperial/SpringDataMongoBulkInsert>` GitHub repository. 
+</mongodb-developer/SpringDataMongoBulkInsert>` GitHub repository. 
 
 .. note:: Imports Not specified
    
-   The import statements required for the classes in the tutorial have not been included. See the :github:`GitHub repository</jorge-imperial/SpringDataMongoBulkInsert>` for complete files.
+   The import statements required for the classes in the tutorial have not been included. See the :github:`GitHub repository</mongodb-developer/SpringDataMongoBulkInsert>` for complete files.
 
 Prerequisites
 ~~~~~~~~~~~~~
@@ -90,7 +90,14 @@ this tutorial:
 Add Dependencies
 ~~~~~~~~~~~~~~~~
 
-Add the following dependencies to your ``pom.xml``:
+Ensure that you use a Spring Data MongoDB version that is compatible with the
+{+driver-long+} and Java versions you are using. For compatibility specifications, see
+the `Requirements
+<https://docs.spring.io/spring-data/mongodb/reference/preface.html>`__ page
+of the Spring Data MongoDB documentation, and the :ref:`Compatibility
+<java-compatibility-tables>` page of this guide.
+
+Add the dependency to your ``pom.xml``:
 
 .. code-block:: xml
 
@@ -98,22 +105,17 @@ Add the following dependencies to your ``pom.xml``:
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
-       <version>4.4.0</version>
+       <version/> // Add as necessary
    </dependency>
 
-Ensure that you are using a Spring Data version that is compatible with the
-{+driver-long+} and Java versions you are using. For compatibility specifications, see
-the `Requirements
-<https://docs.spring.io/spring-data/mongodb/reference/preface.html>`__ page
-of the Spring Data MongoDB documentation, and the :ref:`Compatibility
-<java-compatibility-tables>` page of this guide.
-
 MongoClient Configuration
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The ``MongodConfig`` class contains the configuration for the ``MongoClient``
-that will allow the Spring Data framework to interact with the MongoDB server
-and sets the template for data operations.
+that will allow the Spring Data framework to interact with the MongoDB server,
+and sets other configuration options. For more information about configuration
+options, see the :ref:`Specify Connection Options <specify-mongoclient-settings>`
+page of this guide.
 
 This application uses ``@Configuration`` annotations for classes, ``@Bean``
 annotations for methods, and ``@Value`` annotations for parameter conversion.
@@ -128,67 +130,19 @@ Spring Data framework guide:
   <https://docs.spring.io/spring-framework/docs/5.3.22/reference/html/core.html#beans-value-annotations>`__ 
 
 Create configuration and template classes to set up your MongoDB connection by adding the
-following code to your application:
-
-.. code-block:: java
-
-   @Configuration
-   public class MongoConfig   {
-      @Value("${mongodb.uri}")
-      private String uri;
-
-      @Value("${mongodb.database}")
-      private String databaseName;
-
-      // Indicates whether you deployment is managed by Atlas
-      @Value("${mongodb.atlas}")
-      private boolean atlas;
-
-      // Details for accessing credentials in your JVM trust store
-      // for non-Atlas deployments
-      @Value("${truststore.path}")
-      private String trustStorePath;
-      @Value("${truststore.pwd}")
-      private String trustStorePwd;
-
-      @Bean
-      public MongoClient mongo() {
-         ConnectionString connectionString = new ConnectionString(uri);
-            MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
-               .applyConnectionString(connectionString)
-               .applyToSslSettings(builder -> {
-                  if (!atlas) {
-                     // Use SSLContext if a trustStore has been provided
-                     if (!trustStorePath.isEmpty()) {
-                        SSLFactory sslFactory = SSLFactory.builder()
-                           .withTrustMaterial(Paths.get(trustStorePath), trustStorePwd.toCharArray())
-                           .build();
-                        SSLContext sslContext = sslFactory.getSslContext();
-                        builder.context(sslContext);
-                        builder.invalidHostNameAllowed(true);
-                     }
-                  }
-                  builder.enabled(true);
-               })
-               .build();
-         return MongoClients.create(mongoClientSettings);
-      }
-
-      @Bean
-      public MongoTemplate mongoTemplate() throws Exception {
-         return new MongoTemplate(mongo(), databaseName);
-      }
-   }
+following code to a ``MongoConfig.java`` file:
+
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
+   :start-after: // start-mongoconfig
+   :end-before: // end-mongoconfig
+   :language: java
+   :dedent:
 
 Ensure that your connection string (``mongodb.database``) and
 database name (``mongodb.database``) are set in your environment variables. For
 more information, see the :ref:`<java-get-started-connection-string>` section of
 this guide.
 
-For non-Atlas deployments, ensure your JVM trust store information is set in
-your environment variables. For more information, see the :ref:`Configure the
-JVM Trust Store <tls-configure-jvm-truststore>` of this guide.
-
 Object to Document Mapping
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -199,116 +153,68 @@ documents, see the `Mapping Annotation Overview
 <https://docs.spring.io/spring-data/mongodb/docs/current-SNAPSHOT/reference/html/#mapping-usage-annotations>`__
 section of the Spring Data MongoDB documentation.
 
-Create your ``Product`` class and map it to your ``products`` collection by
-adding the following code to your application: 
-
-.. code-block:: java
-
-   @Document("products")
-   public class Products {
-
-       private static final Logger LOG = LoggerFactory
-          .getLogger(Products.class);
-
-       // Indicates our default index   
-       @Id
-       private String id;
+The ``@Id`` annotation indicates that the ``id`` field maps to the ``_id`` field
+used as a unique identifier in MongoDB documents. You can choose any field of
+any type, except arrays, to be the unique identifier. For more information, see
+the `How the _id field is handled in the mapping layer
+<https://docs.spring.io/spring-data/mongodb/reference/mongodb/mapping/mapping.html#mapping.conventions.id-field>`__
+section of the Spring Data MongoDB documentation.
 
-       private String name;
-       private int qty;
-       private double price;
-       private Date available;
-       private Date  unavailable;
-       private String skuId;
+Create your ``Products`` class and map it to your ``products`` collection by
+adding the following code to a ``Products.java`` file: 
 
-       // Getters and setters
-   }
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/Products.java
+   :start-after: // start-products-class
+   :end-before: // end-products-class
+   :language: java
+   :dedent:
 
 You can add getters and setters for each field.
 
 Implement a Bulk Write Method
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The repository that stores your Products is implemented by two classes: an
-interface, and an interface implementation. This will allow you to create
+The repository that stores your ``Products`` is implemented by two classes an
+interface, and an interface implementation. This allows you to create
 multiple product repositories for storing different products, while maintaining
-a basic interface.
+the same basic interface.
 
 Create a generic repository interface with a bulk inserts method by adding the
-following code to your application:
-
-.. code-block:: java
-
-   public interface CustomProductsRepository {
-      void updateProductQuantity(String name, int newQty);
-      int bulkInsertProducts(int count);
-   } 
-
-Create a class that implements and customizes the repository by adding the
-following code to your application:
-
-.. code-block:: java
-
-   @Component
-   public class CustomProductsRepositoryImpl implements CustomProductsRepository {
-
-      private static final Logger LOG = LoggerFactory
-         .getLogger(CustomProductsRepository.class);
+following code to a ``CustomProductsRepository.java`` file:
 
-      @Autowired
-      MongoTemplate mongoTemplate;
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
+   :start-after: // start-customproductsrepo
+   :end-before: // end-customproductsrepo
+   :language: java
+   :dedent:
 
-      public int bulkInsertProducts(int count) {
+When you implement your products repository, you will need to reference the
+client creation methods defined in the ``MongoConfig`` class, which were
+annotated with ``@Bean``. By using the ``@Autowired`` annotation with the
+``mongoTemplate`` variable, the Spring container uses field injection to .
 
-         // For testing purposes, clear any existing data in your product collection
-         LOG.info("Dropping collection...");
-         mongoTemplate.dropCollection(Products.class);
-         LOG.info("Dropped!");
+Create a class that implements and customizes the ``CustomProductsRepository``
+repository by adding the following code to a
+``CustomProductsRepositoryImpl.java`` file:
 
-         Instant start = Instant.now();
-         mongoTemplate.setWriteConcern(WriteConcern.W1.withJournal(true));
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java
+   :start-after: // start-customproductsrepoimpl
+   :end-before: // end-customproductsrepoimpl
+   :language: java
+   :dedent:
 
-         Products [] productList = Products.RandomProducts(count);
-         BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Products.class);
-
-         for (int i=0; i<productList.length; ++i)
-            bulkInsertion.insert(productList[i]);
-
-         BulkWriteResult bulkWriteResult = bulkInsertion.execute();
-
-         LOG.info("Bulk insert of "+bulkWriteResult.getInsertedCount()+" documents completed in "+ Duration.between(start, Instant.now()).toMillis() + " milliseconds");
-         return bulkWriteResult.getInsertedCount();
-      }
-   }
-
-This method uses unordered bulk inserts, which can improve performance by not guaranteeing the order of operations.
+The ``bulkInsertProducts()`` method uses unordered bulk inserts, which can improve performance by not guaranteeing the order of operations.
 
 Perform a Bulk Operation
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 Create a main application class, trigger the bulk insert on startup:
 
-.. code-block:: java
-
-   @SpringBootApplication
-   public class Application implements CommandLineRunner {
-
-       @Autowired
-       private ProductRepository productRepository;
-
-       @Override
-       public void run(String... args) throws Exception {
-           List<Product> products = Arrays.asList(
-               new Product("Product1", 10, 100.0),
-               new Product("Product2", 20, 200.0)
-           );
-           productRepository.bulkInsert(products);
-       }
-
-       public static void main(String[] args) {
-           SpringApplication.run(Application.class, args);
-       }
-   }
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java
+   :start-after: // start-application
+   :end-before: // end-application
+   :language: java
+   :dedent:
 
 Conclusion
 ----------

From f98048ec8758187ef3aaed5af3072cb2a7f8213d Mon Sep 17 00:00:00 2001
From: Rachel Mackintosh <rachel.mackintosh@mongodb.com>
Date: Fri, 13 Jun 2025 13:05:30 -0400
Subject: [PATCH 4/5] final

---
 .../main/java/CustomProductsRepository.java   |   8 -
 ...ertApplication.java => MyProjectName.java} |   8 +-
 ...sitoryImpl.java => ProductRepository.java} |  14 +-
 .../main/resources/application.properties     |   8 +-
 .../integrations/spring-data-integration.txt  | 152 +++++++++++-------
 5 files changed, 103 insertions(+), 87 deletions(-)
 delete mode 100644 source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
 rename source/includes/integrations/spring-data-tutorial-code/main/java/{SpringDataBulkInsertApplication.java => MyProjectName.java} (75%)
 rename source/includes/integrations/spring-data-tutorial-code/main/java/{CustomProductsRepositoryImpl.java => ProductRepository.java} (80%)

diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java b/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
deleted file mode 100644
index f788c267b..000000000
--- a/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package com.mongodb.examples.springdatabulkinsert;
-
-// start-customproductsrepo
-public interface CustomProductsRepository {
-    void updateProductQuantity(String name, int newQty)  ;
-    int bulkInsertProducts(int count);
-}
-// end-customproductsrepo
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java b/source/includes/integrations/spring-data-tutorial-code/main/java/MyProjectName.java
similarity index 75%
rename from source/includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java
rename to source/includes/integrations/spring-data-tutorial-code/main/java/MyProjectName.java
index 76016361d..77c26620f 100644
--- a/source/includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/MyProjectName.java
@@ -10,18 +10,18 @@
 
 // start-application
 @SpringBootApplication
-public class SpringDataBulkInsertApplication implements CommandLineRunner {
+public class MyProjectName implements CommandLineRunner {
 
     @Value("${documentCount}")
     private int count;
     private static final Logger LOG = LoggerFactory
-            .getLogger(SpringDataBulkInsertApplication.class);
+            .getLogger(MyProjectName.class);
 
     @Autowired
-    private CustomProductsRepository repository;
+    private ProductRepository repository;
 
     public static void main(String[] args) {
-        SpringApplication.run(SpringDataBulkInsertApplication.class, args);
+        SpringApplication.run(MyProjectName.class, args);
     }
 
     @Override
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java b/source/includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
similarity index 80%
rename from source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java
rename to source/includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
index e9d92cbf1..9acbea424 100644
--- a/source/includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
@@ -2,31 +2,27 @@
 
 import com.mongodb.WriteConcern;
 import com.mongodb.bulk.BulkWriteResult;
-import com.mongodb.client.result.UpdateResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.mongodb.core.BulkOperations;
 import org.springframework.data.mongodb.core.MongoTemplate;
-import org.springframework.data.mongodb.core.query.Criteria;
-import org.springframework.data.mongodb.core.query.Query;
-import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.stereotype.Component;
 
 import java.time.Duration;
 import java.time.Instant;
 
-// start-customproductsrepoimpl
+// start-productrepo
 @Component
-public class CustomProductsRepositoryImpl implements CustomProductsRepository {
+public class ProductRepository {
 
     private static final Logger LOG = LoggerFactory
-            .getLogger(CustomProductsRepository.class);
+            .getLogger(ProductRepository.class);
 
     private final MongoTemplate mongoTemplate;
 
     @Autowired
-    public CustomProductsRepositoryImpl(MongoTemplate mongoTemplate){
+    public ProductRepository(MongoTemplate mongoTemplate){
         this.mongoTemplate = mongoTemplate;
     }
 
@@ -65,4 +61,4 @@ public int bulkInsertProducts(int count) {
         return bulkWriteResult.getInsertedCount();
     }
 }
-// end-customproductsrepoimpl
+// end-productrepo
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties b/source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties
index 3fd734d77..a14d39bfe 100644
--- a/source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties
+++ b/source/includes/integrations/spring-data-tutorial-code/main/resources/application.properties
@@ -1,10 +1,6 @@
 
+# start-mongoconfig-properties
 mongodb.database=bulk
-
 mongodb.uri=<connection string>
-mongodb.atlas=1
-
-truststore.path=/etc/ssl/truststore.jks
-truststore.pwd=P4ssw0rd
-
 documentCount=25000
+# end-mongoconfig-properties
diff --git a/source/integrations/spring-data-integration.txt b/source/integrations/spring-data-integration.txt
index 0154867a2..4d69f6b7a 100644
--- a/source/integrations/spring-data-integration.txt
+++ b/source/integrations/spring-data-integration.txt
@@ -29,18 +29,31 @@ MongoDB <https://spring.io/projects/spring-data-mongodb>`__ with the
 Spring Data MongoDB
 ~~~~~~~~~~~~~~~~~~~
 
-Spring Data MongoDB is a third-party Java ORM for MongoDB. The Spring Data
-project provides a familiar and consistent Spring-based programming model while
-enabling MongoDB-specific features and capabilities. Spring Data MongoDB uses a
-POJO-centric model for interacting with collections and writing repository-style
-data access layers.  
+Spring Data MongoDB is the official Spring Data ODM for MongoDB. It allows you to
+interact with MongoDB by using plain old Java objects (POJOs) and repository
+abstraction. It supports MongoDB-specific features like dynamic queries,
+indexing, and nested document mapping while reducing boilerplate code such as
+manual ``find()`` and ``update()`` calls. 
+
+Dependency Injection
+~~~~~~~~~~~~~~~~~~~~
+
+Dependency injection (DI) is a core principle of the Spring Framework. It
+allows objects, called beans, to be created and managed by the Spring container,
+then injected into other beans that use them. This is distinct from typical
+object-oriented development where classes are responsible for initializing and
+constructing the objects they use.
+
+For more information about dependency injection, see the `Dependency
+Injection <https://docs.spring.io/spring-framework/reference/core/beans/dependencies/factory-collaborators.html>`__
+page of the Spring Framework documentation. 
 
 The Spring Data BulkOperations Interface
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 BulkOperations is an Spring Framework Data interface that contains a list of write 
-operations that can be applied to your database. They can be any combination of
-the following operations which map to similar {+driver-short+} operations:
+operations that can be applied to your database. It can handle any combination of
+the following operations which map to similar {+driver-long+} operations:
 
 - ``insert``
 - ``updateOne``
@@ -50,10 +63,10 @@ the following operations which map to similar {+driver-short+} operations:
 - ``deleteMany``
 - ``upsert``
 
-A BulkOperation can be ordered or unordered. Ordered operations will be applied
-sequentially and if an error is detected, will return with an error code.
-Unordered operations will be applied in parallel, which means they can be
-faster. However, you must check if there were errors during the operations. 
+A BulkOperation can be ordered or unordered. Ordered bulk operations run operations
+sequentially, and if an error is detected, return with an error code.
+Unordered operations are run in parallel, which means they are typically faster
+faster. However, you must manually check if there were errors during the operations. 
 
 For more information about bulk operations, see the following resources:
 
@@ -72,7 +85,7 @@ You can find the completed sample app for this tutorial in the
 
 .. note:: Imports Not specified
    
-   The import statements required for the classes in the tutorial have not been included. See the :github:`GitHub repository</mongodb-developer/SpringDataMongoBulkInsert>` for complete files.
+   The import statements required for the files in the tutorial have not been included on the page. See the :github:`GitHub repository</mongodb-developer/SpringDataMongoBulkInsert>` for complete files.
 
 Prerequisites
 ~~~~~~~~~~~~~
@@ -81,11 +94,9 @@ Ensure you have the following components installed and set up before you start
 this tutorial:
 
 - `Java 8 or later <https://www.oracle.com/java/technologies/downloads/>`__
-- A MongoDB Atlas cluster
-  To learn how to set up a cluster, see the :ref:`Getting Started
-  <java-get-started>`__ guide for more information. 
-- `Spring Boot application setup <https://spring.io/guides/gs/spring-boot>`__ 
-- Maven for dependency management
+- `Maven <https://maven.apache.org/>`__
+- A :atlas:`MongoDB Atlas cluster </getting-started?tck=docs_driver_java>`
+- A new `Spring Boot application <https://spring.io/guides/gs/spring-boot>`__ 
 
 Add Dependencies
 ~~~~~~~~~~~~~~~~
@@ -97,16 +108,26 @@ the `Requirements
 of the Spring Data MongoDB documentation, and the :ref:`Compatibility
 <java-compatibility-tables>` page of this guide.
 
-Add the dependency to your ``pom.xml``:
+.. note:: 
+   
+   If you used the `Spring Initializr <https://start.spring.io/>`__ or a clone of the :github:`Spring Boot sample project <spring-guides/gs-spring-boot>` to create your project, versioning compatibility has already been accounted for, and the ``spring-boot-starter-data-mongodb`` component will already be included in your ``pom.xml`` file.
+
+Add the dependencies to your ``pom.xml``:
 
 .. code-block:: xml
 
-   <dependencies>
    <dependency>
-       <groupId>org.springframework.boot</groupId>
-       <artifactId>spring-boot-starter-data-mongodb</artifactId>
-       <version/> // Add as necessary
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-data-mongodb</artifactId>
+      <version>3.2.5 </version>
    </dependency>
+   <dependency>
+      <groupId>net.datafaker</groupId>
+      <artifactId>datafaker</artifactId>
+      <version>2.4.3</version>
+   </dependency>
+
+The ``datafaker`` dependency is used to generate a large quantity of Product objects.
 
 MongoClient Configuration
 ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -138,13 +159,22 @@ following code to a ``MongoConfig.java`` file:
    :language: java
    :dedent:
 
-Ensure that your connection string (``mongodb.database``) and
-database name (``mongodb.database``) are set in your environment variables. For
+Set the values of your connection string (``mongodb.uri``),
+database name (``mongodb.database``), and bulk operation count (``documentCount``) in your ``application.properties`` file: 
+
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/resources/application.properties
+   :start-after: # start-mongoconfig-properties
+   :end-before: # end-mongoconfig-properties
+   :language: console
+   :dedent:
+
+This tutorial uses a database named ``bulk``, and creates 25000 documents to save. Replace the ``<connection
+string>`` placeholder with a connection string for your Atlas deployment. For
 more information, see the :ref:`<java-get-started-connection-string>` section of
-this guide.
+this guide.  
 
-Object to Document Mapping
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+Map Your Object to a Document
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Mapping a class to a collection allows the Spring IoC container to store objects
 as MongoDB documents. You can use the ``@Document`` annotation to specify which
@@ -153,8 +183,8 @@ documents, see the `Mapping Annotation Overview
 <https://docs.spring.io/spring-data/mongodb/docs/current-SNAPSHOT/reference/html/#mapping-usage-annotations>`__
 section of the Spring Data MongoDB documentation.
 
-The ``@Id`` annotation indicates that the ``id`` field maps to the ``_id`` field
-used as a unique identifier in MongoDB documents. You can choose any field of
+The ``@Id`` annotation in the following code indicates that the ``id`` field
+maps to the ``_id`` field which is used as a unique identifier in MongoDB documents. You can choose any field of
 any type, except arrays, to be the unique identifier. For more information, see
 the `How the _id field is handled in the mapping layer
 <https://docs.spring.io/spring-data/mongodb/reference/mongodb/mapping/mapping.html#mapping.conventions.id-field>`__
@@ -169,48 +199,46 @@ adding the following code to a ``Products.java`` file:
    :language: java
    :dedent:
 
-You can add getters and setters for each field.
-
-Implement a Bulk Write Method
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The repository that stores your ``Products`` is implemented by two classes an
-interface, and an interface implementation. This allows you to create
-multiple product repositories for storing different products, while maintaining
-the same basic interface.
+The ``Products`` class includes a static method that generates an array of
+``Product`` objects. You may also define getters and setters for each field.
 
-Create a generic repository interface with a bulk inserts method by adding the
-following code to a ``CustomProductsRepository.java`` file:
+Implement a Repository to Store Your Products
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepository.java
-   :start-after: // start-customproductsrepo
-   :end-before: // end-customproductsrepo
-   :language: java
-   :dedent:
-
-When you implement your products repository, you will need to reference the
+The ``ProductRepository`` will manage a collection of ``Products``. 
+When you implement your ``ProductRepository``, you must reference the
 client creation methods defined in the ``MongoConfig`` class, which were
 annotated with ``@Bean``. By using the ``@Autowired`` annotation with the
-``mongoTemplate`` variable, the Spring container uses field injection to .
-
-Create a class that implements and customizes the ``CustomProductsRepository``
-repository by adding the following code to a
-``CustomProductsRepositoryImpl.java`` file:
-
-.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/CustomProductsRepositoryImpl.java
-   :start-after: // start-customproductsrepoimpl
-   :end-before: // end-customproductsrepoimpl
+``mongoTemplate`` variable together with a constructor that includes
+``mongoTemplate`` as an argument, the Spring container uses constructor
+injection to inject a ``mongoTemplate`` dependency. For more information about
+constructor injection, see the `Constructor-based Dependency Injection
+<https://docs.spring.io/spring-framework/reference/core/beans/dependencies/factory-collaborators.html#beans-constructor-injection>`__
+section of the Spring Framework documentation. 
+
+Create the ``ProductRepository`` class that manages a collection of ``Products``
+by adding the following code to a ``ProductRepository.java`` file:
+
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
+   :start-after: // start-productrepo
+   :end-before: // end-productrepo
    :language: java
    :dedent:
 
-The ``bulkInsertProducts()`` method uses unordered bulk inserts, which can improve performance by not guaranteeing the order of operations.
+The ``bulkInsertProducts()`` method uses unordered bulk inserts, which can
+improve performance by not guaranteeing the order of operations. 
 
 Perform a Bulk Operation
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-Create a main application class, trigger the bulk insert on startup:
+The main application class triggers the ``ProductRepository`` to generate the
+specified number of ``Products`` and save them to your MongoDB database. It uses
+the ``@Autowired`` annotation to inject a ``ProductRepository``, and implements logging.
+
+Add the following code to a class of the same name as your project file, and add
+the following code:
 
-.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/SpringDataBulkInsertApplication.java
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/MyProjectName.java
    :start-after: // start-application
    :end-before: // end-application
    :language: java
@@ -219,7 +247,11 @@ Create a main application class, trigger the bulk insert on startup:
 Conclusion
 ----------
 
-Implementing bulk writes in Spring Boot with MongoDB significantly improves performance by minimizing database round trips. By following the steps in this tutorial, you can efficiently manage batch data operations in your applications.
+Spring Data MongoDB provides a high-level abstraction for working with MongoDB.
+It can simplify application architecture by supporting automatic dependency
+injection, which eliminates the need for manual client configuration and complex
+query handling. By reducing boilerplate code and supporting object-oriented data access, it can
+streamline data access and promote a clear separation of concerns.
 
 More Resources
 --------------

From 414fcf11368cc204856cb75dbdc49ac7ebf7bc52 Mon Sep 17 00:00:00 2001
From: Rachel Mackintosh <rachel.mackintosh@mongodb.com>
Date: Fri, 13 Jun 2025 13:44:29 -0400
Subject: [PATCH 5/5] refine

---
 .../main/java/MongoConfig.java                | 26 ---------
 .../main/java/{Products.java => Product.java} | 10 ++--
 .../main/java/ProductRepository.java          |  8 +--
 .../integrations/spring-data-integration.txt  | 57 ++++++++++---------
 4 files changed, 40 insertions(+), 61 deletions(-)
 rename source/includes/integrations/spring-data-tutorial-code/main/java/{Products.java => Product.java} (87%)

diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java b/source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
index 7e8013502..9075685a7 100644
--- a/source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
@@ -9,10 +9,6 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.mongodb.core.MongoTemplate;
 
-import javax.net.ssl.SSLContext;
-import java.nio.file.Paths;
-import nl.altindag.ssl.SSLFactory;
-
 // start-mongoconfig
 @Configuration
 public class MongoConfig   {
@@ -21,14 +17,6 @@ public class MongoConfig   {
     @Value("${mongodb.database}")
     private String databaseName;
 
-    @Value("${truststore.path}")
-    private String trustStorePath;
-    @Value("${truststore.pwd}")
-    private String trustStorePwd;
-
-    @Value("${mongodb.atlas}")
-    private boolean atlas;
-
     @Bean
     public MongoClient mongo() {
 
@@ -36,20 +24,6 @@ public MongoClient mongo() {
 
             MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
                     .applyConnectionString(connectionString)
-                    .applyToSslSettings(builder -> {
-                        if (!atlas) {
-                            // Use SSLContext if a trustStore has been provided
-                            if (!trustStorePath.isEmpty()) {
-                                SSLFactory sslFactory = SSLFactory.builder()
-                                        .withTrustMaterial(Paths.get(trustStorePath), trustStorePwd.toCharArray())
-                                        .build();
-                                SSLContext sslContext = sslFactory.getSslContext();
-                                builder.context(sslContext);
-                                builder.invalidHostNameAllowed(true);
-                            }
-                        }
-                        builder.enabled(true);
-                    })
                     .build();
 
 
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/Products.java b/source/includes/integrations/spring-data-tutorial-code/main/java/Product.java
similarity index 87%
rename from source/includes/integrations/spring-data-tutorial-code/main/java/Products.java
rename to source/includes/integrations/spring-data-tutorial-code/main/java/Product.java
index 8165c98e7..2460bce93 100644
--- a/source/includes/integrations/spring-data-tutorial-code/main/java/Products.java
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/Product.java
@@ -11,7 +11,7 @@
 
 // start-products-class
 @Document("products")
-public class Products {
+public class Product {
 
     private static final Logger LOG = LoggerFactory
             .getLogger(Products.class);
@@ -25,7 +25,7 @@ public class Products {
     private Date  unavailable;
     private String skuId;
 
-    public Products(String name, int qty, double price, Date available, Date unavailable, String skuId) {
+    public Product(String name, int qty, double price, Date available, Date unavailable, String skuId) {
         this.name = name;
         this.qty = qty;
         this.price = price;
@@ -34,15 +34,15 @@ public Products(String name, int qty, double price, Date available, Date unavail
         this.skuId = skuId;
     }
 
-    public static Products [] RandomProducts( int  count) {
+    public static Product [] RandomProducts( int  count) {
 
         Faker faker = new Faker();
         Random rand = new Random();
 
-        Products [] retProds = new Products[count];
+        Product [] retProds = new Product[count];
         for (int i=0; i<count; ++i) {
 
-            Products p = new Products(  faker.animal().name(),
+            Product p = new Product(  faker.animal().name(),
                     1+rand.nextInt(998),
                     10.0+rand.nextInt(9999),
                     new Date(), new Date(),
diff --git a/source/includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java b/source/includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
index 9acbea424..dab278aeb 100644
--- a/source/includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
+++ b/source/includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
@@ -32,7 +32,7 @@ public void updateProductQuantity(String name, int newQuantity) {
         Update update = new Update();
         update.set("quantity", newQuantity);
 
-        UpdateResult result = mongoTemplate.updateFirst(query, update, Products.class);
+        UpdateResult result = mongoTemplate.updateFirst(query, update, Product.class);
 
         if(result == null)
             LOG.error("No documents updated");
@@ -43,14 +43,14 @@ public void updateProductQuantity(String name, int newQuantity) {
     public int bulkInsertProducts(int count) {
 
         LOG.info("Dropping collection...");
-        mongoTemplate.dropCollection(Products.class);
+        mongoTemplate.dropCollection(Product.class);
         LOG.info("Dropped!");
 
         Instant start = Instant.now();
         mongoTemplate.setWriteConcern(WriteConcern.W1.withJournal(true));
 
-        Products [] productList = Products.RandomProducts(count);
-        BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Products.class);
+        Product [] productList = Product.RandomProducts(count);
+        BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Product.class);
 
         for (int i=0; i<productList.length; ++i)
             bulkInsertion.insert(productList[i]);
diff --git a/source/integrations/spring-data-integration.txt b/source/integrations/spring-data-integration.txt
index 4d69f6b7a..6f0ad0692 100644
--- a/source/integrations/spring-data-integration.txt
+++ b/source/integrations/spring-data-integration.txt
@@ -24,7 +24,7 @@ Overview
 
 In this tutorial, you can learn how to use `Spring Data
 MongoDB <https://spring.io/projects/spring-data-mongodb>`__ with the
-{+driver-short+} to build a bulk write application. 
+{+driver-short+} to perform high-performance bulk inserts in a Spring Boot application. 
 
 Spring Data MongoDB
 ~~~~~~~~~~~~~~~~~~~
@@ -51,7 +51,7 @@ page of the Spring Framework documentation.
 The Spring Data BulkOperations Interface
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-BulkOperations is an Spring Framework Data interface that contains a list of write 
+BulkOperations is a Spring Data MongoDB interface that contains a list of write 
 operations that can be applied to your database. It can handle any combination of
 the following operations which map to similar {+driver-long+} operations:
 
@@ -65,8 +65,8 @@ the following operations which map to similar {+driver-long+} operations:
 
 A BulkOperation can be ordered or unordered. Ordered bulk operations run operations
 sequentially, and if an error is detected, return with an error code.
-Unordered operations are run in parallel, which means they are typically faster
-faster. However, you must manually check if there were errors during the operations. 
+Unordered operations are run in parallel, which means they are typically faster.
+However, you must manually check if there were errors during the operations. 
 
 For more information about bulk operations, see the following resources:
 
@@ -83,7 +83,7 @@ You can find the completed sample app for this tutorial in the
 :github:`SpringDataBulkInsert sample project
 </mongodb-developer/SpringDataMongoBulkInsert>` GitHub repository. 
 
-.. note:: Imports Not specified
+.. note:: Imports Not Specified
    
    The import statements required for the files in the tutorial have not been included on the page. See the :github:`GitHub repository</mongodb-developer/SpringDataMongoBulkInsert>` for complete files.
 
@@ -112,7 +112,7 @@ of the Spring Data MongoDB documentation, and the :ref:`Compatibility
    
    If you used the `Spring Initializr <https://start.spring.io/>`__ or a clone of the :github:`Spring Boot sample project <spring-guides/gs-spring-boot>` to create your project, versioning compatibility has already been accounted for, and the ``spring-boot-starter-data-mongodb`` component will already be included in your ``pom.xml`` file.
 
-Add the dependencies to your ``pom.xml``:
+Add the following dependencies to your ``pom.xml``:
 
 .. code-block:: xml
 
@@ -127,12 +127,13 @@ Add the dependencies to your ``pom.xml``:
       <version>2.4.3</version>
    </dependency>
 
-The ``datafaker`` dependency is used to generate a large quantity of Product objects.
+The ``datafaker`` dependency is used to generate a large quantity of ``Product``
+objects to use in the bulk write operation.
 
-MongoClient Configuration
-~~~~~~~~~~~~~~~~~~~~~~~~~
+Configure your MongoClient
+~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The ``MongodConfig`` class contains the configuration for the ``MongoClient``
+The ``MongoConfig`` class contains the configuration for the ``MongoClient``
 that will allow the Spring Data framework to interact with the MongoDB server,
 and sets other configuration options. For more information about configuration
 options, see the :ref:`Specify Connection Options <specify-mongoclient-settings>`
@@ -150,8 +151,8 @@ Spring Data framework guide:
 - ``@Value`` annotations: `Using @Value
   <https://docs.spring.io/spring-framework/docs/5.3.22/reference/html/core.html#beans-value-annotations>`__ 
 
-Create configuration and template classes to set up your MongoDB connection by adding the
-following code to a ``MongoConfig.java`` file:
+Create a ``MongoConfig.java`` file and add the following configuration and
+template classes to set up your MongoDB connection: 
 
 .. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/MongoConfig.java
    :start-after: // start-mongoconfig
@@ -159,6 +160,12 @@ following code to a ``MongoConfig.java`` file:
    :language: java
    :dedent:
 
+.. note:: API vs Interface
+
+   This implementation uses the ``MongoTemplate`` API, rather than extending a
+   Spring Data repository interface such as ``MongoRepository``, to allow for
+   fine-grained control over bulk operations.
+
 Set the values of your connection string (``mongodb.uri``),
 database name (``mongodb.database``), and bulk operation count (``documentCount``) in your ``application.properties`` file: 
 
@@ -190,24 +197,23 @@ the `How the _id field is handled in the mapping layer
 <https://docs.spring.io/spring-data/mongodb/reference/mongodb/mapping/mapping.html#mapping.conventions.id-field>`__
 section of the Spring Data MongoDB documentation.
 
-Create your ``Products`` class and map it to your ``products`` collection by
-adding the following code to a ``Products.java`` file: 
+Create a ``Product.java`` file to define your ``Product`` class and map it to
+your ``products`` collection with the following code:   
 
-.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/Products.java
+.. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/Product.java
    :start-after: // start-products-class
    :end-before: // end-products-class
    :language: java
    :dedent:
 
-The ``Products`` class includes a static method that generates an array of
+The ``Product`` class includes a static method that generates an array of
 ``Product`` objects. You may also define getters and setters for each field.
 
-Implement a Repository to Store Your Products
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Define a Repository to Store Your Products
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The ``ProductRepository`` will manage a collection of ``Products``. 
-When you implement your ``ProductRepository``, you must reference the
-client creation methods defined in the ``MongoConfig`` class, which were
+The ``ProductRepository`` will manage a collection of ``Product`` objects. 
+Your ``ProductRepository`` references the client creation methods defined in the ``MongoConfig`` class, which you
 annotated with ``@Bean``. By using the ``@Autowired`` annotation with the
 ``mongoTemplate`` variable together with a constructor that includes
 ``mongoTemplate`` as an argument, the Spring container uses constructor
@@ -216,8 +222,8 @@ constructor injection, see the `Constructor-based Dependency Injection
 <https://docs.spring.io/spring-framework/reference/core/beans/dependencies/factory-collaborators.html#beans-constructor-injection>`__
 section of the Spring Framework documentation. 
 
-Create the ``ProductRepository`` class that manages a collection of ``Products``
-by adding the following code to a ``ProductRepository.java`` file:
+Create a ``ProductRepository.java`` file and define your ``ProductRepository``
+class to manage a collection of ``Product`` objects with the following code:
 
 .. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/ProductRepository.java
    :start-after: // start-productrepo
@@ -232,11 +238,10 @@ Perform a Bulk Operation
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 The main application class triggers the ``ProductRepository`` to generate the
-specified number of ``Products`` and save them to your MongoDB database. It uses
+specified number of ``Product`` objects and save them to your MongoDB database. It uses
 the ``@Autowired`` annotation to inject a ``ProductRepository``, and implements logging.
 
-Add the following code to a class of the same name as your project file, and add
-the following code:
+Add the following code to your main class to run your application:
 
 .. literalinclude:: /includes/integrations/spring-data-tutorial-code/main/java/MyProjectName.java
    :start-after: // start-application