Erste Schritte mit Spring Boot oder .NET-Entwicklerteil: Erstellen einer Produktentitäts-CRUD-Anwendung in Spring Boot

Nachdem wir uns im vorherigen Beitrag mit den Grundlagen von Spring Boot 3 befasst haben, wollen wir tiefer eintauchen, indem wir eine Produktentitäts-CRUD-Operation (Erstellen, Lesen, Aktualisieren, Löschen) implementieren. Unterwegs vergleichen wir die Kernkonzepte von Spring Boot mit ihren .NET Core-Gegenstücken, um .NET-Entwicklern dabei zu helfen, die Lücke beim Übergang zum Java-Ökosystem zu schließen.

Einrichten des Projekts

Bevor Sie beginnen, stellen Sie sicher, dass Sie über ein Spring Boot-Projekt mit den folgenden Abhängigkeiten verfügen:

• Spring Web: Zum Erstellen von REST-APIs.
• Spring Data JPA: Für Datenbankinteraktionen.
• PostgreSQL-Treiber: Zur Verbindung mit einer PostgreSQL-Datenbank.

PostgreSQL lokal mit Docker ausführen

Um PostgreSQL lokal auszuführen, verwenden Sie Docker, um schnell eine Instanz einzurichten:

1. PostgreSQL-Image abrufen:
   

   docker pull postgres
   

2. Führen Sie einen PostgreSQL-Container aus:
   

   docker run --name postgres-db -e POSTGRES_PASSWORD=yourpassword -e POSTGRES_USER=yourusername -e POSTGRES_DB=mydatabase -p 5432:5432 -d postgres
   

   Ersetzen Sie Ihren Benutzernamen, Ihr Passwort und meine Datenbank durch Ihren gewünschten Benutzernamen, Ihr Passwort und Ihren gewünschten Datenbanknamen.

3. Überprüfen Sie, ob die Datenbank ausgeführt wird:
   

   docker ps
   

4. Verwenden Sie einen Datenbank-Client (z. B. DBeaver, pgAdmin oder psql), um eine Verbindung zu localhost:5432 herzustellen und sicherzustellen, dass auf Ihre Datenbank zugegriffen werden kann.

Aktualisieren Sie die pom.xml-Datei

Wenn Sie Maven verwenden, fügen Sie die folgenden Abhängigkeiten in Ihre pom.xml-Datei ein, um sicherzustellen, dass alle erforderlichen Bibliotheken verfügbar sind:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.5.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Stellen Sie außerdem sicher, dass das folgende Plugin zum Erstellen des Projekts enthalten ist:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Vergleich mit .NET Core:
In .NET Core werden Paketverweise mithilfe der csproj-Datei verwaltet. Äquivalente Abhängigkeiten für eine PostgreSQL-gestützte Web-API könnten wie folgt aussehen:

<ItemGroup>
  <PackageReference Include="Microsoft.AspNetCore.App" />
  <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.0" />
</ItemGroup>

PostgreSQL-Datenbank konfigurieren

Aktualisieren Sie Ihre application.yml-Datei, um eine Verbindung zu einer PostgreSQL-Datenbank herzustellen:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydatabase
    username: yourusername
    password: yourpassword
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: update

Ersetzen Sie meine Datenbank, Ihren Benutzernamen und Ihr Passwort durch Ihre tatsächlichen PostgreSQL-Datenbankdetails. Die Einstellung ddl-auto=update stellt sicher, dass Hibernate Tabellen basierend auf Ihren Entitätsdefinitionen automatisch erstellt oder aktualisiert.

Vergleich mit .NET Core:
In .NET Core würden sich ähnliche Konfigurationen in appsettings.json:
befinden

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=mydatabase;Username=yourusername;Password=yourpassword"
  },
  "EntityFramework": {
    "MigrationsAssembly": "YourProjectName"
  }
}

Übersicht über die Projektstruktur

Spring Boot-Projekte organisieren Code in Paketen:

• Entität: Enthält Datenmodelle.
• Repository: Schnittstellen für Datenbankoperationen.
• Controller: REST-Endpunkte.
• Dienst (optional): Geschäftslogik.

