Erstellen einer Benutzer-CRUD-Anwendung mit Spring Boot und Docker

Einführung

Spring Boot ist ein Framework, das die Entwicklung produktionsbereiter Anwendungen mithilfe des Spring-Frameworks vereinfacht. Es bietet eine Reihe von Tools und Konventionen, mit denen Sie Anwendungen schnell und effizient erstellen können. Mit Spring Boot können Sie ganz einfach eigenständige Anwendungen in Produktionsqualität mit minimaler Konfiguration erstellen.

Diese Anleitung führt Sie durch die Erstellung einer einfachen Benutzer-CRUD-Anwendung (Erstellen, Lesen, Aktualisieren, Löschen) mit Spring Boot. Wir werden die Anwendung auch mit Docker containerisieren, um die Konsistenz in verschiedenen Umgebungen sicherzustellen.

Voraussetzungen

Stellen Sie sicher, dass Folgendes installiert ist:

• Java JDK 11 oder höher
• Maven
• Docker
• Git

Schritt 1: Erstellen Sie ein neues Spring Boot-Projekt

Generieren Sie das Projekt

Verwenden Sie Spring Initializr, um ein neues Spring Boot-Projekt zu generieren:

• Projekt: Maven-Projekt
• Sprache: Java
• Spring Boot: 3.2.0
• Gruppe: com.example
• Artefakt: benutzerschädigend
• Abhängigkeiten: Spring Web, Spring Data JPA, H2-Datenbank

Klicken Sie auf „Generieren“, um das Projekt herunterzuladen, und entpacken Sie es dann.

Navigieren Sie zum Projektverzeichnis

cd user-crud

Schritt 2: Definieren Sie die Benutzerentität

Erstellen Sie die Entitätsklasse

Erstellen Sie eine neue Java-Klasse mit dem Namen User.java in 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;
    }
}

Schritt 3: Erstellen Sie das Benutzer-Repository

Erstellen Sie die Repository-Schnittstelle

Erstellen Sie eine neue Java-Schnittstelle mit dem Namen UserRepository.java in src/main/java/com/example/usercrud:

package com.example.usercrud;

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

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

Schritt 4: Erstellen Sie den Benutzercontroller

Erstellen Sie den REST-Controller

Erstellen Sie eine neue Java-Klasse mit dem Namen UserController.java in 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();
    }
}

Schritt 5: Erstellen Sie eine Docker-Datei

Fügen Sie eine Docker-Datei hinzu

Erstellen Sie im Stammverzeichnis Ihres Projekts eine Datei mit dem Namen Dockerfile mit folgendem Inhalt:

# 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"]

Erstellen Sie das Docker-Image

Verpacken Sie zunächst Ihre Anwendung mit Maven:

./mvnw clean package

Dann erstellen Sie das Docker-Image:

docker build -t user-crud .

Schritt 6: Führen Sie den Docker-Container aus

Führen Sie den Container aus

Verwenden Sie den folgenden Befehl, um Ihren Docker-Container auszuführen:

docker run -p 8080:8080 user-crud

Überprüfen Sie die Anwendung

Besuchen Sie http://localhost:8080/api/users, um sicherzustellen, dass die Anwendung im Docker-Container ordnungsgemäß ausgeführt wird. Sie können Tools wie Curl oder Postman verwenden, um die CRUD-Endpunkte zu testen.

Abschluss

Sie haben mit Spring Boot erfolgreich eine einfache User CRUD-Anwendung erstellt, sie mit Docker in einen Container verpackt und ihre Funktionsfähigkeit überprüft. Mit diesem Setup können Sie Ihre Anwendung konsistent in verschiedenen Umgebungen bereitstellen und verwalten. Sie können dieses Beispiel um zusätzliche Funktionen erweitern oder es in ein größeres System integrieren.
Fühlen Sie sich frei, uns mit Ihren Fragen zu kontaktieren... Viel Spaß beim Programmieren!

Weitere Informationen finden Sie unter:

• Spring Boot-Dokumentation
• Docker-Dokumentation

Das obige ist der detaillierte Inhalt vonErstellen einer Benutzer-CRUD-Anwendung mit Spring Boot und Docker. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!