Premiers pas avec Spring Boot ou .NET Developers Part Création d'une application CRUD d'entité de produit dans Spring Boot

Après avoir exploré les bases de Spring Boot 3 dans l'article précédent, approfondissons en implémentant une opération CRUD (Créer, Lire, Mettre à jour, Supprimer) d'entité Produit. En cours de route, nous comparerons les concepts de base de Spring Boot avec leurs homologues .NET Core pour aider à combler le fossé entre les développeurs .NET en transition vers l'écosystème Java.

Mise en place du projet

Avant de commencer, assurez-vous d'avoir un projet Spring Boot prêt avec les dépendances suivantes :

• Spring Web : pour créer des API REST.
• Spring Data JPA : pour les interactions avec la base de données.
• Pilote PostgreSQL : Pour se connecter à une base de données PostgreSQL.

Exécuter PostgreSQL localement à l'aide de Docker

Pour exécuter PostgreSQL localement, utilisez Docker pour configurer rapidement une instance :

1. Extraire l'image PostgreSQL :
   

   docker pull postgres
   

2. Exécutez un conteneur PostgreSQL :
   

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

   Remplacez votre nom d'utilisateur, votre mot de passe et ma base de données par le nom d'utilisateur, le mot de passe et le nom de la base de données souhaités.

3. Vérifiez que la base de données est en cours d'exécution :
   

   docker ps
   

4. Utilisez un client de base de données (par exemple, DBeaver, pgAdmin ou psql) pour vous connecter à localhost:5432 et vérifiez que votre base de données est accessible.

Mettre à jour le fichier pom.xml

Si vous utilisez Maven, incluez les dépendances suivantes dans votre fichier pom.xml pour vous assurer que toutes les bibliothèques nécessaires sont disponibles :

<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>

Assurez-vous également que le plugin suivant est inclus pour créer le projet :

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

Comparaison avec .NET Core :
Dans .NET Core, les références de packages sont gérées à l’aide du fichier csproj. Les dépendances équivalentes pour une API Web basée sur PostgreSQL pourraient ressembler à ceci :

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

Configurer la base de données PostgreSQL

Mettez à jour votre fichier application.yml pour vous connecter à une base de données PostgreSQL :

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

Remplacez ma base de données, votre nom d'utilisateur et votre mot de passe par les détails réels de votre base de données PostgreSQL. Le paramètre ddl-auto=update garantit qu'Hibernate crée ou met à jour automatiquement les tables en fonction des définitions de vos entités.

Comparaison avec .NET Core :
Dans .NET Core, des configurations similaires résideraient dans appsettings.json :

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

Aperçu de la structure du projet

Les projets Spring Boot organisent le code en packages :

• entité : contient des modèles de données.
• référentiel : Interfaces pour les opérations de base de données.
• contrôleur : points de terminaison REST.
• service (facultatif) : Logique métier.

Cette structure est similaire aux couches typiques d'un projet .NET Core : modèles, données/dépôts, contrôleurs et services.

Étape 1 : Définir l'entité produit

Dans Spring Boot, les entités représentent des tables de base de données, similaires aux modèles dans Entity Framework Core. Utilisez des annotations telles que @Entity et @Id pour mapper la classe à une table :

docker pull postgres

Équivalent .NET Core

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

Étape 2 : Créer un référentiel

Dans Spring Boot, les référentiels sont des interfaces étendant JpaRepository. Ils fournissent des opérations CRUD intégrées, semblables à DbContext dans EF Core.

docker ps

Équivalent .NET Core

<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>

Étape 3 : implémenter une couche de service (facultatif)

La couche de service gère la logique métier. Bien que facultatif, il s’agit d’une bonne pratique pour les applications plus volumineuses.

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

Équivalent .NET Core

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

Étape 4 : Construire le contrôleur

Les contrôleurs gèrent les requêtes HTTP, tout comme dans 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

Équivalent .NET Core

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

Étape 5 : tester votre API

Exécutez votre application et testez les points de terminaison à l'aide d'outils comme Postman ou cURL. Assurez-vous que votre base de données PostgreSQL est en cours d'exécution et correctement configurée.

Une fois l'application opérationnelle, testez les points de terminaison CRUD avec Postman ou cURL. Assurez-vous que PostgreSQL est en cours d'exécution et correctement configuré.

Test des points de terminaison avec Postman :

• GET /api/products : récupère tous les produits.
• GET /api/products/{id} : récupère un seul produit par ID.
• POST /api/products : Créer un nouveau produit.
• DELETE /api/products/{id} : Supprimer un produit par ID.

Comparaisons clés

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

Conclusion

Créer une application CRUD dans Spring Boot est simple, en particulier pour ceux qui connaissent .NET Core. Les principes de l'injection de dépendances, de l'ORM et des API RESTful sont similaires dans les deux écosystèmes. Ce guide n'est qu'un début : les prochains articles couvriront l'intégration de Lombok, Swagger/OpenAPI, la validation, la gestion des erreurs et les migrations de bases de données. Restez à l'écoute !

Bon codage !

---

Références

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

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!