Diese Struktur ähnelt den typischen Ebenen in einem .NET Core-Projekt: Modelle, Daten/Repositorys, Controller und Dienste.

Schritt 1: Definieren Sie die Produkteinheit

In Spring Boot stellen Entitäten Datenbanktabellen dar, ähnlich wie Modelle in Entity Framework Core. Verwenden Sie Annotationen wie @Entity und @Id, um die Klasse einer Tabelle zuzuordnen:

docker pull postgres

.NET Core-Äquivalent

docker run --name postgres-db -e POSTGRES_PASSWORD=yourpassword -e POSTGRES_USER=yourusername -e POSTGRES_DB=mydatabase -p 5432:5432 -d postgres

Schritt 2: Erstellen Sie ein Repository

In Spring Boot sind Repositorys Schnittstellen, die JpaRepository erweitern. Sie bieten integrierte CRUD-Operationen, ähnlich wie DbContext in EF Core.

docker ps

.NET Core-Äquivalent

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.5.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Schritt 3: Implementieren Sie eine Serviceschicht (optional)

Die Serviceschicht verwaltet die Geschäftslogik. Dies ist zwar optional, empfiehlt sich jedoch für größere Anwendungen.

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

.NET Core-Äquivalent

<ItemGroup>
  <PackageReference Include="Microsoft.AspNetCore.App" />
  <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.0" />
</ItemGroup>

Schritt 4: Erstellen Sie den Controller

Controller verarbeiten HTTP-Anfragen, genau wie in ASP.NET Core.

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydatabase
    username: yourusername
    password: yourpassword
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: update

.NET Core-Äquivalent

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=mydatabase;Username=yourusername;Password=yourpassword"
  },
  "EntityFramework": {
    "MigrationsAssembly": "YourProjectName"
  }
}

Schritt 5: Testen Sie Ihre API

Führen Sie Ihre Anwendung aus und testen Sie die Endpunkte mit Tools wie Postman oder cURL. Stellen Sie sicher, dass Ihre PostgreSQL-Datenbank ausgeführt und ordnungsgemäß konfiguriert ist.

Sobald die Anwendung läuft, testen Sie die CRUD-Endpunkte mit Postman oder cURL. Stellen Sie sicher, dass PostgreSQL ausgeführt und korrekt konfiguriert ist.

Endpunkte mit Postman testen:

• GET /api/products: Alle Produkte abrufen.
• GET /api/products/{id}: Ein einzelnes Produkt anhand der ID abrufen.
• POST /api/products: Erstellen Sie ein neues Produkt.
• DELETE /api/products/{id}: Ein Produkt anhand der ID löschen.

Wichtige Vergleiche

Feature	Spring Boot 3	.NET Core
Dependency Injection	Built-in with @Autowired or constructor injection	Built-in with AddScoped, AddSingleton
ORM Tool	Spring Data JPA	Entity Framework Core
Routing	@RequestMapping, @GetMapping	[Route], [HttpGet]
Middleware	Spring Interceptors	ASP.NET Middleware
Response Handling	ResponseEntity	IActionResult

Fazit

Das Erstellen einer CRUD-Anwendung in Spring Boot ist einfach, insbesondere für diejenigen, die mit .NET Core vertraut sind. Die Prinzipien der Abhängigkeitsinjektion, ORM und RESTful APIs sind in beiden Ökosystemen ähnlich. Dieser Leitfaden ist nur der Anfang – zukünftige Beiträge werden sich mit Lombok-Integration, Swagger/OpenAPI, Validierung, Fehlerbehandlung und Datenbankmigrationen befassen. Bleiben Sie dran!

Viel Spaß beim Codieren!

---

Referenzen

1. Spring Boot-Dokumentation: https://spring.io/projects/spring-boot
2. PostgreSQL-Dokumentation: https://www.postgresql.org/docs/
3. Spring Data JPA-Dokumentation: https://spring.io/projects/spring-data-jpa
4. .NET Core-Dokumentation: https://docs.microsoft.com/en-us/aspnet/core/?view=aspnetcore-7.0

Das obige ist der detaillierte Inhalt vonErste Schritte mit Spring Boot oder .NET-Entwicklerteil: Erstellen einer Produktentitäts-CRUD-Anwendung in Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!