Créons une API REST en utilisant SpringBoot + MongoDB

Quel est cet article?

Ceci est une page pratique pour créer une API REST à l'aide de Spring Boot en utilisant MongoDB comme magasin de données. Comme il s'agit d'une course d'entraînement, nous visons à rendre l'expérience facile en résumant les procédures en séquence et en les copiant.

Le contenu lui-même est presque le copier-coller suivant. Je voulais utiliser Gradle, donc j'ai un peu changé le contenu. https://stackabuse.com/spring-data-mongodb-tutorial/

supposition

• Ont touché Java
• Peut utiliser IntelliJ IDEA
• Savoir ce qu'est l'API REST
• Peut utiliser Postman
• Veuillez vous référer à cette zone: https://qiita.com/notch0314/items/97c7d1bb565fdae4a712
• Ce que vous savez sur NoSQL / MongoDB

Aperçu de la mise en œuvre

Créez une API REST à l'aide de Spring Boot. Utilisez MongoDB pour le magasin de données et les données CRUD MongoDB sur demande

Le produit fini est répertorié sur le GitHub ci-dessous, veuillez donc vous y référer s'il ne fonctionne pas. https://github.com/theMistletoe/MongoDB-SpringBoot-sample

Procédure pratique

Configuration de MongoDB

Inscrivez-vous à MongoDB https://account.mongodb.com/account/register

Après vous être inscrit, cliquez sur "Créer un cluster"

Je veux le faire gratuitement, alors choisissez GRATUIT

paramètres de cluster. Vous n'êtes pas obligé de le changer.

La construction du cluster commencera.

Après avoir créé le cluster, créez d'abord un utilisateur pour l'accès à la base de données.

Sélectionnez l'authentification par mot de passe et entrez le nom d'utilisateur et le mot de passe pour créer un utilisateur. Souvenez-vous de ce nom d'utilisateur et de ce mot de passe car vous les utiliserez plus tard.

L'utilisateur a été créé

