Développement backend Java : création d'API réactives avec Akka HTTP

Dans le développement Web d’aujourd’hui, la programmation réactive devient de plus en plus importante. Akka HTTP est un framework HTTP hautes performances basé sur Akka, adapté à la création d'API réactives de style REST. Cet article expliquera comment utiliser Akka HTTP pour créer une API réactive, tout en fournissant quelques exemples pratiques. Commençons !

1. Pourquoi choisir Akka HTTP

Lors du développement d'une API réactive, il est très important de choisir le bon framework. Akka HTTP est un très bon choix car il présente les avantages suivants :

1.1 Responsive et non bloquant

Akka HTTP est un framework très responsive qui permet de gérer un grand nombre de demandes sans bloquer votre candidature. Il utilise le modèle Actor, ce qui signifie que vous pouvez utiliser des opérations asynchrones pour répondre rapidement aux demandes tout en gardant votre application hautement évolutive.

1.2 Hautes performances

Puisqu'il est construit sur le framework Akka, Akka HTTP est capable de fournir des performances plus rapides. En effet, il est capable de tirer pleinement parti de plusieurs processeurs et cœurs et convient aux situations dans lesquelles une simultanéité élevée est utilisée.

1.3 Facile à utiliser et à configurer

Akka HTTP est très simple à configurer et à utiliser. Il fournit un ensemble d'outils puissants qui vous permettent de configurer et de gérer rapidement votre API. Vous pouvez également écrire votre code en Scala ou Java.

2. Créer une API réactive

Ensuite, nous montrerons comment créer une API réactive à l'aide d'Akka HTTP. Nous allons créer une API simple pour gérer une liste d'utilisateurs.

2.1 Installation et importation

Pour utiliser Akka HTTP, vous devez ajouter les dépendances suivantes :

<dependency>
  <groupId>com.typesafe.akka</groupId>
  <artifactId>akka-actor_2.12</artifactId>
  <version>2.5.26</version>
</dependency>

<dependency>
  <groupId>com.typesafe.akka</groupId>
  <artifactId>akka-http_2.12</artifactId>
  <version>10.1.10</version>
</dependency>

Veuillez vous assurer que dans votre Maven ou Projet Gradle Incluez ces dépendances.

2.2 Créer un routeur

Nous allons maintenant créer un routeur qui recevra différentes requêtes HTTP et fournira les réponses correspondantes. Nous utiliserons la classe Route fournie par Akka HTTP pour définir notre routeur et fournir les règles de routage correspondantes.

Dans cet exemple, nous allons créer un chemin /User avec les méthodes GET, POST, PUT et DELETE. La méthode GET renverra une liste d'utilisateurs, la méthode POST créera un nouvel utilisateur, la méthode PUT mettra à jour les utilisateurs et la méthode DELETE supprimera un utilisateur.

Voici le code de notre routeur :

import akka.http.javadsl.server.Route;
import akka.http.javadsl.server.AllDirectives;

public class UserRouter extends AllDirectives {
  
  private final UserService userService;
  
  public UserRouter(UserService userService) {
    this.userService = userService;
  }
  
  public Route createRoute() {
    return route(
      pathPrefix("users", () -> route(
        get(() -> complete(userService.getUsers())),
        post(() -> entity(
          Jackson.unmarshaller(User.class), user -> complete(
            StatusCodes.CREATED, userService.createUser(user)
          )
        )),
        put(() -> entity(
          Jackson.unmarshaller(User.class), user -> complete(
            userService.updateUser(user)
          )
        )),
        delete(() -> parameter(
          "id", id -> complete(
            userService.deleteUser(Long.parseLong(id))
          )
        ))
      ))
    );
  }
  
}

2.3 Implémentation de la couche de service

Ensuite, nous devons implémenter la couche de service utilisateur. La couche de service traitera en fait toutes les demandes et utilisera une couche de stockage (telle qu'une base de données) pour gérer les données utilisateur. Dans cet exemple, nous utiliserons un simple HashMap pour stocker les données.

Voici le code de notre classe UserService :

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

public class UserService {

  private final Map<Long, User> users = new HashMap<>();
  private final AtomicLong counter = new AtomicLong();

  public User createUser(User user) {
    long id = counter.incrementAndGet();
    user.setId(id);
    users.put(id, user);
    return user;
  }

  public User updateUser(User user) {
    users.put(user.getId(), user);
    return user;
  }

  public User deleteUser(long id) {
    return users.remove(id);
  }

  public List<User> getUsers() {
    return new ArrayList<>(users.values());
  }

}

2.4 Démarrage du service

Maintenant que nous avons défini notre routeur et notre couche de service, nous Nous devons démarrer notre application. Pour cet exemple, nous allons créer une méthode principale simple qui démarrera le serveur HTTP Akka et se connectera au port spécifié. 🎜🎜 Création d'une API réactive basée sur Akka HTTP et capable de gérer une liste d'utilisateurs en utilisant différentes méthodes HTTP. Testons notre API à l'aide d'un outil comme Postman et assurons-nous qu'elle fonctionne correctement.

Méthode GET : Obtenir la liste des utilisateurs

import akka.actor.ActorSystem;
import akka.stream.ActorMaterializer;
import akka.http.javadsl.server.HttpApp;

public class Main extends HttpApp {

  private final UserService userService = new UserService();
  private final UserRouter userRouter = new UserRouter(userService);

  public static void main(String[] args) {
    Main main = new Main();
    main.startServer("localhost", 8080, ActorSystem.create(), ActorMaterializer.create());
  }

  @Override
  protected Route routes() {
    return userRouter.createRoute();
  }
  
}

Méthode POST : Créer un nouvel utilisateur

3. GET http://localhost:8080/users

Méthode PUT : Mettre à jour l'utilisateur existant

POST http://localhost:8080/users
Body: 
{
  "name": "John Smith",
  "email": "john.smith@example.com"
}

# 🎜🎜#Méthode DELETE : Supprimer l'utilisateur existant

PUT http://localhost:8080/users
Body: 
{
  "id": 1,
  "name": "John Smith",
  "email": "john.smith@example.com"
}

Résumé

Grâce à cet article, nous avons appris à construire une réaction en utilisant Akka HTTP API. Nous avons découvert les principaux avantages du framework, comment créer des couches de routeur et de service et comment les démarrer. Nous fournissons également quelques exemples de méthodes HTTP courantes afin que vous puissiez tester et utiliser votre API. J'espère que cet article vous aidera !

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!