Tutorial: Integración con el framework Spring Data

Datos de primavera MongoDB

Spring Data MongoDB es el mapeador de documentos de objetos (ODM) oficial de Spring Data para MongoDB. Permite interactuar con MongoDB mediante objetos Java (POJO) y abstracción de repositorios. Admite funciones específicas de MongoDB, como consultas dinámicas, indexación y mapeo de documentos anidados, a la vez que reduce el código repetitivo, como el manual. find() y update() llamadas.

Bota de primavera

Spring Boot es un framework desarrollado sobre Spring Framework. Incorpora autoconfiguración, valores predeterminados y funciones listas para producción para simplificar la creación de aplicaciones Java basadas en Spring, incluyendo la integración con Spring Data MongoDB. Para más información, consulte la documentación de Spring Boot.

Inyección de dependencias

La inyección de dependencias (ID) es un principio fundamental de Spring Framework. Permite que el contenedor Spring cree y gestione objetos, llamados beans, y luego los inyecte en otros beans que los utilizan. Esto se distingue del desarrollo orientado a objetos típico, donde las clases se encargan de inicializar y construir los objetos que utilizan.

Para obtener más información sobre la inyección de dependencias, consulte la página Inyección de dependencias de la documentación de Spring Framework.

Spring Data BulkOperations Interface

BulkOperations Es una interfaz de Spring Data MongoDB que contiene una lista de operaciones de escritura aplicables a la base de datos. Puede gestionar cualquier combinación de las siguientes operaciones, que se asignan a operaciones similares del controlador Java de MongoDB:

• insert

• updateOne

• updateMany

• replaceOne

• deleteOne

• deleteMany

• upsert

Un BulkOperation puede ser ordenado o desordenado. Las operaciones masivas ordenadas se ejecutan secuencialmente y, si se detecta un error, devuelven un código de error. Las operaciones desordenadas se ejecutan en paralelo, lo que significa que suelen ser más rápidas. Sin embargo, debe comprobar manualmente si se produjeron errores durante las operaciones.

Para obtener más información sobre operaciones masivas, consulte los siguientes recursos:

• BulkOperations en la documentación de la API de Spring Framework

• Operaciones de escritura masiva en esta guía

• Operaciones de escritura masiva en el manual del servidor MongoDB

Requisitos previos

Asegúrese de tener los siguientes componentes instalados y configurados antes de comenzar este tutorial:

• Java 8 o versiones posteriores

• Maven

• Un clúster MongoDB Atlas

• Una nueva aplicación Spring Boot

Agregar dependencias

Asegúrese de utilizar una versión de Spring Data MongoDB compatible con el controlador Java de MongoDB y las versiones de Java que esté utilizando. Para consultar las especificaciones de compatibilidad, consulte la página de Requisitos de la documentación de Spring Data MongoDB y la página de Compatibilidad de esta guía.

Se debe añadir las siguientes dependencias al archivo pom.xml:

<dependency>
   <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>

La dependencia datafaker se utiliza para generar una gran cantidad de objetos Product para usar en la operación de escritura masiva.

Configura tu MongoClient

La MongoConfig clase contiene la configuración del MongoClient objeto que permitirá que Spring Data Framework interactúe con MongoDB Server y define otras opciones de configuración. Para obtener más información sobre las opciones de configuración, consulte la página "Especificar opciones de conexión" de esta guía.

Esta aplicación utiliza anotaciones @Configuration para clases, @Bean para métodos y @Value para la conversión de parámetros. Estas anotaciones permiten que el contenedor de Inversión de Control (IoC) de Spring gestione objetos. Para obtener una explicación detallada de estas anotaciones, consulte las siguientes secciones de la guía de Spring Data Framework:

• @Configuration y @Bean anotaciones: Configuración de contenedor basada en Java

• @Value anotaciones: Usar @Value

Cree un archivo MongoConfig.java y agregue las siguientes clases de configuración y plantilla para configurar su conexión MongoDB:

@Configuration
public class MongoConfig {
    @Value("${mongodb.uri}")
    private String uri;
    @Value("${mongodb.database}")
    private String databaseName;
    @Bean
    public MongoClient mongoClient() {
        ConnectionString connectionString = new ConnectionString(uri);
        MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
            .applyConnectionString(connectionString)
            .build();
        return MongoClients.create(mongoClientSettings);
    }
    @Bean
    public MongoTemplate mongoTemplate() throws Exception {
        return new MongoTemplate(mongoClient(), databaseName);
    }
}

Establezca los valores de su cadena de conexión (mongodb.uri), nombre de base de datos (mongodb.database) y recuento de operaciones masivas (documentCount) en su archivo application.properties:

mongodb.database=bulk
mongodb.uri=<connection string>
documentCount=25000

Este tutorial utiliza una base de datos llamada bulk y 25 crea,000 documentos para guardar. Reemplace <connection string> el marcador con la cadena de conexión de su implementación de Atlas. Para obtener más información, consulte la sección "Crear una cadena de conexión" de esta guía.

Asignar su objeto a un documento

Asignar una clase a una colección permite que el contenedor IoC de Spring almacene objetos como documentos MongoDB. Puede usar la @Document anotación para especificar a qué colección se asigna una clase. Para obtener más información sobre cómo asignar objetos a documentos MongoDB, consulte la sección "Información general sobre anotaciones de asignación" de la documentación de Spring Data MongoDB.

La @Id anotación en el siguiente código indica que el campo del objeto id se asigna al _id campo del documento, que se utiliza como identificador único en los documentos de MongoDB. Puede elegir cualquier campo de cualquier tipo, excepto matrices, como identificador único. Para obtener más información, consulte la sección "Cómo se gestiona el campo _id en la capa de asignación" de la documentación de Spring Data MongoDB.

Utilice el siguiente código para crear un archivo Product.java para definir su clase Product y asignarlo a su colección products:

@Document("products")
public class Product {
    private static final Logger LOG = LoggerFactory.getLogger(Product.class);
    @Id
    private String id;
    private String name;
    private int qty;
    private double price;
    private Date available;
    private Date  unavailable;
    private 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;
        this.available = available;
        this.unavailable = unavailable;
        this.skuId = skuId;
    }
    public static List<Product> randomProducts(int  count) {
        Faker faker = new Faker();
        Random rand = new Random();
        List<Product> retProds = new ArrayList<>(count);
        for (int i = 0; i < count; ++i) {
            Product product = new Product(faker.animal().name(),
                    1 + rand.nextInt(998),
                    10.0 + rand.nextInt(9999),
                    new Date(), new Date(),
                    faker.idNumber().valid());
            retProds.add(product);
        }
        return retProds;
    }
    // Getters and setters
}

La clase Product incluye un método estático que genera una matriz de objetos Product. También puede definir métodos getter y setter para los campos.

Define un repositorio para almacenar tus productos

El ProductRepository objeto gestionará una colección de Product objetos. Su ProductRepository objeto debe inyectarse con el MongoTemplate bean generado en la MongoConfig clase. Al usar la @Autowired anotación con un constructor que incluye mongoTemplate como argumento, el contenedor de Spring utiliza la inyección de constructor para inyectar una mongoTemplate dependencia. Para más información sobre la inyección de constructor, consulte la sección "Inyección de dependencias basada en constructor" de la documentación de Spring Framework.

Utilice el siguiente código para crear el archivo ProductRepository.java y definir su clase ProductRepository para administrar una colección de Product objetos:

@Repository
public class ProductRepository {
    private static final Logger LOG = LoggerFactory
            .getLogger(ProductRepository.class);
    private final MongoTemplate mongoTemplate;
    @Autowired
    public ProductRepository(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, Product.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(Product.class);
        LOG.info("Dropped!");
        Instant start = Instant.now();
        mongoTemplate.setWriteConcern(WriteConcern.W1.withJournal(true));
        List<Product> productList = Product.randomProducts(count);
        BulkOperations bulkInsertion = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, Product.class);
        bulkInsertion.insert(productList);
        BulkWriteResult bulkWriteResult = bulkInsertion.execute();
        LOG.info("Bulk insert of " + bulkWriteResult.getInsertedCount() + " documents completed in " + Duration.between(start, Instant.now()).toMillis() + " milliseconds");
        return bulkWriteResult.getInsertedCount();
    }
}

El método bulkInsertProducts() utiliza inserciones masivas desordenadas, lo que puede mejorar el rendimiento al no garantizar el orden de las operaciones.

Realizar una operación masiva

La clase principal de la aplicación activa ProductRepository para generar la cantidad especificada de objetos Product y guardarlos en la base de datos MongoDB. Utiliza la anotación @Autowired para inyectar un ProductRepository e implementa el registro.

Agregue el siguiente código a su clase principal para ejecutar su aplicación:

@SpringBootApplication
public class SpringDataBulkInsertApplication implements CommandLineRunner {
    @Value("${documentCount}")
    private int count;
    private static final Logger LOG = LoggerFactory
            .getLogger(SpringDataBulkInsertApplication.class);
    @Autowired
    private ProductRepository 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(0);
    }
}