Création d'une application CRUD utilisateur avec Spring Boot et Docker

Introduction

Spring Boot est un framework qui simplifie le développement d'applications prêtes pour la production à l'aide du framework Spring. Il fournit un ensemble d'outils et de conventions pour vous aider à créer des applications rapidement et efficacement. Avec Spring Boot, vous pouvez facilement créer des applications autonomes de niveau production avec une configuration minimale.

Ce guide vous guidera dans la création d'une application User CRUD (Créer, Lire, Mettre à jour, Supprimer) simple à l'aide de Spring Boot. Nous allons également conteneuriser l'application avec Docker pour garantir la cohérence dans les différents environnements.

Conditions préalables

Assurez-vous que les éléments suivants sont installés :

• Java JDK 11 ou supérieur
• Maven
• Docker
• Git

Étape 1 : Créer un nouveau projet Spring Boot

Générer le projet

Utilisez Spring Initializr pour générer un nouveau projet Spring Boot :

• Projet : Projet Maven
• Langage : Java
• Botte de printemps : 3.2.0
• Groupe : com.example
• Artefact : utilisateur-crud
• Dépendances : Spring Web, Spring Data JPA, base de données H2

Cliquez sur "Générer" pour télécharger le projet, puis décompressez-le.

Accédez au répertoire du projet

cd user-crud

Étape 2 : définir l'entité utilisateur

Créer la classe d'entité

Créez une nouvelle classe Java nommée User.java dans src/main/java/com/example/usercrud :

package com.example.usercrud;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

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

Étape 3 : Créer le référentiel d'utilisateurs

Créer l'interface du référentiel

Créez une nouvelle interface Java nommée UserRepository.java dans src/main/java/com/example/usercrud :

package com.example.usercrud;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

Étape 4 : Créer le contrôleur utilisateur

Créer le contrôleur REST

Créez une nouvelle classe Java nommée UserController.java dans src/main/java/com/example/usercrud :

package com.example.usercrud;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userRepository.save(user);
        return new ResponseEntity<>(savedUser, HttpStatus.CREATED);
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        Optional<User> user = userRepository.findById(id);
        return user.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        if (!userRepository.existsById(id)) {
            return ResponseEntity.notFound().build();
        }
        user.setId(id);
        User updatedUser = userRepository.save(user);
        return ResponseEntity.ok(updatedUser);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        if (!userRepository.existsById(id)) {
            return ResponseEntity.notFound().build();
        }
        userRepository.deleteById(id);
        return ResponseEntity.noContent().build();
    }
}

Étape 5 : Créer un fichier Docker

Ajouter un fichier Docker

Créez un fichier nommé Dockerfile dans le répertoire racine de votre projet avec le contenu suivant :

# Use a base image with Java 11
FROM openjdk:11-jdk-slim

# Set the working directory
WORKDIR /app

# Copy the jar file from the target directory
COPY target/user-crud-0.0.1-SNAPSHOT.jar app.jar

# Expose port 8080
EXPOSE 8080

# Run the application
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

Construire l'image Docker

Tout d'abord, packagez votre application avec Maven :

./mvnw clean package

Ensuite, créez l'image Docker :

docker build -t user-crud .

Étape 6 : Exécutez le conteneur Docker

Exécuter le conteneur

Utilisez la commande suivante pour exécuter votre conteneur Docker :

docker run -p 8080:8080 user-crud

Vérifiez la demande

Visitez http://localhost:8080/api/users pour vous assurer que l'application s'exécute correctement dans le conteneur Docker. Vous pouvez utiliser des outils comme curl ou Postman pour tester les points de terminaison CRUD.

Conclusion

Vous avez réussi à créer une application User CRUD simple avec Spring Boot, à la conteneuriser à l'aide de Docker et à vérifier son fonctionnement. Cette configuration vous permet de déployer et de gérer votre application de manière cohérente dans différents environnements. Vous pouvez étendre cet exemple avec des fonctionnalités supplémentaires ou l'intégrer dans un système plus grand.
N'hésitez pas à nous poser vos questions... Happy Coding !

Pour plus d'informations, reportez-vous à :

• Documentation Spring Boot
• Documentation Docker

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!