Spring Boot 4 Complete Guide · Lezione

Integrazione di database NoSQL

Imparare a integrare e utilizzare database NoSQL come MongoDB o Redis con Spring Data.

Integrazione di database NoSQL è una lezione Spring Boot 4 Complete Guide gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Spring Boot 4 Complete Guide, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Spring Boot 4 Complete Guide include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Intro to NoSQL Databases

Traditional databases (like SQL) store data in structured tables. NoSQL databases offer a flexible alternative, ideal for handling large volumes of unstructured or semi-structured data.

Non-relational: No fixed schema.
Scalable: Easily scale horizontally.
Diverse Models: Document, Key-Value, Graph, Column-Family.

They are great for big data, real-time web apps, and microservices.

Spring Data's Role in NoSQL

Just like with JPA, Spring Data provides a consistent, familiar programming model for interacting with various NoSQL databases.

It simplifies data access by:

Reducing boilerplate code.
Offering repository interfaces.
Handling database-specific operations.

You get the Spring experience even with non-relational stores!

Our NoSQL Example: MongoDB

There are many NoSQL databases, like Redis (key-value), Cassandra (column-family), and Neo4j (graph). For this lesson, we'll focus on MongoDB, a popular document-oriented database.

In MongoDB, data is stored in flexible, JSON-like documents called BSON, grouped into collections.

Add MongoDB Dependency

First, we need to add the Spring Data MongoDB starter dependency to our project. This pulls in all necessary libraries to connect to MongoDB.

For Maven, add this to your pom.xml:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

Configure MongoDB Connection

Next, tell Spring Boot how to connect to your MongoDB instance. You'll typically do this in your application.properties or application.yml file.

Here's a basic setup for a local MongoDB:

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=mydatabase

Define Your MongoDB Document

In MongoDB, data is stored in documents. We represent these documents in Java using simple POJOs (Plain Old Java Objects). Use Spring Data MongoDB annotations like @Document and @Id.

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "products")
public class Product {
  @Id
  private String id;
  private String name;
  private double price;

  public Product(String name, double price) {
    this.name = name;
    this.price = price;
  }

  // Getters and Setters (omitted for brevity)
  public String getId() { return id; }
  public void setId(String id) { this.id = id; }
  public String getName() { return name; }
  public void setName(String name) { this.name = name; }
  public double getPrice() { return price; }
  public void setPrice(double price) { this.price = price; }

  @Override
  public String toString() {
    return "Product{id='" + id + "', name='" + name + "', price=" + price + '}';
  }
}

Create a MongoRepository

Spring Data MongoDB makes interacting with your documents easy through repository interfaces. Extend MongoRepository, specifying your document type and its ID type.

This gives you basic CRUD methods out-of-the-box!

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductRepository extends MongoRepository<Product, String> {
  // Spring Data automatically generates methods based on method names
  Product findByName(String name);
}

Basic CRUD Operations

With MongoRepository, you can perform common operations:

Save: repository.save(product) to insert or update.
Find: repository.findById(id) to get a document by ID.
Find All: repository.findAll() to retrieve all documents.
Delete: repository.deleteById(id) to remove a document.

You can also define custom queries by simply declaring method names!

MongoDB Integration Demo

Let's put it all together! This Spring Boot application saves a product, finds it, and prints its details. Make sure MongoDB is running locally.

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

@SpringBootApplication
public class MongoDemoApplication {

  public static void main(String[] args) {
    SpringApplication.run(MongoDemoApplication.class, args);
  }

  @Bean
  public CommandLineRunner demo(ProductRepository repository) {
    return (args) -> {
      System.out.println("--- MongoDB Demo ---");

      // Clear existing data (optional)
      repository.deleteAll();

      // Save a new product
      Product product1 = new Product("Laptop Pro", 1200.00);
      repository.save(product1);
      System.out.println("Saved: " + product1);

      // Find by name
      Product foundProduct = repository.findByName("Laptop Pro");
      System.out.println("Found by name: " + foundProduct);

      // Find all products
      System.out.println("All products:");
      repository.findAll().forEach(System.out::println);

      System.out.println("--- Demo End ---");
    };
  }

  // Nested Document class
  @Document(collection = "products")
  public static class Product {
    @Id
    private String id;
    private String name;
    private double price;

    public Product(String name, double price) {
      this.name = name;
      this.price = price;
    }

    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }

    @Override
    public String toString() {
      return "Product{id='" + id + "', name='" + name + "', price=" + price + '}';
    }
  }

  // Nested Repository interface
  @Repository
  public interface ProductRepository extends MongoRepository<Product, String> {
    Product findByName(String name);
  }
}

Quick Check: NoSQL Repositories

You've seen how Spring Data simplifies NoSQL interactions. Which annotation marks a class as a MongoDB document in Spring Data?

Recap: NoSQL with Spring Data

Great job! You've learned how to integrate NoSQL databases using Spring Data. We covered:

The purpose of NoSQL databases.
Adding the MongoDB starter dependency.
Configuring connection properties.
Creating @Document classes and MongoRepository interfaces.
Performing basic CRUD operations.

Spring Data makes NoSQL as easy to use as traditional SQL databases!

Domande Frequenti

La lezione «Integrazione di database NoSQL» è gratuita?

Sì — il testo completo di «Integrazione di database NoSQL» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Spring Boot 4 Complete Guide, passa a CoddyKit PRO. Il corso Spring Boot 4 Complete Guide include 4 lezioni in totale.

Cosa imparerò in «Integrazione di database NoSQL»?

Imparare a integrare e utilizzare database NoSQL come MongoDB o Redis con Spring Data. Eserciti Spring Boot 4 Complete Guide con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Spring Boot 4 Complete Guide?

Non è richiesta alcuna esperienza precedente. Spring Boot 4 Complete Guide su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Integrazione di database NoSQL»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Spring Boot 4 Complete Guide?

Sì. Ogni lezione Spring Boot 4 Complete Guide include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Spring Boot 4 Complete Guide