Ensuite, configurez l'accès au réseau. Vous pouvez définir une liste blanche à l'aide d'adresses IP, alors configurez-la pour accepter n'importe quelle adresse IP pour vous entraîner. (Étant donné que la sécurité est lâche pour la pratique, veuillez arrêter de l'utiliser en production)

Cliquez sur [AUTORISER L'ACCÈS DE N'IMPORTE O] pour confirmer

Faisons une DB Cliquez sur Clusters COLLECTIONS

Cliquez sur Ajouter mes propres données

Entrez «jobs» pour le nom de la base de données et «candidat» pour le nom de la collection à créer

Après avoir créé la base de données, l'écran de la console s'affiche. Les mises à jour ultérieures des données seront reflétées ici.

C'est la fin de l'installation de MongoDB.

Construction de l'environnement Spring Boot

Accédez à Spring Initializr, définissez le modèle comme indiqué dans l'image et téléchargez le zip avec Generate.

Décompressez le zip et ouvrez-le dans IntelliJ. Tout d'abord, ouvrez application.properties et définissez les informations d'accès de MongoDB.

spring.data.mongodb.uri=mongodb+srv://user:<password>@cluster0.ayoho.mongodb.net/<dbname>?retryWrites=true&w=majority

Les paramètres de spring.data.mongodb.uri peuvent être obtenus à partir de la console MongoDB.

Utilisez le mot de passe et le nom de base de données définis lors de la configuration de MongoDB. (Si vous suivez la procédure, dbname sera "jobs")

Implémentation du programme Java

Écrivons maintenant Java. Je ne peux pas expliquer l'implémentation détaillée, alors essayez d'écrire tout en résolvant les points peu clairs. Vous pouvez le placer n'importe où, mais veuillez vous référer aux informations du package ou vous référer à GitHub.

Candidate.java

package com.example.mongoDBsample.entity;

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

@Document(collection = "candidate")
public class Candidate {
    @Id
    private String id;

    private String name;

    private double exp;

    @Indexed(unique = true)
    private String email;

    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 getExp() {
        return exp;
    }

    public void setExp(double exp) {
        this.exp = exp;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

CandidateRepository.java

package com.example.mongoDBsample.repository;

import com.example.mongoDBsample.entity.Candidate;
import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;
import java.util.Optional;

public interface CandidateRepository extends MongoRepository<Candidate, String> {
    Optional<Candidate> findByEmail(String email);

    List<Candidate> findByExpGreaterThanEqual(double exp);

    List<Candidate> findByExpBetween(double from, double to);
}

CandidateController.java

package com.example.mongoDBsample.controller;

import com.example.mongoDBsample.exception.ResourceNotFoundException;
import com.example.mongoDBsample.entity.Candidate;
import com.example.mongoDBsample.repository.CandidateRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/candidate")
public class CandidateController {

    @Autowired
    private CandidateRepository candidateRepository;

    @PostMapping
    @ResponseStatus(code = HttpStatus.CREATED)
    public Candidate add(@RequestBody Candidate candidate) {
        return candidateRepository.save(candidate);
    }

    @GetMapping
    public List<Candidate> getAll() {
        return candidateRepository.findAll();
    }

    @GetMapping(value = "/{id}")
    public Candidate getOne(@PathVariable String id) {
        return candidateRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException());
    }

    @PutMapping(value = "/{id}")
    public Candidate update(@PathVariable String id, @RequestBody Candidate updatedCandidate) {
        Candidate candidate = candidateRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException());
        candidate.setName(updatedCandidate.getName());
        candidate.setExp(updatedCandidate.getExp());
        candidate.setEmail(updatedCandidate.getEmail());
        return candidateRepository.save(candidate);
    }

    @DeleteMapping(value = "/{id}")
    @ResponseStatus(code = HttpStatus.ACCEPTED)
    public void delete(@PathVariable String id) {
        Candidate candidate = candidateRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException());
        candidateRepository.delete(candidate);
    }

    @GetMapping("/searchByEmail")
    public Candidate searchByEmail(@RequestParam(name = "email") String email) {
        return candidateRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException());

    }

    @GetMapping("/searchByExp")
    public List<Candidate> searchByExp(@RequestParam(name = "expFrom") Double expFrom, @RequestParam(name = "expTo", required = false) Double expTo) {
        List<Candidate> result = new ArrayList<>();
        if (expTo != null) {
            result = candidateRepository.findByExpBetween(expFrom, expTo);
        } else {
            result = candidateRepository.findByExpGreaterThanEqual(expFrom);
        }
        return result;
    }
}

ResourceNotFoundException.java

package com.example.mongoDBsample.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException() {
    }
}

Confirmation de la mise en œuvre

Maintenant que l'implémentation est terminée, vérifions si l'accès aux données est possible via l'API.

Lancez l'application sur IntelliJ

Ou exécutez ce qui suit dans CUI pour démarrer

./gradlew bootRun

Enregistrer l'utilisateur

Commençons par enregistrer l'utilisateur. Si vous envoyez une requête POST à http: // localhost: 8080 / candidate / avec l'objet JSON suivant attaché au corps, Les informations de l'utilisateur enregistré seront renvoyées dans la réponse.

{
    "name": "Axel",
    "exp": "10",
    "email": "[email protected]"
}

Si vous regardez la console MongoDB, vous pouvez voir que les données ont été ajoutées.

Parcourir les utilisateurs

Si vous envoyez une requête GET à http: // localhost: 8080 / candidate, tous les utilisateurs enregistrés seront renvoyés.

Mettre à jour les informations utilisateur

Dans une requête PUT à http: // localhost: 8080 / candidate / {user id} Si vous attachez l'objet JSON mis à jour au corps, les informations d'enregistrement seront mises à jour.

Supprimer l'utilisateur

En envoyant une requête DELETE à http: // localhost: 8080 / candidate / {user id} Vous pouvez supprimer l'utilisateur.

c'est tout.

Je pense que vous avez créé MongoDB / SpringBoot pour implémenter les bases d'un backend d'API REST qui vous permet d'utiliser votre magasin de données. Étendons cela ou créons une application en coopération avec le frontal!